cutego/core/core.go

// +build !minimal

package core

//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "core.h"
import "C"
import (
	"github.com/therecipe/qt"
	"reflect"
	"runtime"
	"strings"
	"unsafe"
)

func cGoUnpackString(s C.struct_QtCore_PackedString) string {
	if int(s.len) == -1 {
		return C.GoString(s.data)
	}
	return C.GoStringN(s.data, C.int(s.len))
}
func cGoUnpackBytes(s C.struct_QtCore_PackedString) []byte {
	if int(s.len) == -1 {
		gs := C.GoString(s.data)
		return *(*[]byte)(unsafe.Pointer(&gs))
	}
	return C.GoBytes(unsafe.Pointer(s.data), C.int(s.len))
}
func unpackStringList(s string) []string {
	if len(s) == 0 {
		return make([]string, 0)
	}
	return strings.Split(s, "¡¦!")
}

type QAbstractAnimation struct {
	QObject
}

type QAbstractAnimation_ITF interface {
	QObject_ITF
	QAbstractAnimation_PTR() *QAbstractAnimation
}

func (ptr *QAbstractAnimation) QAbstractAnimation_PTR() *QAbstractAnimation {
	return ptr
}

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

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

func PointerFromQAbstractAnimation(ptr QAbstractAnimation_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractAnimation_PTR().Pointer()
	}
	return nil
}

func NewQAbstractAnimationFromPointer(ptr unsafe.Pointer) (n *QAbstractAnimation) {
	n = new(QAbstractAnimation)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QAbstractAnimation__Direction
//QAbstractAnimation::Direction
type QAbstractAnimation__Direction int64

const (
	QAbstractAnimation__Forward  QAbstractAnimation__Direction = QAbstractAnimation__Direction(0)
	QAbstractAnimation__Backward QAbstractAnimation__Direction = QAbstractAnimation__Direction(1)
)

//go:generate stringer -type=QAbstractAnimation__State
//QAbstractAnimation::State
type QAbstractAnimation__State int64

const (
	QAbstractAnimation__Stopped QAbstractAnimation__State = QAbstractAnimation__State(0)
	QAbstractAnimation__Paused  QAbstractAnimation__State = QAbstractAnimation__State(1)
	QAbstractAnimation__Running QAbstractAnimation__State = QAbstractAnimation__State(2)
)

//go:generate stringer -type=QAbstractAnimation__DeletionPolicy
//QAbstractAnimation::DeletionPolicy
type QAbstractAnimation__DeletionPolicy int64

const (
	QAbstractAnimation__KeepWhenStopped   QAbstractAnimation__DeletionPolicy = QAbstractAnimation__DeletionPolicy(0)
	QAbstractAnimation__DeleteWhenStopped QAbstractAnimation__DeletionPolicy = QAbstractAnimation__DeletionPolicy(1)
)

func NewQAbstractAnimation(parent QObject_ITF) *QAbstractAnimation {
	tmpValue := NewQAbstractAnimationFromPointer(C.QAbstractAnimation_NewQAbstractAnimation(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QAbstractAnimation) CurrentLoop() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractAnimation_CurrentLoop(ptr.Pointer())))
	}
	return 0
}

//export callbackQAbstractAnimation_CurrentLoopChanged
func callbackQAbstractAnimation_CurrentLoopChanged(ptr unsafe.Pointer, currentLoop C.int) {
	if signal := qt.GetSignal(ptr, "currentLoopChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(currentLoop)))
	}

}

func (ptr *QAbstractAnimation) ConnectCurrentLoopChanged(f func(currentLoop int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentLoopChanged") {
			C.QAbstractAnimation_ConnectCurrentLoopChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentLoopChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentLoopChanged"); signal != nil {
			f := func(currentLoop int) {
				(*(*func(int))(signal))(currentLoop)
				f(currentLoop)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentLoopChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentLoopChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectCurrentLoopChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DisconnectCurrentLoopChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentLoopChanged")
	}
}

func (ptr *QAbstractAnimation) CurrentLoopChanged(currentLoop int) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_CurrentLoopChanged(ptr.Pointer(), C.int(int32(currentLoop)))
	}
}

func (ptr *QAbstractAnimation) CurrentLoopTime() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractAnimation_CurrentLoopTime(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAbstractAnimation) CurrentTime() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractAnimation_CurrentTime(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAbstractAnimation) Direction() QAbstractAnimation__Direction {
	if ptr.Pointer() != nil {
		return QAbstractAnimation__Direction(C.QAbstractAnimation_Direction(ptr.Pointer()))
	}
	return 0
}

//export callbackQAbstractAnimation_DirectionChanged
func callbackQAbstractAnimation_DirectionChanged(ptr unsafe.Pointer, newDirection C.longlong) {
	if signal := qt.GetSignal(ptr, "directionChanged"); signal != nil {
		(*(*func(QAbstractAnimation__Direction))(signal))(QAbstractAnimation__Direction(newDirection))
	}

}

func (ptr *QAbstractAnimation) ConnectDirectionChanged(f func(newDirection QAbstractAnimation__Direction)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "directionChanged") {
			C.QAbstractAnimation_ConnectDirectionChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "directionChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "directionChanged"); signal != nil {
			f := func(newDirection QAbstractAnimation__Direction) {
				(*(*func(QAbstractAnimation__Direction))(signal))(newDirection)
				f(newDirection)
			}
			qt.ConnectSignal(ptr.Pointer(), "directionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "directionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectDirectionChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DisconnectDirectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "directionChanged")
	}
}

func (ptr *QAbstractAnimation) DirectionChanged(newDirection QAbstractAnimation__Direction) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DirectionChanged(ptr.Pointer(), C.longlong(newDirection))
	}
}

//export callbackQAbstractAnimation_Duration
func callbackQAbstractAnimation_Duration(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "duration"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(0))
}

func (ptr *QAbstractAnimation) ConnectDuration(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "duration"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectDuration() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "duration")
	}
}

func (ptr *QAbstractAnimation) Duration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractAnimation_Duration(ptr.Pointer())))
	}
	return 0
}

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

}

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

		if !qt.ExistsSignal(ptr.Pointer(), "finished") {
			C.QAbstractAnimation_ConnectFinished(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "finished")))
		}

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

func (ptr *QAbstractAnimation) DisconnectFinished() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "finished")
	}
}

func (ptr *QAbstractAnimation) Finished() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Finished(ptr.Pointer())
	}
}

func (ptr *QAbstractAnimation) Group() *QAnimationGroup {
	if ptr.Pointer() != nil {
		tmpValue := NewQAnimationGroupFromPointer(C.QAbstractAnimation_Group(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractAnimation) LoopCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractAnimation_LoopCount(ptr.Pointer())))
	}
	return 0
}

//export callbackQAbstractAnimation_Pause
func callbackQAbstractAnimation_Pause(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "pause"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractAnimationFromPointer(ptr).PauseDefault()
	}
}

func (ptr *QAbstractAnimation) ConnectPause(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "pause"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "pause", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "pause", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectPause() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "pause")
	}
}

func (ptr *QAbstractAnimation) Pause() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Pause(ptr.Pointer())
	}
}

func (ptr *QAbstractAnimation) PauseDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_PauseDefault(ptr.Pointer())
	}
}

//export callbackQAbstractAnimation_Resume
func callbackQAbstractAnimation_Resume(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resume"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractAnimationFromPointer(ptr).ResumeDefault()
	}
}

func (ptr *QAbstractAnimation) ConnectResume(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resume"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "resume", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resume", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectResume() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resume")
	}
}

func (ptr *QAbstractAnimation) Resume() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Resume(ptr.Pointer())
	}
}

func (ptr *QAbstractAnimation) ResumeDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_ResumeDefault(ptr.Pointer())
	}
}

//export callbackQAbstractAnimation_SetCurrentTime
func callbackQAbstractAnimation_SetCurrentTime(ptr unsafe.Pointer, msecs C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentTime"); signal != nil {
		(*(*func(int))(signal))(int(int32(msecs)))
	} else {
		NewQAbstractAnimationFromPointer(ptr).SetCurrentTimeDefault(int(int32(msecs)))
	}
}

func (ptr *QAbstractAnimation) ConnectSetCurrentTime(f func(msecs int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentTime"); signal != nil {
			f := func(msecs int) {
				(*(*func(int))(signal))(msecs)
				f(msecs)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectSetCurrentTime() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentTime")
	}
}

func (ptr *QAbstractAnimation) SetCurrentTime(msecs int) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetCurrentTime(ptr.Pointer(), C.int(int32(msecs)))
	}
}

func (ptr *QAbstractAnimation) SetCurrentTimeDefault(msecs int) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetCurrentTimeDefault(ptr.Pointer(), C.int(int32(msecs)))
	}
}

func (ptr *QAbstractAnimation) SetDirection(direction QAbstractAnimation__Direction) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetDirection(ptr.Pointer(), C.longlong(direction))
	}
}

func (ptr *QAbstractAnimation) SetLoopCount(loopCount int) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetLoopCount(ptr.Pointer(), C.int(int32(loopCount)))
	}
}

//export callbackQAbstractAnimation_SetPaused
func callbackQAbstractAnimation_SetPaused(ptr unsafe.Pointer, paused C.char) {
	if signal := qt.GetSignal(ptr, "setPaused"); signal != nil {
		(*(*func(bool))(signal))(int8(paused) != 0)
	} else {
		NewQAbstractAnimationFromPointer(ptr).SetPausedDefault(int8(paused) != 0)
	}
}

func (ptr *QAbstractAnimation) ConnectSetPaused(f func(paused bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setPaused"); signal != nil {
			f := func(paused bool) {
				(*(*func(bool))(signal))(paused)
				f(paused)
			}
			qt.ConnectSignal(ptr.Pointer(), "setPaused", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setPaused", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectSetPaused() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setPaused")
	}
}

func (ptr *QAbstractAnimation) SetPaused(paused bool) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetPaused(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(paused))))
	}
}

func (ptr *QAbstractAnimation) SetPausedDefault(paused bool) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetPausedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(paused))))
	}
}

//export callbackQAbstractAnimation_Start
func callbackQAbstractAnimation_Start(ptr unsafe.Pointer, policy C.longlong) {
	if signal := qt.GetSignal(ptr, "start"); signal != nil {
		(*(*func(QAbstractAnimation__DeletionPolicy))(signal))(QAbstractAnimation__DeletionPolicy(policy))
	} else {
		NewQAbstractAnimationFromPointer(ptr).StartDefault(QAbstractAnimation__DeletionPolicy(policy))
	}
}

func (ptr *QAbstractAnimation) ConnectStart(f func(policy QAbstractAnimation__DeletionPolicy)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
			f := func(policy QAbstractAnimation__DeletionPolicy) {
				(*(*func(QAbstractAnimation__DeletionPolicy))(signal))(policy)
				f(policy)
			}
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectStart() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "start")
	}
}

func (ptr *QAbstractAnimation) Start(policy QAbstractAnimation__DeletionPolicy) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Start(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QAbstractAnimation) StartDefault(policy QAbstractAnimation__DeletionPolicy) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_StartDefault(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QAbstractAnimation) State() QAbstractAnimation__State {
	if ptr.Pointer() != nil {
		return QAbstractAnimation__State(C.QAbstractAnimation_State(ptr.Pointer()))
	}
	return 0
}

//export callbackQAbstractAnimation_StateChanged
func callbackQAbstractAnimation_StateChanged(ptr unsafe.Pointer, newState C.longlong, oldState C.longlong) {
	if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
		(*(*func(QAbstractAnimation__State, QAbstractAnimation__State))(signal))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	}

}

func (ptr *QAbstractAnimation) ConnectStateChanged(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
			C.QAbstractAnimation_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
			f := func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
				(*(*func(QAbstractAnimation__State, QAbstractAnimation__State))(signal))(newState, oldState)
				f(newState, oldState)
			}
			qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectStateChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DisconnectStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
	}
}

func (ptr *QAbstractAnimation) StateChanged(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_StateChanged(ptr.Pointer(), C.longlong(newState), C.longlong(oldState))
	}
}

//export callbackQAbstractAnimation_Stop
func callbackQAbstractAnimation_Stop(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "stop"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractAnimationFromPointer(ptr).StopDefault()
	}
}

func (ptr *QAbstractAnimation) ConnectStop(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectStop() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "stop")
	}
}

func (ptr *QAbstractAnimation) Stop() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Stop(ptr.Pointer())
	}
}

func (ptr *QAbstractAnimation) StopDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_StopDefault(ptr.Pointer())
	}
}

func (ptr *QAbstractAnimation) TotalDuration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractAnimation_TotalDuration(ptr.Pointer())))
	}
	return 0
}

//export callbackQAbstractAnimation_UpdateCurrentTime
func callbackQAbstractAnimation_UpdateCurrentTime(ptr unsafe.Pointer, currentTime C.int) {
	if signal := qt.GetSignal(ptr, "updateCurrentTime"); signal != nil {
		(*(*func(int))(signal))(int(int32(currentTime)))
	}

}

func (ptr *QAbstractAnimation) ConnectUpdateCurrentTime(f func(currentTime int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateCurrentTime"); signal != nil {
			f := func(currentTime int) {
				(*(*func(int))(signal))(currentTime)
				f(currentTime)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectUpdateCurrentTime() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateCurrentTime")
	}
}

func (ptr *QAbstractAnimation) UpdateCurrentTime(currentTime int) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(int32(currentTime)))
	}
}

//export callbackQAbstractAnimation_UpdateDirection
func callbackQAbstractAnimation_UpdateDirection(ptr unsafe.Pointer, direction C.longlong) {
	if signal := qt.GetSignal(ptr, "updateDirection"); signal != nil {
		(*(*func(QAbstractAnimation__Direction))(signal))(QAbstractAnimation__Direction(direction))
	} else {
		NewQAbstractAnimationFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
	}
}

func (ptr *QAbstractAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateDirection"); signal != nil {
			f := func(direction QAbstractAnimation__Direction) {
				(*(*func(QAbstractAnimation__Direction))(signal))(direction)
				f(direction)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateDirection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateDirection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectUpdateDirection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateDirection")
	}
}

func (ptr *QAbstractAnimation) UpdateDirection(direction QAbstractAnimation__Direction) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_UpdateDirection(ptr.Pointer(), C.longlong(direction))
	}
}

func (ptr *QAbstractAnimation) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_UpdateDirectionDefault(ptr.Pointer(), C.longlong(direction))
	}
}

//export callbackQAbstractAnimation_UpdateState
func callbackQAbstractAnimation_UpdateState(ptr unsafe.Pointer, newState C.longlong, oldState C.longlong) {
	if signal := qt.GetSignal(ptr, "updateState"); signal != nil {
		(*(*func(QAbstractAnimation__State, QAbstractAnimation__State))(signal))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	} else {
		NewQAbstractAnimationFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	}
}

func (ptr *QAbstractAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateState"); signal != nil {
			f := func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
				(*(*func(QAbstractAnimation__State, QAbstractAnimation__State))(signal))(newState, oldState)
				f(newState, oldState)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateState", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateState", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectUpdateState() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateState")
	}
}

func (ptr *QAbstractAnimation) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_UpdateState(ptr.Pointer(), C.longlong(newState), C.longlong(oldState))
	}
}

func (ptr *QAbstractAnimation) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_UpdateStateDefault(ptr.Pointer(), C.longlong(newState), C.longlong(oldState))
	}
}

//export callbackQAbstractAnimation_DestroyQAbstractAnimation
func callbackQAbstractAnimation_DestroyQAbstractAnimation(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractAnimation"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractAnimationFromPointer(ptr).DestroyQAbstractAnimationDefault()
	}
}

func (ptr *QAbstractAnimation) ConnectDestroyQAbstractAnimation(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractAnimation"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractAnimation", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractAnimation", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractAnimation) DisconnectDestroyQAbstractAnimation() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAbstractAnimation")
	}
}

func (ptr *QAbstractAnimation) DestroyQAbstractAnimation() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DestroyQAbstractAnimation(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractAnimation) DestroyQAbstractAnimationDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DestroyQAbstractAnimationDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QAbstractConcatenable struct {
	ptr unsafe.Pointer
}

type QAbstractConcatenable_ITF interface {
	QAbstractConcatenable_PTR() *QAbstractConcatenable
}

func (ptr *QAbstractConcatenable) QAbstractConcatenable_PTR() *QAbstractConcatenable {
	return ptr
}

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

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

func PointerFromQAbstractConcatenable(ptr QAbstractConcatenable_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractConcatenable_PTR().Pointer()
	}
	return nil
}

func NewQAbstractConcatenableFromPointer(ptr unsafe.Pointer) (n *QAbstractConcatenable) {
	n = new(QAbstractConcatenable)
	n.SetPointer(ptr)
	return
}

func (ptr *QAbstractConcatenable) DestroyQAbstractConcatenable() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QAbstractEventDispatcher struct {
	QObject
}

type QAbstractEventDispatcher_ITF interface {
	QObject_ITF
	QAbstractEventDispatcher_PTR() *QAbstractEventDispatcher
}

func (ptr *QAbstractEventDispatcher) QAbstractEventDispatcher_PTR() *QAbstractEventDispatcher {
	return ptr
}

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

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

func PointerFromQAbstractEventDispatcher(ptr QAbstractEventDispatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractEventDispatcher_PTR().Pointer()
	}
	return nil
}

func NewQAbstractEventDispatcherFromPointer(ptr unsafe.Pointer) (n *QAbstractEventDispatcher) {
	n = new(QAbstractEventDispatcher)
	n.SetPointer(ptr)
	return
}

//export callbackQAbstractEventDispatcher_AboutToBlock
func callbackQAbstractEventDispatcher_AboutToBlock(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "aboutToBlock"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractEventDispatcher) ConnectAboutToBlock(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "aboutToBlock") {
			C.QAbstractEventDispatcher_ConnectAboutToBlock(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "aboutToBlock")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "aboutToBlock"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "aboutToBlock", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "aboutToBlock", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectAboutToBlock() {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_DisconnectAboutToBlock(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "aboutToBlock")
	}
}

func (ptr *QAbstractEventDispatcher) AboutToBlock() {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_AboutToBlock(ptr.Pointer())
	}
}

//export callbackQAbstractEventDispatcher_Awake
func callbackQAbstractEventDispatcher_Awake(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "awake"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractEventDispatcher) ConnectAwake(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "awake") {
			C.QAbstractEventDispatcher_ConnectAwake(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "awake")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "awake"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "awake", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "awake", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectAwake() {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_DisconnectAwake(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "awake")
	}
}

func (ptr *QAbstractEventDispatcher) Awake() {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_Awake(ptr.Pointer())
	}
}

func (ptr *QAbstractEventDispatcher) FilterNativeEvent(eventType QByteArray_ITF, message unsafe.Pointer, result *int) bool {
	if ptr.Pointer() != nil {
		var resultC C.long
		if result != nil {
			resultC = C.long(int32(*result))
			defer func() { *result = int(int32(resultC)) }()
		}
		return int8(C.QAbstractEventDispatcher_FilterNativeEvent(ptr.Pointer(), PointerFromQByteArray(eventType), message, &resultC)) != 0
	}
	return false
}

func (ptr *QAbstractEventDispatcher) InstallNativeEventFilter(filterObj QAbstractNativeEventFilter_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_InstallNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filterObj))
	}
}

func QAbstractEventDispatcher_Instance(thread QThread_ITF) *QAbstractEventDispatcher {
	tmpValue := NewQAbstractEventDispatcherFromPointer(C.QAbstractEventDispatcher_QAbstractEventDispatcher_Instance(PointerFromQThread(thread)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QAbstractEventDispatcher) Instance(thread QThread_ITF) *QAbstractEventDispatcher {
	tmpValue := NewQAbstractEventDispatcherFromPointer(C.QAbstractEventDispatcher_QAbstractEventDispatcher_Instance(PointerFromQThread(thread)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQAbstractEventDispatcher_Interrupt
func callbackQAbstractEventDispatcher_Interrupt(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "interrupt"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractEventDispatcher) ConnectInterrupt(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "interrupt"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "interrupt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "interrupt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectInterrupt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "interrupt")
	}
}

func (ptr *QAbstractEventDispatcher) Interrupt() {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_Interrupt(ptr.Pointer())
	}
}

//export callbackQAbstractEventDispatcher_ProcessEvents
func callbackQAbstractEventDispatcher_ProcessEvents(ptr unsafe.Pointer, flags C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "processEvents"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(QEventLoop__ProcessEventsFlag) bool)(signal))(QEventLoop__ProcessEventsFlag(flags)))))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QAbstractEventDispatcher) ConnectProcessEvents(f func(flags QEventLoop__ProcessEventsFlag) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "processEvents"); signal != nil {
			f := func(flags QEventLoop__ProcessEventsFlag) bool {
				(*(*func(QEventLoop__ProcessEventsFlag) bool)(signal))(flags)
				return f(flags)
			}
			qt.ConnectSignal(ptr.Pointer(), "processEvents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "processEvents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectProcessEvents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "processEvents")
	}
}

func (ptr *QAbstractEventDispatcher) ProcessEvents(flags QEventLoop__ProcessEventsFlag) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractEventDispatcher_ProcessEvents(ptr.Pointer(), C.longlong(flags))) != 0
	}
	return false
}

//export callbackQAbstractEventDispatcher_RegisterEventNotifier
func callbackQAbstractEventDispatcher_RegisterEventNotifier(ptr unsafe.Pointer, notifier unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "registerEventNotifier"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QWinEventNotifier) bool)(signal))(NewQWinEventNotifierFromPointer(notifier)))))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QAbstractEventDispatcher) ConnectRegisterEventNotifier(f func(notifier *QWinEventNotifier) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "registerEventNotifier"); signal != nil {
			f := func(notifier *QWinEventNotifier) bool {
				(*(*func(*QWinEventNotifier) bool)(signal))(notifier)
				return f(notifier)
			}
			qt.ConnectSignal(ptr.Pointer(), "registerEventNotifier", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "registerEventNotifier", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectRegisterEventNotifier() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "registerEventNotifier")
	}
}

func (ptr *QAbstractEventDispatcher) RegisterEventNotifier(notifier QWinEventNotifier_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractEventDispatcher_RegisterEventNotifier(ptr.Pointer(), PointerFromQWinEventNotifier(notifier))) != 0
	}
	return false
}

//export callbackQAbstractEventDispatcher_RegisterSocketNotifier
func callbackQAbstractEventDispatcher_RegisterSocketNotifier(ptr unsafe.Pointer, notifier unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "registerSocketNotifier"); signal != nil {
		(*(*func(*QSocketNotifier))(signal))(NewQSocketNotifierFromPointer(notifier))
	}

}

func (ptr *QAbstractEventDispatcher) ConnectRegisterSocketNotifier(f func(notifier *QSocketNotifier)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "registerSocketNotifier"); signal != nil {
			f := func(notifier *QSocketNotifier) {
				(*(*func(*QSocketNotifier))(signal))(notifier)
				f(notifier)
			}
			qt.ConnectSignal(ptr.Pointer(), "registerSocketNotifier", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "registerSocketNotifier", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectRegisterSocketNotifier() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "registerSocketNotifier")
	}
}

func (ptr *QAbstractEventDispatcher) RegisterSocketNotifier(notifier QSocketNotifier_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_RegisterSocketNotifier(ptr.Pointer(), PointerFromQSocketNotifier(notifier))
	}
}

func (ptr *QAbstractEventDispatcher) RegisterTimer3(interval int, timerType Qt__TimerType, object QObject_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractEventDispatcher_RegisterTimer3(ptr.Pointer(), C.int(int32(interval)), C.longlong(timerType), PointerFromQObject(object))))
	}
	return 0
}

//export callbackQAbstractEventDispatcher_RegisterTimer4
func callbackQAbstractEventDispatcher_RegisterTimer4(ptr unsafe.Pointer, timerId C.int, interval C.int, timerType C.longlong, object unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "registerTimer4"); signal != nil {
		(*(*func(int, int, Qt__TimerType, *QObject))(signal))(int(int32(timerId)), int(int32(interval)), Qt__TimerType(timerType), NewQObjectFromPointer(object))
	}

}

func (ptr *QAbstractEventDispatcher) ConnectRegisterTimer4(f func(timerId int, interval int, timerType Qt__TimerType, object *QObject)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "registerTimer4"); signal != nil {
			f := func(timerId int, interval int, timerType Qt__TimerType, object *QObject) {
				(*(*func(int, int, Qt__TimerType, *QObject))(signal))(timerId, interval, timerType, object)
				f(timerId, interval, timerType, object)
			}
			qt.ConnectSignal(ptr.Pointer(), "registerTimer4", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "registerTimer4", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectRegisterTimer4() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "registerTimer4")
	}
}

func (ptr *QAbstractEventDispatcher) RegisterTimer4(timerId int, interval int, timerType Qt__TimerType, object QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_RegisterTimer4(ptr.Pointer(), C.int(int32(timerId)), C.int(int32(interval)), C.longlong(timerType), PointerFromQObject(object))
	}
}

//export callbackQAbstractEventDispatcher_RemainingTime
func callbackQAbstractEventDispatcher_RemainingTime(ptr unsafe.Pointer, timerId C.int) C.int {
	if signal := qt.GetSignal(ptr, "remainingTime"); signal != nil {
		return C.int(int32((*(*func(int) int)(signal))(int(int32(timerId)))))
	}

	return C.int(int32(0))
}

func (ptr *QAbstractEventDispatcher) ConnectRemainingTime(f func(timerId int) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "remainingTime"); signal != nil {
			f := func(timerId int) int {
				(*(*func(int) int)(signal))(timerId)
				return f(timerId)
			}
			qt.ConnectSignal(ptr.Pointer(), "remainingTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "remainingTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectRemainingTime() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "remainingTime")
	}
}

func (ptr *QAbstractEventDispatcher) RemainingTime(timerId int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractEventDispatcher_RemainingTime(ptr.Pointer(), C.int(int32(timerId)))))
	}
	return 0
}

func (ptr *QAbstractEventDispatcher) RemoveNativeEventFilter(filter QAbstractNativeEventFilter_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_RemoveNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filter))
	}
}

//export callbackQAbstractEventDispatcher_UnregisterEventNotifier
func callbackQAbstractEventDispatcher_UnregisterEventNotifier(ptr unsafe.Pointer, notifier unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "unregisterEventNotifier"); signal != nil {
		(*(*func(*QWinEventNotifier))(signal))(NewQWinEventNotifierFromPointer(notifier))
	}

}

func (ptr *QAbstractEventDispatcher) ConnectUnregisterEventNotifier(f func(notifier *QWinEventNotifier)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "unregisterEventNotifier"); signal != nil {
			f := func(notifier *QWinEventNotifier) {
				(*(*func(*QWinEventNotifier))(signal))(notifier)
				f(notifier)
			}
			qt.ConnectSignal(ptr.Pointer(), "unregisterEventNotifier", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "unregisterEventNotifier", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectUnregisterEventNotifier() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "unregisterEventNotifier")
	}
}

func (ptr *QAbstractEventDispatcher) UnregisterEventNotifier(notifier QWinEventNotifier_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_UnregisterEventNotifier(ptr.Pointer(), PointerFromQWinEventNotifier(notifier))
	}
}

//export callbackQAbstractEventDispatcher_UnregisterSocketNotifier
func callbackQAbstractEventDispatcher_UnregisterSocketNotifier(ptr unsafe.Pointer, notifier unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "unregisterSocketNotifier"); signal != nil {
		(*(*func(*QSocketNotifier))(signal))(NewQSocketNotifierFromPointer(notifier))
	}

}

func (ptr *QAbstractEventDispatcher) ConnectUnregisterSocketNotifier(f func(notifier *QSocketNotifier)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "unregisterSocketNotifier"); signal != nil {
			f := func(notifier *QSocketNotifier) {
				(*(*func(*QSocketNotifier))(signal))(notifier)
				f(notifier)
			}
			qt.ConnectSignal(ptr.Pointer(), "unregisterSocketNotifier", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "unregisterSocketNotifier", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectUnregisterSocketNotifier() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "unregisterSocketNotifier")
	}
}

func (ptr *QAbstractEventDispatcher) UnregisterSocketNotifier(notifier QSocketNotifier_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_UnregisterSocketNotifier(ptr.Pointer(), PointerFromQSocketNotifier(notifier))
	}
}

//export callbackQAbstractEventDispatcher_UnregisterTimer
func callbackQAbstractEventDispatcher_UnregisterTimer(ptr unsafe.Pointer, timerId C.int) C.char {
	if signal := qt.GetSignal(ptr, "unregisterTimer"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int) bool)(signal))(int(int32(timerId))))))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QAbstractEventDispatcher) ConnectUnregisterTimer(f func(timerId int) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "unregisterTimer"); signal != nil {
			f := func(timerId int) bool {
				(*(*func(int) bool)(signal))(timerId)
				return f(timerId)
			}
			qt.ConnectSignal(ptr.Pointer(), "unregisterTimer", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "unregisterTimer", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectUnregisterTimer() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "unregisterTimer")
	}
}

func (ptr *QAbstractEventDispatcher) UnregisterTimer(timerId int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractEventDispatcher_UnregisterTimer(ptr.Pointer(), C.int(int32(timerId)))) != 0
	}
	return false
}

//export callbackQAbstractEventDispatcher_UnregisterTimers
func callbackQAbstractEventDispatcher_UnregisterTimers(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "unregisterTimers"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QObject) bool)(signal))(NewQObjectFromPointer(object)))))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QAbstractEventDispatcher) ConnectUnregisterTimers(f func(object *QObject) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "unregisterTimers"); signal != nil {
			f := func(object *QObject) bool {
				(*(*func(*QObject) bool)(signal))(object)
				return f(object)
			}
			qt.ConnectSignal(ptr.Pointer(), "unregisterTimers", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "unregisterTimers", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectUnregisterTimers() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "unregisterTimers")
	}
}

func (ptr *QAbstractEventDispatcher) UnregisterTimers(object QObject_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractEventDispatcher_UnregisterTimers(ptr.Pointer(), PointerFromQObject(object))) != 0
	}
	return false
}

//export callbackQAbstractEventDispatcher_WakeUp
func callbackQAbstractEventDispatcher_WakeUp(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "wakeUp"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractEventDispatcher) ConnectWakeUp(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "wakeUp"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "wakeUp", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "wakeUp", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectWakeUp() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "wakeUp")
	}
}

func (ptr *QAbstractEventDispatcher) WakeUp() {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_WakeUp(ptr.Pointer())
	}
}

//export callbackQAbstractEventDispatcher_DestroyQAbstractEventDispatcher
func callbackQAbstractEventDispatcher_DestroyQAbstractEventDispatcher(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractEventDispatcher"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractEventDispatcherFromPointer(ptr).DestroyQAbstractEventDispatcherDefault()
	}
}

func (ptr *QAbstractEventDispatcher) ConnectDestroyQAbstractEventDispatcher(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractEventDispatcher"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractEventDispatcher", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractEventDispatcher", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectDestroyQAbstractEventDispatcher() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAbstractEventDispatcher")
	}
}

func (ptr *QAbstractEventDispatcher) DestroyQAbstractEventDispatcher() {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_DestroyQAbstractEventDispatcher(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractEventDispatcher) DestroyQAbstractEventDispatcherDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_DestroyQAbstractEventDispatcherDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QAbstractItemModel struct {
	QObject
}

type QAbstractItemModel_ITF interface {
	QObject_ITF
	QAbstractItemModel_PTR() *QAbstractItemModel
}

func (ptr *QAbstractItemModel) QAbstractItemModel_PTR() *QAbstractItemModel {
	return ptr
}

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

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

func PointerFromQAbstractItemModel(ptr QAbstractItemModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemModel_PTR().Pointer()
	}
	return nil
}

func NewQAbstractItemModelFromPointer(ptr unsafe.Pointer) (n *QAbstractItemModel) {
	n = new(QAbstractItemModel)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QAbstractItemModel__LayoutChangeHint
//QAbstractItemModel::LayoutChangeHint
type QAbstractItemModel__LayoutChangeHint int64

const (
	QAbstractItemModel__NoLayoutChangeHint QAbstractItemModel__LayoutChangeHint = QAbstractItemModel__LayoutChangeHint(0)
	QAbstractItemModel__VerticalSortHint   QAbstractItemModel__LayoutChangeHint = QAbstractItemModel__LayoutChangeHint(1)
	QAbstractItemModel__HorizontalSortHint QAbstractItemModel__LayoutChangeHint = QAbstractItemModel__LayoutChangeHint(2)
)

//go:generate stringer -type=QAbstractItemModel__CheckIndexOption
//QAbstractItemModel::CheckIndexOption
type QAbstractItemModel__CheckIndexOption int64

const (
	QAbstractItemModel__NoOption        QAbstractItemModel__CheckIndexOption = QAbstractItemModel__CheckIndexOption(0x0000)
	QAbstractItemModel__IndexIsValid    QAbstractItemModel__CheckIndexOption = QAbstractItemModel__CheckIndexOption(0x0001)
	QAbstractItemModel__DoNotUseParent  QAbstractItemModel__CheckIndexOption = QAbstractItemModel__CheckIndexOption(0x0002)
	QAbstractItemModel__ParentIsInvalid QAbstractItemModel__CheckIndexOption = QAbstractItemModel__CheckIndexOption(0x0004)
)

func NewQAbstractItemModel(parent QObject_ITF) *QAbstractItemModel {
	tmpValue := NewQAbstractItemModelFromPointer(C.QAbstractItemModel_NewQAbstractItemModel(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QAbstractItemModel) BeginInsertColumns(parent QModelIndex_ITF, first int, last int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_BeginInsertColumns(ptr.Pointer(), PointerFromQModelIndex(parent), C.int(int32(first)), C.int(int32(last)))
	}
}

func (ptr *QAbstractItemModel) BeginInsertRows(parent QModelIndex_ITF, first int, last int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_BeginInsertRows(ptr.Pointer(), PointerFromQModelIndex(parent), C.int(int32(first)), C.int(int32(last)))
	}
}

func (ptr *QAbstractItemModel) BeginMoveColumns(sourceParent QModelIndex_ITF, sourceFirst int, sourceLast int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_BeginMoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(int32(sourceFirst)), C.int(int32(sourceLast)), PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) BeginMoveRows(sourceParent QModelIndex_ITF, sourceFirst int, sourceLast int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_BeginMoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(int32(sourceFirst)), C.int(int32(sourceLast)), PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) BeginRemoveColumns(parent QModelIndex_ITF, first int, last int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_BeginRemoveColumns(ptr.Pointer(), PointerFromQModelIndex(parent), C.int(int32(first)), C.int(int32(last)))
	}
}

func (ptr *QAbstractItemModel) BeginRemoveRows(parent QModelIndex_ITF, first int, last int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_BeginRemoveRows(ptr.Pointer(), PointerFromQModelIndex(parent), C.int(int32(first)), C.int(int32(last)))
	}
}

func (ptr *QAbstractItemModel) BeginResetModel() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_BeginResetModel(ptr.Pointer())
	}
}

//export callbackQAbstractItemModel_Buddy
func callbackQAbstractItemModel_Buddy(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "buddy"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(index)))
	}

	return PointerFromQModelIndex(NewQAbstractItemModelFromPointer(ptr).BuddyDefault(NewQModelIndexFromPointer(index)))
}

func (ptr *QAbstractItemModel) ConnectBuddy(f func(index *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "buddy"); signal != nil {
			f := func(index *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "buddy", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "buddy", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectBuddy() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "buddy")
	}
}

func (ptr *QAbstractItemModel) Buddy(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel_Buddy(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) BuddyDefault(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel_BuddyDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemModel_CanDropMimeData
func callbackQAbstractItemModel_CanDropMimeData(ptr unsafe.Pointer, data unsafe.Pointer, action C.longlong, row C.int, column C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "canDropMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(signal))(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).CanDropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))))
}

func (ptr *QAbstractItemModel) ConnectCanDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "canDropMimeData"); signal != nil {
			f := func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool {
				(*(*func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(signal))(data, action, row, column, parent)
				return f(data, action, row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "canDropMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canDropMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectCanDropMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "canDropMimeData")
	}
}

func (ptr *QAbstractItemModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.longlong(action), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) CanDropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_CanDropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.longlong(action), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_CanFetchMore
func callbackQAbstractItemModel_CanFetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "canFetchMore"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QModelIndex) bool)(signal))(NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).CanFetchMoreDefault(NewQModelIndexFromPointer(parent)))))
}

func (ptr *QAbstractItemModel) ConnectCanFetchMore(f func(parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "canFetchMore"); signal != nil {
			f := func(parent *QModelIndex) bool {
				(*(*func(*QModelIndex) bool)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "canFetchMore", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canFetchMore", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectCanFetchMore() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "canFetchMore")
	}
}

func (ptr *QAbstractItemModel) CanFetchMore(parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) CanFetchMoreDefault(parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_CanFetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) ChangePersistentIndex(from QModelIndex_ITF, to QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_ChangePersistentIndex(ptr.Pointer(), PointerFromQModelIndex(from), PointerFromQModelIndex(to))
	}
}

func (ptr *QAbstractItemModel) ChangePersistentIndexList(from []*QModelIndex, to []*QModelIndex) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_ChangePersistentIndexList(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__changePersistentIndexList_from_newList())
			for _, v := range from {
				tmpList.__changePersistentIndexList_from_setList(v)
			}
			return tmpList.Pointer()
		}(), func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__changePersistentIndexList_to_newList())
			for _, v := range to {
				tmpList.__changePersistentIndexList_to_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QAbstractItemModel) CheckIndex(index QModelIndex_ITF, options QAbstractItemModel__CheckIndexOption) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_CheckIndex(ptr.Pointer(), PointerFromQModelIndex(index), C.longlong(options))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_ColumnCount
func callbackQAbstractItemModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(0))
}

func (ptr *QAbstractItemModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectColumnCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnCount")
	}
}

func (ptr *QAbstractItemModel) ColumnCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQAbstractItemModel_ColumnsAboutToBeInserted
func callbackQAbstractItemModel_ColumnsAboutToBeInserted(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsAboutToBeInserted"); signal != nil {
		(*(*func(*QModelIndex, int, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

func (ptr *QAbstractItemModel) ConnectColumnsAboutToBeInserted(f func(parent *QModelIndex, first int, last int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "columnsAboutToBeInserted") {
			C.QAbstractItemModel_ConnectColumnsAboutToBeInserted(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "columnsAboutToBeInserted")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "columnsAboutToBeInserted"); signal != nil {
			f := func(parent *QModelIndex, first int, last int) {
				(*(*func(*QModelIndex, int, int))(signal))(parent, first, last)
				f(parent, first, last)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnsAboutToBeInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnsAboutToBeInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectColumnsAboutToBeInserted() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectColumnsAboutToBeInserted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "columnsAboutToBeInserted")
	}
}

//export callbackQAbstractItemModel_ColumnsAboutToBeMoved
func callbackQAbstractItemModel_ColumnsAboutToBeMoved(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationColumn C.int) {
	if signal := qt.GetSignal(ptr, "columnsAboutToBeMoved"); signal != nil {
		(*(*func(*QModelIndex, int, int, *QModelIndex, int))(signal))(NewQModelIndexFromPointer(sourceParent), int(int32(sourceStart)), int(int32(sourceEnd)), NewQModelIndexFromPointer(destinationParent), int(int32(destinationColumn)))
	}

}

func (ptr *QAbstractItemModel) ConnectColumnsAboutToBeMoved(f func(sourceParent *QModelIndex, sourceStart int, sourceEnd int, destinationParent *QModelIndex, destinationColumn int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "columnsAboutToBeMoved") {
			C.QAbstractItemModel_ConnectColumnsAboutToBeMoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "columnsAboutToBeMoved")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "columnsAboutToBeMoved"); signal != nil {
			f := func(sourceParent *QModelIndex, sourceStart int, sourceEnd int, destinationParent *QModelIndex, destinationColumn int) {
				(*(*func(*QModelIndex, int, int, *QModelIndex, int))(signal))(sourceParent, sourceStart, sourceEnd, destinationParent, destinationColumn)
				f(sourceParent, sourceStart, sourceEnd, destinationParent, destinationColumn)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnsAboutToBeMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnsAboutToBeMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectColumnsAboutToBeMoved() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectColumnsAboutToBeMoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "columnsAboutToBeMoved")
	}
}

//export callbackQAbstractItemModel_ColumnsAboutToBeRemoved
func callbackQAbstractItemModel_ColumnsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsAboutToBeRemoved"); signal != nil {
		(*(*func(*QModelIndex, int, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

func (ptr *QAbstractItemModel) ConnectColumnsAboutToBeRemoved(f func(parent *QModelIndex, first int, last int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "columnsAboutToBeRemoved") {
			C.QAbstractItemModel_ConnectColumnsAboutToBeRemoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "columnsAboutToBeRemoved")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "columnsAboutToBeRemoved"); signal != nil {
			f := func(parent *QModelIndex, first int, last int) {
				(*(*func(*QModelIndex, int, int))(signal))(parent, first, last)
				f(parent, first, last)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnsAboutToBeRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnsAboutToBeRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectColumnsAboutToBeRemoved() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectColumnsAboutToBeRemoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "columnsAboutToBeRemoved")
	}
}

//export callbackQAbstractItemModel_ColumnsInserted
func callbackQAbstractItemModel_ColumnsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsInserted"); signal != nil {
		(*(*func(*QModelIndex, int, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

func (ptr *QAbstractItemModel) ConnectColumnsInserted(f func(parent *QModelIndex, first int, last int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "columnsInserted") {
			C.QAbstractItemModel_ConnectColumnsInserted(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "columnsInserted")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "columnsInserted"); signal != nil {
			f := func(parent *QModelIndex, first int, last int) {
				(*(*func(*QModelIndex, int, int))(signal))(parent, first, last)
				f(parent, first, last)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnsInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnsInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectColumnsInserted() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectColumnsInserted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "columnsInserted")
	}
}

//export callbackQAbstractItemModel_ColumnsMoved
func callbackQAbstractItemModel_ColumnsMoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "columnsMoved"); signal != nil {
		(*(*func(*QModelIndex, int, int, *QModelIndex, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)), NewQModelIndexFromPointer(destination), int(int32(column)))
	}

}

func (ptr *QAbstractItemModel) ConnectColumnsMoved(f func(parent *QModelIndex, start int, end int, destination *QModelIndex, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "columnsMoved") {
			C.QAbstractItemModel_ConnectColumnsMoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "columnsMoved")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "columnsMoved"); signal != nil {
			f := func(parent *QModelIndex, start int, end int, destination *QModelIndex, column int) {
				(*(*func(*QModelIndex, int, int, *QModelIndex, int))(signal))(parent, start, end, destination, column)
				f(parent, start, end, destination, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnsMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnsMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectColumnsMoved() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectColumnsMoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "columnsMoved")
	}
}

//export callbackQAbstractItemModel_ColumnsRemoved
func callbackQAbstractItemModel_ColumnsRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsRemoved"); signal != nil {
		(*(*func(*QModelIndex, int, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

func (ptr *QAbstractItemModel) ConnectColumnsRemoved(f func(parent *QModelIndex, first int, last int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "columnsRemoved") {
			C.QAbstractItemModel_ConnectColumnsRemoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "columnsRemoved")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "columnsRemoved"); signal != nil {
			f := func(parent *QModelIndex, first int, last int) {
				(*(*func(*QModelIndex, int, int))(signal))(parent, first, last)
				f(parent, first, last)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnsRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnsRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectColumnsRemoved() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectColumnsRemoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "columnsRemoved")
	}
}

func (ptr *QAbstractItemModel) CreateIndex(row int, column int, p unsafe.Pointer) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel_CreateIndex(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), p))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) CreateIndex2(row int, column int, id uintptr) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel_CreateIndex2(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), C.uintptr_t(id)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemModel_Data
func callbackQAbstractItemModel_Data(ptr unsafe.Pointer, index unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return PointerFromQVariant((*(*func(*QModelIndex, int) *QVariant)(signal))(NewQModelIndexFromPointer(index), int(int32(role))))
	}

	return PointerFromQVariant(NewQVariant())
}

func (ptr *QAbstractItemModel) ConnectData(f func(index *QModelIndex, role int) *QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "data"); signal != nil {
			f := func(index *QModelIndex, role int) *QVariant {
				(*(*func(*QModelIndex, int) *QVariant)(signal))(index, role)
				return f(index, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "data")
	}
}

func (ptr *QAbstractItemModel) Data(index QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractItemModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemModel_DataChanged
func callbackQAbstractItemModel_DataChanged(ptr unsafe.Pointer, topLeft unsafe.Pointer, bottomRight unsafe.Pointer, roles C.struct_QtCore_PackedList) {
	if signal := qt.GetSignal(ptr, "dataChanged"); signal != nil {
		(*(*func(*QModelIndex, *QModelIndex, []int))(signal))(NewQModelIndexFromPointer(topLeft), NewQModelIndexFromPointer(bottomRight), func(l C.struct_QtCore_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__dataChanged_roles_atList(i)
			}
			return out
		}(roles))
	}

}

func (ptr *QAbstractItemModel) ConnectDataChanged(f func(topLeft *QModelIndex, bottomRight *QModelIndex, roles []int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "dataChanged") {
			C.QAbstractItemModel_ConnectDataChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "dataChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "dataChanged"); signal != nil {
			f := func(topLeft *QModelIndex, bottomRight *QModelIndex, roles []int) {
				(*(*func(*QModelIndex, *QModelIndex, []int))(signal))(topLeft, bottomRight, roles)
				f(topLeft, bottomRight, roles)
			}
			qt.ConnectSignal(ptr.Pointer(), "dataChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dataChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectDataChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectDataChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "dataChanged")
	}
}

func (ptr *QAbstractItemModel) DataChanged(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF, roles []int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DataChanged(ptr.Pointer(), PointerFromQModelIndex(topLeft), PointerFromQModelIndex(bottomRight), func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__dataChanged_roles_newList())
			for _, v := range roles {
				tmpList.__dataChanged_roles_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQAbstractItemModel_DropMimeData
func callbackQAbstractItemModel_DropMimeData(ptr unsafe.Pointer, data unsafe.Pointer, action C.longlong, row C.int, column C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "dropMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(signal))(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).DropMimeDataDefault(NewQMimeDataFromPointer(data), Qt__DropAction(action), int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))))
}

func (ptr *QAbstractItemModel) ConnectDropMimeData(f func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dropMimeData"); signal != nil {
			f := func(data *QMimeData, action Qt__DropAction, row int, column int, parent *QModelIndex) bool {
				(*(*func(*QMimeData, Qt__DropAction, int, int, *QModelIndex) bool)(signal))(data, action, row, column, parent)
				return f(data, action, row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "dropMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dropMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectDropMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dropMimeData")
	}
}

func (ptr *QAbstractItemModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.longlong(action), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) DropMimeDataDefault(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_DropMimeDataDefault(ptr.Pointer(), PointerFromQMimeData(data), C.longlong(action), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) EndInsertColumns() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_EndInsertColumns(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) EndInsertRows() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_EndInsertRows(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) EndMoveColumns() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_EndMoveColumns(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) EndMoveRows() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_EndMoveRows(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) EndRemoveColumns() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_EndRemoveColumns(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) EndRemoveRows() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_EndRemoveRows(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) EndResetModel() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_EndResetModel(ptr.Pointer())
	}
}

//export callbackQAbstractItemModel_FetchMore
func callbackQAbstractItemModel_FetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "fetchMore"); signal != nil {
		(*(*func(*QModelIndex))(signal))(NewQModelIndexFromPointer(parent))
	} else {
		NewQAbstractItemModelFromPointer(ptr).FetchMoreDefault(NewQModelIndexFromPointer(parent))
	}
}

func (ptr *QAbstractItemModel) ConnectFetchMore(f func(parent *QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "fetchMore"); signal != nil {
			f := func(parent *QModelIndex) {
				(*(*func(*QModelIndex))(signal))(parent)
				f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "fetchMore", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "fetchMore", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectFetchMore() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "fetchMore")
	}
}

func (ptr *QAbstractItemModel) FetchMore(parent QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_FetchMore(ptr.Pointer(), PointerFromQModelIndex(parent))
	}
}

func (ptr *QAbstractItemModel) FetchMoreDefault(parent QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_FetchMoreDefault(ptr.Pointer(), PointerFromQModelIndex(parent))
	}
}

//export callbackQAbstractItemModel_Flags
func callbackQAbstractItemModel_Flags(ptr unsafe.Pointer, index unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "flags"); signal != nil {
		return C.longlong((*(*func(*QModelIndex) Qt__ItemFlag)(signal))(NewQModelIndexFromPointer(index)))
	}

	return C.longlong(NewQAbstractItemModelFromPointer(ptr).FlagsDefault(NewQModelIndexFromPointer(index)))
}

func (ptr *QAbstractItemModel) ConnectFlags(f func(index *QModelIndex) Qt__ItemFlag) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "flags"); signal != nil {
			f := func(index *QModelIndex) Qt__ItemFlag {
				(*(*func(*QModelIndex) Qt__ItemFlag)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "flags", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "flags", unsafe.Pointer(&f))
		}
	}
}

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

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

func (ptr *QAbstractItemModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QAbstractItemModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return 0
}

func (ptr *QAbstractItemModel) FlagsDefault(index QModelIndex_ITF) Qt__ItemFlag {
	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QAbstractItemModel_FlagsDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return 0
}

//export callbackQAbstractItemModel_HasChildren
func callbackQAbstractItemModel_HasChildren(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "hasChildren"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QModelIndex) bool)(signal))(NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).HasChildrenDefault(NewQModelIndexFromPointer(parent)))))
}

func (ptr *QAbstractItemModel) ConnectHasChildren(f func(parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hasChildren"); signal != nil {
			f := func(parent *QModelIndex) bool {
				(*(*func(*QModelIndex) bool)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "hasChildren", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hasChildren", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectHasChildren() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hasChildren")
	}
}

func (ptr *QAbstractItemModel) HasChildren(parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) HasChildrenDefault(parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_HasChildrenDefault(ptr.Pointer(), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) HasIndex(row int, column int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_HasIndex(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_HeaderData
func callbackQAbstractItemModel_HeaderData(ptr unsafe.Pointer, section C.int, orientation C.longlong, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "headerData"); signal != nil {
		return PointerFromQVariant((*(*func(int, Qt__Orientation, int) *QVariant)(signal))(int(int32(section)), Qt__Orientation(orientation), int(int32(role))))
	}

	return PointerFromQVariant(NewQAbstractItemModelFromPointer(ptr).HeaderDataDefault(int(int32(section)), Qt__Orientation(orientation), int(int32(role))))
}

func (ptr *QAbstractItemModel) ConnectHeaderData(f func(section int, orientation Qt__Orientation, role int) *QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "headerData"); signal != nil {
			f := func(section int, orientation Qt__Orientation, role int) *QVariant {
				(*(*func(int, Qt__Orientation, int) *QVariant)(signal))(section, orientation, role)
				return f(section, orientation, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "headerData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "headerData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectHeaderData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "headerData")
	}
}

func (ptr *QAbstractItemModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractItemModel_HeaderData(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) HeaderDataDefault(section int, orientation Qt__Orientation, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractItemModel_HeaderDataDefault(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemModel_HeaderDataChanged
func callbackQAbstractItemModel_HeaderDataChanged(ptr unsafe.Pointer, orientation C.longlong, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "headerDataChanged"); signal != nil {
		(*(*func(Qt__Orientation, int, int))(signal))(Qt__Orientation(orientation), int(int32(first)), int(int32(last)))
	}

}

func (ptr *QAbstractItemModel) ConnectHeaderDataChanged(f func(orientation Qt__Orientation, first int, last int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "headerDataChanged") {
			C.QAbstractItemModel_ConnectHeaderDataChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "headerDataChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "headerDataChanged"); signal != nil {
			f := func(orientation Qt__Orientation, first int, last int) {
				(*(*func(Qt__Orientation, int, int))(signal))(orientation, first, last)
				f(orientation, first, last)
			}
			qt.ConnectSignal(ptr.Pointer(), "headerDataChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "headerDataChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectHeaderDataChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectHeaderDataChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "headerDataChanged")
	}
}

func (ptr *QAbstractItemModel) HeaderDataChanged(orientation Qt__Orientation, first int, last int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_HeaderDataChanged(ptr.Pointer(), C.longlong(orientation), C.int(int32(first)), C.int(int32(last)))
	}
}

//export callbackQAbstractItemModel_Index
func callbackQAbstractItemModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return PointerFromQModelIndex((*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
	}

	return PointerFromQModelIndex(NewQModelIndex())
}

func (ptr *QAbstractItemModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "index"); signal != nil {
			f := func(row int, column int, parent *QModelIndex) *QModelIndex {
				(*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(row, column, parent)
				return f(row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "index")
	}
}

func (ptr *QAbstractItemModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) InsertColumn(column int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_InsertColumn(ptr.Pointer(), C.int(int32(column)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_InsertColumns
func callbackQAbstractItemModel_InsertColumns(ptr unsafe.Pointer, column C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "insertColumns"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *QModelIndex) bool)(signal))(int(int32(column)), int(int32(count)), NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).InsertColumnsDefault(int(int32(column)), int(int32(count)), NewQModelIndexFromPointer(parent)))))
}

func (ptr *QAbstractItemModel) ConnectInsertColumns(f func(column int, count int, parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "insertColumns"); signal != nil {
			f := func(column int, count int, parent *QModelIndex) bool {
				(*(*func(int, int, *QModelIndex) bool)(signal))(column, count, parent)
				return f(column, count, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "insertColumns", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "insertColumns", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectInsertColumns() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "insertColumns")
	}
}

func (ptr *QAbstractItemModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_InsertColumns(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) InsertColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_InsertColumnsDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) InsertRow(row int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_InsertRow(ptr.Pointer(), C.int(int32(row)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_InsertRows
func callbackQAbstractItemModel_InsertRows(ptr unsafe.Pointer, row C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "insertRows"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *QModelIndex) bool)(signal))(int(int32(row)), int(int32(count)), NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).InsertRowsDefault(int(int32(row)), int(int32(count)), NewQModelIndexFromPointer(parent)))))
}

func (ptr *QAbstractItemModel) ConnectInsertRows(f func(row int, count int, parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "insertRows"); signal != nil {
			f := func(row int, count int, parent *QModelIndex) bool {
				(*(*func(int, int, *QModelIndex) bool)(signal))(row, count, parent)
				return f(row, count, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "insertRows", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "insertRows", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectInsertRows() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "insertRows")
	}
}

func (ptr *QAbstractItemModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_InsertRows(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) InsertRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_InsertRowsDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_ItemData
func callbackQAbstractItemModel_ItemData(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemData"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__itemData_newList())
			for k, v := range (*(*func(*QModelIndex) map[int]*QVariant)(signal))(NewQModelIndexFromPointer(index)) {
				tmpList.__itemData_setList(k, v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__itemData_newList())
		for k, v := range NewQAbstractItemModelFromPointer(ptr).ItemDataDefault(NewQModelIndexFromPointer(index)) {
			tmpList.__itemData_setList(k, v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QAbstractItemModel) ConnectItemData(f func(index *QModelIndex) map[int]*QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemData"); signal != nil {
			f := func(index *QModelIndex) map[int]*QVariant {
				(*(*func(*QModelIndex) map[int]*QVariant)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectItemData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemData")
	}
}

func (ptr *QAbstractItemModel) ItemData(index QModelIndex_ITF) map[int]*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[int]*QVariant {
			out := make(map[int]*QVariant, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i, v := range tmpList.__itemData_keyList() {
				out[v] = tmpList.__itemData_atList(v, i)
			}
			return out
		}(C.QAbstractItemModel_ItemData(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return make(map[int]*QVariant, 0)
}

func (ptr *QAbstractItemModel) ItemDataDefault(index QModelIndex_ITF) map[int]*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[int]*QVariant {
			out := make(map[int]*QVariant, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i, v := range tmpList.__itemData_keyList() {
				out[v] = tmpList.__itemData_atList(v, i)
			}
			return out
		}(C.QAbstractItemModel_ItemDataDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return make(map[int]*QVariant, 0)
}

//export callbackQAbstractItemModel_LayoutAboutToBeChanged
func callbackQAbstractItemModel_LayoutAboutToBeChanged(ptr unsafe.Pointer, parents C.struct_QtCore_PackedList, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "layoutAboutToBeChanged"); signal != nil {
		(*(*func([]*QPersistentModelIndex, QAbstractItemModel__LayoutChangeHint))(signal))(func(l C.struct_QtCore_PackedList) []*QPersistentModelIndex {
			out := make([]*QPersistentModelIndex, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__layoutAboutToBeChanged_parents_atList(i)
			}
			return out
		}(parents), QAbstractItemModel__LayoutChangeHint(hint))
	}

}

func (ptr *QAbstractItemModel) ConnectLayoutAboutToBeChanged(f func(parents []*QPersistentModelIndex, hint QAbstractItemModel__LayoutChangeHint)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "layoutAboutToBeChanged") {
			C.QAbstractItemModel_ConnectLayoutAboutToBeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "layoutAboutToBeChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "layoutAboutToBeChanged"); signal != nil {
			f := func(parents []*QPersistentModelIndex, hint QAbstractItemModel__LayoutChangeHint) {
				(*(*func([]*QPersistentModelIndex, QAbstractItemModel__LayoutChangeHint))(signal))(parents, hint)
				f(parents, hint)
			}
			qt.ConnectSignal(ptr.Pointer(), "layoutAboutToBeChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "layoutAboutToBeChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectLayoutAboutToBeChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectLayoutAboutToBeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "layoutAboutToBeChanged")
	}
}

func (ptr *QAbstractItemModel) LayoutAboutToBeChanged(parents []*QPersistentModelIndex, hint QAbstractItemModel__LayoutChangeHint) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_LayoutAboutToBeChanged(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__layoutAboutToBeChanged_parents_newList())
			for _, v := range parents {
				tmpList.__layoutAboutToBeChanged_parents_setList(v)
			}
			return tmpList.Pointer()
		}(), C.longlong(hint))
	}
}

//export callbackQAbstractItemModel_LayoutChanged
func callbackQAbstractItemModel_LayoutChanged(ptr unsafe.Pointer, parents C.struct_QtCore_PackedList, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "layoutChanged"); signal != nil {
		(*(*func([]*QPersistentModelIndex, QAbstractItemModel__LayoutChangeHint))(signal))(func(l C.struct_QtCore_PackedList) []*QPersistentModelIndex {
			out := make([]*QPersistentModelIndex, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__layoutChanged_parents_atList(i)
			}
			return out
		}(parents), QAbstractItemModel__LayoutChangeHint(hint))
	}

}

func (ptr *QAbstractItemModel) ConnectLayoutChanged(f func(parents []*QPersistentModelIndex, hint QAbstractItemModel__LayoutChangeHint)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "layoutChanged") {
			C.QAbstractItemModel_ConnectLayoutChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "layoutChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "layoutChanged"); signal != nil {
			f := func(parents []*QPersistentModelIndex, hint QAbstractItemModel__LayoutChangeHint) {
				(*(*func([]*QPersistentModelIndex, QAbstractItemModel__LayoutChangeHint))(signal))(parents, hint)
				f(parents, hint)
			}
			qt.ConnectSignal(ptr.Pointer(), "layoutChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "layoutChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectLayoutChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectLayoutChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "layoutChanged")
	}
}

func (ptr *QAbstractItemModel) LayoutChanged(parents []*QPersistentModelIndex, hint QAbstractItemModel__LayoutChangeHint) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_LayoutChanged(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__layoutChanged_parents_newList())
			for _, v := range parents {
				tmpList.__layoutChanged_parents_setList(v)
			}
			return tmpList.Pointer()
		}(), C.longlong(hint))
	}
}

//export callbackQAbstractItemModel_Match
func callbackQAbstractItemModel_Match(ptr unsafe.Pointer, start unsafe.Pointer, role C.int, value unsafe.Pointer, hits C.int, flags C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "match"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__match_newList())
			for _, v := range (*(*func(*QModelIndex, int, *QVariant, int, Qt__MatchFlag) []*QModelIndex)(signal))(NewQModelIndexFromPointer(start), int(int32(role)), NewQVariantFromPointer(value), int(int32(hits)), Qt__MatchFlag(flags)) {
				tmpList.__match_setList(v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__match_newList())
		for _, v := range NewQAbstractItemModelFromPointer(ptr).MatchDefault(NewQModelIndexFromPointer(start), int(int32(role)), NewQVariantFromPointer(value), int(int32(hits)), Qt__MatchFlag(flags)) {
			tmpList.__match_setList(v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QAbstractItemModel) ConnectMatch(f func(start *QModelIndex, role int, value *QVariant, hits int, flags Qt__MatchFlag) []*QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "match"); signal != nil {
			f := func(start *QModelIndex, role int, value *QVariant, hits int, flags Qt__MatchFlag) []*QModelIndex {
				(*(*func(*QModelIndex, int, *QVariant, int, Qt__MatchFlag) []*QModelIndex)(signal))(start, role, value, hits, flags)
				return f(start, role, value, hits, flags)
			}
			qt.ConnectSignal(ptr.Pointer(), "match", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "match", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectMatch() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "match")
	}
}

func (ptr *QAbstractItemModel) Match(start QModelIndex_ITF, role int, value QVariant_ITF, hits int, flags Qt__MatchFlag) []*QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
			out := make([]*QModelIndex, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__match_atList(i)
			}
			return out
		}(C.QAbstractItemModel_Match(ptr.Pointer(), PointerFromQModelIndex(start), C.int(int32(role)), PointerFromQVariant(value), C.int(int32(hits)), C.longlong(flags)))
	}
	return make([]*QModelIndex, 0)
}

func (ptr *QAbstractItemModel) MatchDefault(start QModelIndex_ITF, role int, value QVariant_ITF, hits int, flags Qt__MatchFlag) []*QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
			out := make([]*QModelIndex, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__match_atList(i)
			}
			return out
		}(C.QAbstractItemModel_MatchDefault(ptr.Pointer(), PointerFromQModelIndex(start), C.int(int32(role)), PointerFromQVariant(value), C.int(int32(hits)), C.longlong(flags)))
	}
	return make([]*QModelIndex, 0)
}

//export callbackQAbstractItemModel_MimeData
func callbackQAbstractItemModel_MimeData(ptr unsafe.Pointer, indexes C.struct_QtCore_PackedList) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mimeData"); signal != nil {
		return PointerFromQMimeData((*(*func([]*QModelIndex) *QMimeData)(signal))(func(l C.struct_QtCore_PackedList) []*QModelIndex {
			out := make([]*QModelIndex, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__mimeData_indexes_atList(i)
			}
			return out
		}(indexes)))
	}

	return PointerFromQMimeData(NewQAbstractItemModelFromPointer(ptr).MimeDataDefault(func(l C.struct_QtCore_PackedList) []*QModelIndex {
		out := make([]*QModelIndex, int(l.len))
		tmpList := NewQAbstractItemModelFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__mimeData_indexes_atList(i)
		}
		return out
	}(indexes)))
}

func (ptr *QAbstractItemModel) ConnectMimeData(f func(indexes []*QModelIndex) *QMimeData) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mimeData"); signal != nil {
			f := func(indexes []*QModelIndex) *QMimeData {
				(*(*func([]*QModelIndex) *QMimeData)(signal))(indexes)
				return f(indexes)
			}
			qt.ConnectSignal(ptr.Pointer(), "mimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mimeData")
	}
}

func (ptr *QAbstractItemModel) MimeData(indexes []*QModelIndex) *QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := NewQMimeDataFromPointer(C.QAbstractItemModel_MimeData(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__mimeData_indexes_newList())
			for _, v := range indexes {
				tmpList.__mimeData_indexes_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) MimeDataDefault(indexes []*QModelIndex) *QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := NewQMimeDataFromPointer(C.QAbstractItemModel_MimeDataDefault(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__mimeData_indexes_newList())
			for _, v := range indexes {
				tmpList.__mimeData_indexes_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemModel_MimeTypes
func callbackQAbstractItemModel_MimeTypes(ptr unsafe.Pointer) C.struct_QtCore_PackedString {
	if signal := qt.GetSignal(ptr, "mimeTypes"); signal != nil {
		tempVal := (*(*func() []string)(signal))()
		return C.struct_QtCore_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
	}
	tempVal := NewQAbstractItemModelFromPointer(ptr).MimeTypesDefault()
	return C.struct_QtCore_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
}

func (ptr *QAbstractItemModel) ConnectMimeTypes(f func() []string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mimeTypes"); signal != nil {
			f := func() []string {
				(*(*func() []string)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "mimeTypes", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mimeTypes", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectMimeTypes() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mimeTypes")
	}
}

func (ptr *QAbstractItemModel) MimeTypes() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QAbstractItemModel_MimeTypes(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QAbstractItemModel) MimeTypesDefault() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QAbstractItemModel_MimeTypesDefault(ptr.Pointer())))
	}
	return make([]string, 0)
}

//export callbackQAbstractItemModel_ModelAboutToBeReset
func callbackQAbstractItemModel_ModelAboutToBeReset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "modelAboutToBeReset"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractItemModel) ConnectModelAboutToBeReset(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "modelAboutToBeReset") {
			C.QAbstractItemModel_ConnectModelAboutToBeReset(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "modelAboutToBeReset")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "modelAboutToBeReset"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "modelAboutToBeReset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "modelAboutToBeReset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectModelAboutToBeReset() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectModelAboutToBeReset(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "modelAboutToBeReset")
	}
}

//export callbackQAbstractItemModel_ModelReset
func callbackQAbstractItemModel_ModelReset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "modelReset"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractItemModel) ConnectModelReset(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "modelReset") {
			C.QAbstractItemModel_ConnectModelReset(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "modelReset")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "modelReset"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "modelReset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "modelReset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectModelReset() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectModelReset(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "modelReset")
	}
}

func (ptr *QAbstractItemModel) MoveColumn(sourceParent QModelIndex_ITF, sourceColumn int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_MoveColumn(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(int32(sourceColumn)), PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_MoveColumns
func callbackQAbstractItemModel_MoveColumns(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.char {
	if signal := qt.GetSignal(ptr, "moveColumns"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QModelIndex, int, int, *QModelIndex, int) bool)(signal))(NewQModelIndexFromPointer(sourceParent), int(int32(sourceColumn)), int(int32(count)), NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).MoveColumnsDefault(NewQModelIndexFromPointer(sourceParent), int(int32(sourceColumn)), int(int32(count)), NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
}

func (ptr *QAbstractItemModel) ConnectMoveColumns(f func(sourceParent *QModelIndex, sourceColumn int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "moveColumns"); signal != nil {
			f := func(sourceParent *QModelIndex, sourceColumn int, count int, destinationParent *QModelIndex, destinationChild int) bool {
				(*(*func(*QModelIndex, int, int, *QModelIndex, int) bool)(signal))(sourceParent, sourceColumn, count, destinationParent, destinationChild)
				return f(sourceParent, sourceColumn, count, destinationParent, destinationChild)
			}
			qt.ConnectSignal(ptr.Pointer(), "moveColumns", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "moveColumns", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectMoveColumns() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "moveColumns")
	}
}

func (ptr *QAbstractItemModel) MoveColumns(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_MoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(int32(sourceColumn)), C.int(int32(count)), PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) MoveColumnsDefault(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_MoveColumnsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(int32(sourceColumn)), C.int(int32(count)), PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) MoveRow(sourceParent QModelIndex_ITF, sourceRow int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_MoveRow(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(int32(sourceRow)), PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_MoveRows
func callbackQAbstractItemModel_MoveRows(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.char {
	if signal := qt.GetSignal(ptr, "moveRows"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QModelIndex, int, int, *QModelIndex, int) bool)(signal))(NewQModelIndexFromPointer(sourceParent), int(int32(sourceRow)), int(int32(count)), NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).MoveRowsDefault(NewQModelIndexFromPointer(sourceParent), int(int32(sourceRow)), int(int32(count)), NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
}

func (ptr *QAbstractItemModel) ConnectMoveRows(f func(sourceParent *QModelIndex, sourceRow int, count int, destinationParent *QModelIndex, destinationChild int) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "moveRows"); signal != nil {
			f := func(sourceParent *QModelIndex, sourceRow int, count int, destinationParent *QModelIndex, destinationChild int) bool {
				(*(*func(*QModelIndex, int, int, *QModelIndex, int) bool)(signal))(sourceParent, sourceRow, count, destinationParent, destinationChild)
				return f(sourceParent, sourceRow, count, destinationParent, destinationChild)
			}
			qt.ConnectSignal(ptr.Pointer(), "moveRows", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "moveRows", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectMoveRows() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "moveRows")
	}
}

func (ptr *QAbstractItemModel) MoveRows(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_MoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(int32(sourceRow)), C.int(int32(count)), PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) MoveRowsDefault(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_MoveRowsDefault(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(int32(sourceRow)), C.int(int32(count)), PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_Parent
func callbackQAbstractItemModel_Parent(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(index)))
	}

	return PointerFromQModelIndex(NewQModelIndex())
}

func (ptr *QAbstractItemModel) ConnectParent(f func(index *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "parent"); signal != nil {
			f := func(index *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectParent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "parent")
	}
}

func (ptr *QAbstractItemModel) Parent(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) PersistentIndexList() []*QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
			out := make([]*QModelIndex, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__persistentIndexList_atList(i)
			}
			return out
		}(C.QAbstractItemModel_PersistentIndexList(ptr.Pointer()))
	}
	return make([]*QModelIndex, 0)
}

func (ptr *QAbstractItemModel) RemoveColumn(column int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_RemoveColumn(ptr.Pointer(), C.int(int32(column)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_RemoveColumns
func callbackQAbstractItemModel_RemoveColumns(ptr unsafe.Pointer, column C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "removeColumns"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *QModelIndex) bool)(signal))(int(int32(column)), int(int32(count)), NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).RemoveColumnsDefault(int(int32(column)), int(int32(count)), NewQModelIndexFromPointer(parent)))))
}

func (ptr *QAbstractItemModel) ConnectRemoveColumns(f func(column int, count int, parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "removeColumns"); signal != nil {
			f := func(column int, count int, parent *QModelIndex) bool {
				(*(*func(int, int, *QModelIndex) bool)(signal))(column, count, parent)
				return f(column, count, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "removeColumns", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "removeColumns", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRemoveColumns() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "removeColumns")
	}
}

func (ptr *QAbstractItemModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_RemoveColumns(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) RemoveColumnsDefault(column int, count int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_RemoveColumnsDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) RemoveRow(row int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_RemoveRow(ptr.Pointer(), C.int(int32(row)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_RemoveRows
func callbackQAbstractItemModel_RemoveRows(ptr unsafe.Pointer, row C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "removeRows"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *QModelIndex) bool)(signal))(int(int32(row)), int(int32(count)), NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).RemoveRowsDefault(int(int32(row)), int(int32(count)), NewQModelIndexFromPointer(parent)))))
}

func (ptr *QAbstractItemModel) ConnectRemoveRows(f func(row int, count int, parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "removeRows"); signal != nil {
			f := func(row int, count int, parent *QModelIndex) bool {
				(*(*func(int, int, *QModelIndex) bool)(signal))(row, count, parent)
				return f(row, count, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "removeRows", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "removeRows", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRemoveRows() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "removeRows")
	}
}

func (ptr *QAbstractItemModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_RemoveRows(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) RemoveRowsDefault(row int, count int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_RemoveRowsDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_ResetInternalData
func callbackQAbstractItemModel_ResetInternalData(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resetInternalData"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemModelFromPointer(ptr).ResetInternalDataDefault()
	}
}

func (ptr *QAbstractItemModel) ConnectResetInternalData(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resetInternalData"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "resetInternalData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resetInternalData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectResetInternalData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resetInternalData")
	}
}

func (ptr *QAbstractItemModel) ResetInternalData() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_ResetInternalData(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) ResetInternalDataDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_ResetInternalDataDefault(ptr.Pointer())
	}
}

//export callbackQAbstractItemModel_Revert
func callbackQAbstractItemModel_Revert(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "revert"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemModelFromPointer(ptr).RevertDefault()
	}
}

func (ptr *QAbstractItemModel) ConnectRevert(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "revert"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "revert", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "revert", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRevert() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "revert")
	}
}

func (ptr *QAbstractItemModel) Revert() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_Revert(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) RevertDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_RevertDefault(ptr.Pointer())
	}
}

//export callbackQAbstractItemModel_RoleNames
func callbackQAbstractItemModel_RoleNames(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "roleNames"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__roleNames_newList())
			for k, v := range (*(*func() map[int]*QByteArray)(signal))() {
				tmpList.__roleNames_setList(k, v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__roleNames_newList())
		for k, v := range NewQAbstractItemModelFromPointer(ptr).RoleNamesDefault() {
			tmpList.__roleNames_setList(k, v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QAbstractItemModel) ConnectRoleNames(f func() map[int]*QByteArray) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "roleNames"); signal != nil {
			f := func() map[int]*QByteArray {
				(*(*func() map[int]*QByteArray)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "roleNames", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "roleNames", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRoleNames() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "roleNames")
	}
}

func (ptr *QAbstractItemModel) RoleNames() map[int]*QByteArray {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[int]*QByteArray {
			out := make(map[int]*QByteArray, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i, v := range tmpList.__roleNames_keyList() {
				out[v] = tmpList.__roleNames_atList(v, i)
			}
			return out
		}(C.QAbstractItemModel_RoleNames(ptr.Pointer()))
	}
	return make(map[int]*QByteArray, 0)
}

func (ptr *QAbstractItemModel) RoleNamesDefault() map[int]*QByteArray {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[int]*QByteArray {
			out := make(map[int]*QByteArray, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i, v := range tmpList.__roleNames_keyList() {
				out[v] = tmpList.__roleNames_atList(v, i)
			}
			return out
		}(C.QAbstractItemModel_RoleNamesDefault(ptr.Pointer()))
	}
	return make(map[int]*QByteArray, 0)
}

//export callbackQAbstractItemModel_RowCount
func callbackQAbstractItemModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(0))
}

func (ptr *QAbstractItemModel) ConnectRowCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRowCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowCount")
	}
}

func (ptr *QAbstractItemModel) RowCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQAbstractItemModel_RowsAboutToBeInserted
func callbackQAbstractItemModel_RowsAboutToBeInserted(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeInserted"); signal != nil {
		(*(*func(*QModelIndex, int, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}

}

func (ptr *QAbstractItemModel) ConnectRowsAboutToBeInserted(f func(parent *QModelIndex, start int, end int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rowsAboutToBeInserted") {
			C.QAbstractItemModel_ConnectRowsAboutToBeInserted(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "rowsAboutToBeInserted")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "rowsAboutToBeInserted"); signal != nil {
			f := func(parent *QModelIndex, start int, end int) {
				(*(*func(*QModelIndex, int, int))(signal))(parent, start, end)
				f(parent, start, end)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRowsAboutToBeInserted() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectRowsAboutToBeInserted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rowsAboutToBeInserted")
	}
}

//export callbackQAbstractItemModel_RowsAboutToBeMoved
func callbackQAbstractItemModel_RowsAboutToBeMoved(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationRow C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeMoved"); signal != nil {
		(*(*func(*QModelIndex, int, int, *QModelIndex, int))(signal))(NewQModelIndexFromPointer(sourceParent), int(int32(sourceStart)), int(int32(sourceEnd)), NewQModelIndexFromPointer(destinationParent), int(int32(destinationRow)))
	}

}

func (ptr *QAbstractItemModel) ConnectRowsAboutToBeMoved(f func(sourceParent *QModelIndex, sourceStart int, sourceEnd int, destinationParent *QModelIndex, destinationRow int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rowsAboutToBeMoved") {
			C.QAbstractItemModel_ConnectRowsAboutToBeMoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "rowsAboutToBeMoved")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "rowsAboutToBeMoved"); signal != nil {
			f := func(sourceParent *QModelIndex, sourceStart int, sourceEnd int, destinationParent *QModelIndex, destinationRow int) {
				(*(*func(*QModelIndex, int, int, *QModelIndex, int))(signal))(sourceParent, sourceStart, sourceEnd, destinationParent, destinationRow)
				f(sourceParent, sourceStart, sourceEnd, destinationParent, destinationRow)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRowsAboutToBeMoved() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectRowsAboutToBeMoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rowsAboutToBeMoved")
	}
}

//export callbackQAbstractItemModel_RowsAboutToBeRemoved
func callbackQAbstractItemModel_RowsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeRemoved"); signal != nil {
		(*(*func(*QModelIndex, int, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

func (ptr *QAbstractItemModel) ConnectRowsAboutToBeRemoved(f func(parent *QModelIndex, first int, last int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rowsAboutToBeRemoved") {
			C.QAbstractItemModel_ConnectRowsAboutToBeRemoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "rowsAboutToBeRemoved")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "rowsAboutToBeRemoved"); signal != nil {
			f := func(parent *QModelIndex, first int, last int) {
				(*(*func(*QModelIndex, int, int))(signal))(parent, first, last)
				f(parent, first, last)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRowsAboutToBeRemoved() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectRowsAboutToBeRemoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rowsAboutToBeRemoved")
	}
}

//export callbackQAbstractItemModel_RowsInserted
func callbackQAbstractItemModel_RowsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "rowsInserted"); signal != nil {
		(*(*func(*QModelIndex, int, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

func (ptr *QAbstractItemModel) ConnectRowsInserted(f func(parent *QModelIndex, first int, last int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rowsInserted") {
			C.QAbstractItemModel_ConnectRowsInserted(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "rowsInserted")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "rowsInserted"); signal != nil {
			f := func(parent *QModelIndex, first int, last int) {
				(*(*func(*QModelIndex, int, int))(signal))(parent, first, last)
				f(parent, first, last)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRowsInserted() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectRowsInserted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rowsInserted")
	}
}

//export callbackQAbstractItemModel_RowsMoved
func callbackQAbstractItemModel_RowsMoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, row C.int) {
	if signal := qt.GetSignal(ptr, "rowsMoved"); signal != nil {
		(*(*func(*QModelIndex, int, int, *QModelIndex, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)), NewQModelIndexFromPointer(destination), int(int32(row)))
	}

}

func (ptr *QAbstractItemModel) ConnectRowsMoved(f func(parent *QModelIndex, start int, end int, destination *QModelIndex, row int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rowsMoved") {
			C.QAbstractItemModel_ConnectRowsMoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "rowsMoved")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "rowsMoved"); signal != nil {
			f := func(parent *QModelIndex, start int, end int, destination *QModelIndex, row int) {
				(*(*func(*QModelIndex, int, int, *QModelIndex, int))(signal))(parent, start, end, destination, row)
				f(parent, start, end, destination, row)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRowsMoved() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectRowsMoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rowsMoved")
	}
}

//export callbackQAbstractItemModel_RowsRemoved
func callbackQAbstractItemModel_RowsRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "rowsRemoved"); signal != nil {
		(*(*func(*QModelIndex, int, int))(signal))(NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

func (ptr *QAbstractItemModel) ConnectRowsRemoved(f func(parent *QModelIndex, first int, last int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rowsRemoved") {
			C.QAbstractItemModel_ConnectRowsRemoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "rowsRemoved")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "rowsRemoved"); signal != nil {
			f := func(parent *QModelIndex, first int, last int) {
				(*(*func(*QModelIndex, int, int))(signal))(parent, first, last)
				f(parent, first, last)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectRowsRemoved() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectRowsRemoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rowsRemoved")
	}
}

//export callbackQAbstractItemModel_SetData
func callbackQAbstractItemModel_SetData(ptr unsafe.Pointer, index unsafe.Pointer, value unsafe.Pointer, role C.int) C.char {
	if signal := qt.GetSignal(ptr, "setData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QModelIndex, *QVariant, int) bool)(signal))(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(int32(role))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).SetDataDefault(NewQModelIndexFromPointer(index), NewQVariantFromPointer(value), int(int32(role))))))
}

func (ptr *QAbstractItemModel) ConnectSetData(f func(index *QModelIndex, value *QVariant, role int) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setData"); signal != nil {
			f := func(index *QModelIndex, value *QVariant, role int) bool {
				(*(*func(*QModelIndex, *QVariant, int) bool)(signal))(index, value, role)
				return f(index, value, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectSetData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setData")
	}
}

func (ptr *QAbstractItemModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(int32(role)))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) SetDataDefault(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_SetDataDefault(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(int32(role)))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_SetHeaderData
func callbackQAbstractItemModel_SetHeaderData(ptr unsafe.Pointer, section C.int, orientation C.longlong, value unsafe.Pointer, role C.int) C.char {
	if signal := qt.GetSignal(ptr, "setHeaderData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, Qt__Orientation, *QVariant, int) bool)(signal))(int(int32(section)), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(int32(role))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).SetHeaderDataDefault(int(int32(section)), Qt__Orientation(orientation), NewQVariantFromPointer(value), int(int32(role))))))
}

func (ptr *QAbstractItemModel) ConnectSetHeaderData(f func(section int, orientation Qt__Orientation, value *QVariant, role int) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setHeaderData"); signal != nil {
			f := func(section int, orientation Qt__Orientation, value *QVariant, role int) bool {
				(*(*func(int, Qt__Orientation, *QVariant, int) bool)(signal))(section, orientation, value, role)
				return f(section, orientation, value, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "setHeaderData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setHeaderData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectSetHeaderData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setHeaderData")
	}
}

func (ptr *QAbstractItemModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_SetHeaderData(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), PointerFromQVariant(value), C.int(int32(role)))) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) SetHeaderDataDefault(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_SetHeaderDataDefault(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), PointerFromQVariant(value), C.int(int32(role)))) != 0
	}
	return false
}

//export callbackQAbstractItemModel_SetItemData
func callbackQAbstractItemModel_SetItemData(ptr unsafe.Pointer, index unsafe.Pointer, roles C.struct_QtCore_PackedList) C.char {
	if signal := qt.GetSignal(ptr, "setItemData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QModelIndex, map[int]*QVariant) bool)(signal))(NewQModelIndexFromPointer(index), func(l C.struct_QtCore_PackedList) map[int]*QVariant {
			out := make(map[int]*QVariant, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i, v := range tmpList.__setItemData_roles_keyList() {
				out[v] = tmpList.__setItemData_roles_atList(v, i)
			}
			return out
		}(roles)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).SetItemDataDefault(NewQModelIndexFromPointer(index), func(l C.struct_QtCore_PackedList) map[int]*QVariant {
		out := make(map[int]*QVariant, int(l.len))
		tmpList := NewQAbstractItemModelFromPointer(l.data)
		for i, v := range tmpList.__setItemData_roles_keyList() {
			out[v] = tmpList.__setItemData_roles_atList(v, i)
		}
		return out
	}(roles)))))
}

func (ptr *QAbstractItemModel) ConnectSetItemData(f func(index *QModelIndex, roles map[int]*QVariant) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setItemData"); signal != nil {
			f := func(index *QModelIndex, roles map[int]*QVariant) bool {
				(*(*func(*QModelIndex, map[int]*QVariant) bool)(signal))(index, roles)
				return f(index, roles)
			}
			qt.ConnectSignal(ptr.Pointer(), "setItemData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setItemData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectSetItemData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setItemData")
	}
}

func (ptr *QAbstractItemModel) SetItemData(index QModelIndex_ITF, roles map[int]*QVariant) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_SetItemData(ptr.Pointer(), PointerFromQModelIndex(index), func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__setItemData_roles_newList())
			for k, v := range roles {
				tmpList.__setItemData_roles_setList(k, v)
			}
			return tmpList.Pointer()
		}())) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) SetItemDataDefault(index QModelIndex_ITF, roles map[int]*QVariant) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_SetItemDataDefault(ptr.Pointer(), PointerFromQModelIndex(index), func() unsafe.Pointer {
			tmpList := NewQAbstractItemModelFromPointer(NewQAbstractItemModelFromPointer(nil).__setItemData_roles_newList())
			for k, v := range roles {
				tmpList.__setItemData_roles_setList(k, v)
			}
			return tmpList.Pointer()
		}())) != 0
	}
	return false
}

//export callbackQAbstractItemModel_Sibling
func callbackQAbstractItemModel_Sibling(ptr unsafe.Pointer, row C.int, column C.int, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sibling"); signal != nil {
		return PointerFromQModelIndex((*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(index)))
	}

	return PointerFromQModelIndex(NewQAbstractItemModelFromPointer(ptr).SiblingDefault(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(index)))
}

func (ptr *QAbstractItemModel) ConnectSibling(f func(row int, column int, index *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sibling"); signal != nil {
			f := func(row int, column int, index *QModelIndex) *QModelIndex {
				(*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(row, column, index)
				return f(row, column, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "sibling", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sibling", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectSibling() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sibling")
	}
}

func (ptr *QAbstractItemModel) Sibling(row int, column int, index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel_Sibling(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) SiblingDefault(row int, column int, index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel_SiblingDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemModel_Sort
func callbackQAbstractItemModel_Sort(ptr unsafe.Pointer, column C.int, order C.longlong) {
	if signal := qt.GetSignal(ptr, "sort"); signal != nil {
		(*(*func(int, Qt__SortOrder))(signal))(int(int32(column)), Qt__SortOrder(order))
	} else {
		NewQAbstractItemModelFromPointer(ptr).SortDefault(int(int32(column)), Qt__SortOrder(order))
	}
}

func (ptr *QAbstractItemModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sort"); signal != nil {
			f := func(column int, order Qt__SortOrder) {
				(*(*func(int, Qt__SortOrder))(signal))(column, order)
				f(column, order)
			}
			qt.ConnectSignal(ptr.Pointer(), "sort", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sort", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectSort() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sort")
	}
}

func (ptr *QAbstractItemModel) Sort(column int, order Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_Sort(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
	}
}

func (ptr *QAbstractItemModel) SortDefault(column int, order Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_SortDefault(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
	}
}

//export callbackQAbstractItemModel_Span
func callbackQAbstractItemModel_Span(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "span"); signal != nil {
		return PointerFromQSize((*(*func(*QModelIndex) *QSize)(signal))(NewQModelIndexFromPointer(index)))
	}

	return PointerFromQSize(NewQAbstractItemModelFromPointer(ptr).SpanDefault(NewQModelIndexFromPointer(index)))
}

func (ptr *QAbstractItemModel) ConnectSpan(f func(index *QModelIndex) *QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "span"); signal != nil {
			f := func(index *QModelIndex) *QSize {
				(*(*func(*QModelIndex) *QSize)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "span", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "span", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectSpan() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "span")
	}
}

func (ptr *QAbstractItemModel) Span(index QModelIndex_ITF) *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QAbstractItemModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) SpanDefault(index QModelIndex_ITF) *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QAbstractItemModel_SpanDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

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

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemModelFromPointer(ptr).SubmitDefault())))
}

func (ptr *QAbstractItemModel) ConnectSubmit(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "submit"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "submit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "submit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectSubmit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "submit")
	}
}

func (ptr *QAbstractItemModel) Submit() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_Submit(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) SubmitDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemModel_SubmitDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQAbstractItemModel_SupportedDragActions
func callbackQAbstractItemModel_SupportedDragActions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "supportedDragActions"); signal != nil {
		return C.longlong((*(*func() Qt__DropAction)(signal))())
	}

	return C.longlong(NewQAbstractItemModelFromPointer(ptr).SupportedDragActionsDefault())
}

func (ptr *QAbstractItemModel) ConnectSupportedDragActions(f func() Qt__DropAction) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "supportedDragActions"); signal != nil {
			f := func() Qt__DropAction {
				(*(*func() Qt__DropAction)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "supportedDragActions", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "supportedDragActions", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectSupportedDragActions() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "supportedDragActions")
	}
}

func (ptr *QAbstractItemModel) SupportedDragActions() Qt__DropAction {
	if ptr.Pointer() != nil {
		return Qt__DropAction(C.QAbstractItemModel_SupportedDragActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemModel) SupportedDragActionsDefault() Qt__DropAction {
	if ptr.Pointer() != nil {
		return Qt__DropAction(C.QAbstractItemModel_SupportedDragActionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQAbstractItemModel_SupportedDropActions
func callbackQAbstractItemModel_SupportedDropActions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "supportedDropActions"); signal != nil {
		return C.longlong((*(*func() Qt__DropAction)(signal))())
	}

	return C.longlong(NewQAbstractItemModelFromPointer(ptr).SupportedDropActionsDefault())
}

func (ptr *QAbstractItemModel) ConnectSupportedDropActions(f func() Qt__DropAction) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "supportedDropActions"); signal != nil {
			f := func() Qt__DropAction {
				(*(*func() Qt__DropAction)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "supportedDropActions", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "supportedDropActions", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectSupportedDropActions() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "supportedDropActions")
	}
}

func (ptr *QAbstractItemModel) SupportedDropActions() Qt__DropAction {
	if ptr.Pointer() != nil {
		return Qt__DropAction(C.QAbstractItemModel_SupportedDropActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemModel) SupportedDropActionsDefault() Qt__DropAction {
	if ptr.Pointer() != nil {
		return Qt__DropAction(C.QAbstractItemModel_SupportedDropActionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQAbstractItemModel_DestroyQAbstractItemModel
func callbackQAbstractItemModel_DestroyQAbstractItemModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractItemModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemModelFromPointer(ptr).DestroyQAbstractItemModelDefault()
	}
}

func (ptr *QAbstractItemModel) ConnectDestroyQAbstractItemModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractItemModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractItemModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractItemModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemModel) DisconnectDestroyQAbstractItemModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAbstractItemModel")
	}
}

func (ptr *QAbstractItemModel) DestroyQAbstractItemModel() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DestroyQAbstractItemModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractItemModel) DestroyQAbstractItemModelDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DestroyQAbstractItemModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractItemModel) __changePersistentIndexList_from_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel___changePersistentIndexList_from_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __changePersistentIndexList_from_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___changePersistentIndexList_from_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QAbstractItemModel) __changePersistentIndexList_from_newList() unsafe.Pointer {
	return C.QAbstractItemModel___changePersistentIndexList_from_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __changePersistentIndexList_to_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel___changePersistentIndexList_to_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __changePersistentIndexList_to_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___changePersistentIndexList_to_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QAbstractItemModel) __changePersistentIndexList_to_newList() unsafe.Pointer {
	return C.QAbstractItemModel___changePersistentIndexList_to_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __dataChanged_roles_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemModel___dataChanged_roles_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QAbstractItemModel) __dataChanged_roles_setList(i int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___dataChanged_roles_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QAbstractItemModel) __dataChanged_roles_newList() unsafe.Pointer {
	return C.QAbstractItemModel___dataChanged_roles_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __doSetRoleNames_roleNames_atList(v int, i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QAbstractItemModel___doSetRoleNames_roleNames_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __doSetRoleNames_roleNames_setList(key int, i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___doSetRoleNames_roleNames_setList(ptr.Pointer(), C.int(int32(key)), PointerFromQByteArray(i))
	}
}

func (ptr *QAbstractItemModel) __doSetRoleNames_roleNames_newList() unsafe.Pointer {
	return C.QAbstractItemModel___doSetRoleNames_roleNames_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __doSetRoleNames_roleNames_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____doSetRoleNames_roleNames_keyList_atList(i)
			}
			return out
		}(C.QAbstractItemModel___doSetRoleNames_roleNames_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QAbstractItemModel) __encodeData_indexes_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel___encodeData_indexes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __encodeData_indexes_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___encodeData_indexes_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QAbstractItemModel) __encodeData_indexes_newList() unsafe.Pointer {
	return C.QAbstractItemModel___encodeData_indexes_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __itemData_atList(v int, i int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractItemModel___itemData_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __itemData_setList(key int, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___itemData_setList(ptr.Pointer(), C.int(int32(key)), PointerFromQVariant(i))
	}
}

func (ptr *QAbstractItemModel) __itemData_newList() unsafe.Pointer {
	return C.QAbstractItemModel___itemData_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __itemData_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____itemData_keyList_atList(i)
			}
			return out
		}(C.QAbstractItemModel___itemData_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QAbstractItemModel) __layoutAboutToBeChanged_parents_atList(i int) *QPersistentModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQPersistentModelIndexFromPointer(C.QAbstractItemModel___layoutAboutToBeChanged_parents_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QPersistentModelIndex).DestroyQPersistentModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __layoutAboutToBeChanged_parents_setList(i QPersistentModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___layoutAboutToBeChanged_parents_setList(ptr.Pointer(), PointerFromQPersistentModelIndex(i))
	}
}

func (ptr *QAbstractItemModel) __layoutAboutToBeChanged_parents_newList() unsafe.Pointer {
	return C.QAbstractItemModel___layoutAboutToBeChanged_parents_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __layoutChanged_parents_atList(i int) *QPersistentModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQPersistentModelIndexFromPointer(C.QAbstractItemModel___layoutChanged_parents_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QPersistentModelIndex).DestroyQPersistentModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __layoutChanged_parents_setList(i QPersistentModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___layoutChanged_parents_setList(ptr.Pointer(), PointerFromQPersistentModelIndex(i))
	}
}

func (ptr *QAbstractItemModel) __layoutChanged_parents_newList() unsafe.Pointer {
	return C.QAbstractItemModel___layoutChanged_parents_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __match_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel___match_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __match_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___match_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QAbstractItemModel) __match_newList() unsafe.Pointer {
	return C.QAbstractItemModel___match_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __mimeData_indexes_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel___mimeData_indexes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __mimeData_indexes_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___mimeData_indexes_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QAbstractItemModel) __mimeData_indexes_newList() unsafe.Pointer {
	return C.QAbstractItemModel___mimeData_indexes_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __persistentIndexList_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractItemModel___persistentIndexList_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __persistentIndexList_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___persistentIndexList_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QAbstractItemModel) __persistentIndexList_newList() unsafe.Pointer {
	return C.QAbstractItemModel___persistentIndexList_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __roleNames_atList(v int, i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QAbstractItemModel___roleNames_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __roleNames_setList(key int, i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___roleNames_setList(ptr.Pointer(), C.int(int32(key)), PointerFromQByteArray(i))
	}
}

func (ptr *QAbstractItemModel) __roleNames_newList() unsafe.Pointer {
	return C.QAbstractItemModel___roleNames_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __roleNames_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____roleNames_keyList_atList(i)
			}
			return out
		}(C.QAbstractItemModel___roleNames_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QAbstractItemModel) __setItemData_roles_atList(v int, i int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractItemModel___setItemData_roles_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __setItemData_roles_setList(key int, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___setItemData_roles_setList(ptr.Pointer(), C.int(int32(key)), PointerFromQVariant(i))
	}
}

func (ptr *QAbstractItemModel) __setItemData_roles_newList() unsafe.Pointer {
	return C.QAbstractItemModel___setItemData_roles_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __setItemData_roles_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____setItemData_roles_keyList_atList(i)
			}
			return out
		}(C.QAbstractItemModel___setItemData_roles_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QAbstractItemModel) __setRoleNames_roleNames_atList(v int, i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QAbstractItemModel___setRoleNames_roleNames_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemModel) __setRoleNames_roleNames_setList(key int, i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel___setRoleNames_roleNames_setList(ptr.Pointer(), C.int(int32(key)), PointerFromQByteArray(i))
	}
}

func (ptr *QAbstractItemModel) __setRoleNames_roleNames_newList() unsafe.Pointer {
	return C.QAbstractItemModel___setRoleNames_roleNames_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) __setRoleNames_roleNames_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQAbstractItemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____setRoleNames_roleNames_keyList_atList(i)
			}
			return out
		}(C.QAbstractItemModel___setRoleNames_roleNames_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QAbstractItemModel) ____doSetRoleNames_roleNames_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemModel_____doSetRoleNames_roleNames_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QAbstractItemModel) ____doSetRoleNames_roleNames_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_____doSetRoleNames_roleNames_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QAbstractItemModel) ____doSetRoleNames_roleNames_keyList_newList() unsafe.Pointer {
	return C.QAbstractItemModel_____doSetRoleNames_roleNames_keyList_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) ____itemData_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemModel_____itemData_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QAbstractItemModel) ____itemData_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_____itemData_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QAbstractItemModel) ____itemData_keyList_newList() unsafe.Pointer {
	return C.QAbstractItemModel_____itemData_keyList_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) ____roleNames_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemModel_____roleNames_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QAbstractItemModel) ____roleNames_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_____roleNames_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QAbstractItemModel) ____roleNames_keyList_newList() unsafe.Pointer {
	return C.QAbstractItemModel_____roleNames_keyList_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) ____setItemData_roles_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemModel_____setItemData_roles_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QAbstractItemModel) ____setItemData_roles_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_____setItemData_roles_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QAbstractItemModel) ____setItemData_roles_keyList_newList() unsafe.Pointer {
	return C.QAbstractItemModel_____setItemData_roles_keyList_newList(ptr.Pointer())
}

func (ptr *QAbstractItemModel) ____setRoleNames_roleNames_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemModel_____setRoleNames_roleNames_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QAbstractItemModel) ____setRoleNames_roleNames_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemModel_____setRoleNames_roleNames_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QAbstractItemModel) ____setRoleNames_roleNames_keyList_newList() unsafe.Pointer {
	return C.QAbstractItemModel_____setRoleNames_roleNames_keyList_newList(ptr.Pointer())
}

type QAbstractListModel struct {
	QAbstractItemModel
}

type QAbstractListModel_ITF interface {
	QAbstractItemModel_ITF
	QAbstractListModel_PTR() *QAbstractListModel
}

func (ptr *QAbstractListModel) QAbstractListModel_PTR() *QAbstractListModel {
	return ptr
}

func (ptr *QAbstractListModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemModel_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQAbstractListModel(ptr QAbstractListModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractListModel_PTR().Pointer()
	}
	return nil
}

func NewQAbstractListModelFromPointer(ptr unsafe.Pointer) (n *QAbstractListModel) {
	n = new(QAbstractListModel)
	n.SetPointer(ptr)
	return
}
func NewQAbstractListModel(parent QObject_ITF) *QAbstractListModel {
	tmpValue := NewQAbstractListModelFromPointer(C.QAbstractListModel_NewQAbstractListModel(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQAbstractListModel_Index
func callbackQAbstractListModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return PointerFromQModelIndex((*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
	}

	return PointerFromQModelIndex(NewQAbstractListModelFromPointer(ptr).IndexDefault(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
}

func (ptr *QAbstractListModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "index"); signal != nil {
			f := func(row int, column int, parent *QModelIndex) *QModelIndex {
				(*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(row, column, parent)
				return f(row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractListModel) DisconnectIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "index")
	}
}

func (ptr *QAbstractListModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractListModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractListModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractListModel_IndexDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractListModel_DestroyQAbstractListModel
func callbackQAbstractListModel_DestroyQAbstractListModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractListModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractListModelFromPointer(ptr).DestroyQAbstractListModelDefault()
	}
}

func (ptr *QAbstractListModel) ConnectDestroyQAbstractListModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractListModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractListModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractListModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractListModel) DisconnectDestroyQAbstractListModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAbstractListModel")
	}
}

func (ptr *QAbstractListModel) DestroyQAbstractListModel() {
	if ptr.Pointer() != nil {
		C.QAbstractListModel_DestroyQAbstractListModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractListModel) DestroyQAbstractListModelDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractListModel_DestroyQAbstractListModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQAbstractListModel_ColumnCount
func callbackQAbstractListModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQAbstractListModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QAbstractListModel) ColumnCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractListModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QAbstractListModel) ColumnCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractListModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQAbstractListModel_Data
func callbackQAbstractListModel_Data(ptr unsafe.Pointer, index unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return PointerFromQVariant((*(*func(*QModelIndex, int) *QVariant)(signal))(NewQModelIndexFromPointer(index), int(int32(role))))
	}

	return PointerFromQVariant(NewQAbstractListModelFromPointer(ptr).DataDefault(NewQModelIndexFromPointer(index), int(int32(role))))
}

func (ptr *QAbstractListModel) Data(index QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractListModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractListModel) DataDefault(index QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractListModel_DataDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractListModel_Parent
func callbackQAbstractListModel_Parent(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(index)))
	}

	return PointerFromQModelIndex(NewQAbstractListModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(index)))
}

func (ptr *QAbstractListModel) Parent(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractListModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractListModel) ParentDefault(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractListModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractListModel_RowCount
func callbackQAbstractListModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQAbstractListModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QAbstractListModel) RowCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractListModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QAbstractListModel) RowCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractListModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

type QAbstractNativeEventFilter struct {
	ptr unsafe.Pointer
}

type QAbstractNativeEventFilter_ITF interface {
	QAbstractNativeEventFilter_PTR() *QAbstractNativeEventFilter
}

func (ptr *QAbstractNativeEventFilter) QAbstractNativeEventFilter_PTR() *QAbstractNativeEventFilter {
	return ptr
}

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

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

func PointerFromQAbstractNativeEventFilter(ptr QAbstractNativeEventFilter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractNativeEventFilter_PTR().Pointer()
	}
	return nil
}

func NewQAbstractNativeEventFilterFromPointer(ptr unsafe.Pointer) (n *QAbstractNativeEventFilter) {
	n = new(QAbstractNativeEventFilter)
	n.SetPointer(ptr)
	return
}
func NewQAbstractNativeEventFilter() *QAbstractNativeEventFilter {
	return NewQAbstractNativeEventFilterFromPointer(C.QAbstractNativeEventFilter_NewQAbstractNativeEventFilter())
}

//export callbackQAbstractNativeEventFilter_NativeEventFilter
func callbackQAbstractNativeEventFilter_NativeEventFilter(ptr unsafe.Pointer, eventType unsafe.Pointer, message unsafe.Pointer, result *C.long) C.char {
	var resultR int
	if result != nil {
		resultR = int(int32(*result))
		defer func() { *result = C.long(int32(resultR)) }()
	}
	if signal := qt.GetSignal(ptr, "nativeEventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QByteArray, unsafe.Pointer, *int) bool)(signal))(NewQByteArrayFromPointer(eventType), message, &resultR))))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QAbstractNativeEventFilter) ConnectNativeEventFilter(f func(eventType *QByteArray, message unsafe.Pointer, result *int) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "nativeEventFilter"); signal != nil {
			f := func(eventType *QByteArray, message unsafe.Pointer, result *int) bool {
				(*(*func(*QByteArray, unsafe.Pointer, *int) bool)(signal))(eventType, message, result)
				return f(eventType, message, result)
			}
			qt.ConnectSignal(ptr.Pointer(), "nativeEventFilter", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "nativeEventFilter", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractNativeEventFilter) DisconnectNativeEventFilter() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "nativeEventFilter")
	}
}

func (ptr *QAbstractNativeEventFilter) NativeEventFilter(eventType QByteArray_ITF, message unsafe.Pointer, result *int) bool {
	if ptr.Pointer() != nil {
		var resultC C.long
		if result != nil {
			resultC = C.long(int32(*result))
			defer func() { *result = int(int32(resultC)) }()
		}
		return int8(C.QAbstractNativeEventFilter_NativeEventFilter(ptr.Pointer(), PointerFromQByteArray(eventType), message, &resultC)) != 0
	}
	return false
}

//export callbackQAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter
func callbackQAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractNativeEventFilter"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractNativeEventFilterFromPointer(ptr).DestroyQAbstractNativeEventFilterDefault()
	}
}

func (ptr *QAbstractNativeEventFilter) ConnectDestroyQAbstractNativeEventFilter(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractNativeEventFilter"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractNativeEventFilter", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractNativeEventFilter", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractNativeEventFilter) DisconnectDestroyQAbstractNativeEventFilter() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAbstractNativeEventFilter")
	}
}

func (ptr *QAbstractNativeEventFilter) DestroyQAbstractNativeEventFilter() {
	if ptr.Pointer() != nil {
		C.QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractNativeEventFilter) DestroyQAbstractNativeEventFilterDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilterDefault(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

type QAbstractProxyModel struct {
	QAbstractItemModel
}

type QAbstractProxyModel_ITF interface {
	QAbstractItemModel_ITF
	QAbstractProxyModel_PTR() *QAbstractProxyModel
}

func (ptr *QAbstractProxyModel) QAbstractProxyModel_PTR() *QAbstractProxyModel {
	return ptr
}

func (ptr *QAbstractProxyModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemModel_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQAbstractProxyModel(ptr QAbstractProxyModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractProxyModel_PTR().Pointer()
	}
	return nil
}

func NewQAbstractProxyModelFromPointer(ptr unsafe.Pointer) (n *QAbstractProxyModel) {
	n = new(QAbstractProxyModel)
	n.SetPointer(ptr)
	return
}
func NewQAbstractProxyModel(parent QObject_ITF) *QAbstractProxyModel {
	tmpValue := NewQAbstractProxyModelFromPointer(C.QAbstractProxyModel_NewQAbstractProxyModel(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQAbstractProxyModel_Data
func callbackQAbstractProxyModel_Data(ptr unsafe.Pointer, proxyIndex unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return PointerFromQVariant((*(*func(*QModelIndex, int) *QVariant)(signal))(NewQModelIndexFromPointer(proxyIndex), int(int32(role))))
	}

	return PointerFromQVariant(NewQAbstractProxyModelFromPointer(ptr).DataDefault(NewQModelIndexFromPointer(proxyIndex), int(int32(role))))
}

func (ptr *QAbstractProxyModel) ConnectData(f func(proxyIndex *QModelIndex, role int) *QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "data"); signal != nil {
			f := func(proxyIndex *QModelIndex, role int) *QVariant {
				(*(*func(*QModelIndex, int) *QVariant)(signal))(proxyIndex, role)
				return f(proxyIndex, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "data")
	}
}

func (ptr *QAbstractProxyModel) Data(proxyIndex QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractProxyModel_Data(ptr.Pointer(), PointerFromQModelIndex(proxyIndex), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractProxyModel) DataDefault(proxyIndex QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractProxyModel_DataDefault(ptr.Pointer(), PointerFromQModelIndex(proxyIndex), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractProxyModel_MapFromSource
func callbackQAbstractProxyModel_MapFromSource(ptr unsafe.Pointer, sourceIndex unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapFromSource"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(sourceIndex)))
	}

	return PointerFromQModelIndex(NewQModelIndex())
}

func (ptr *QAbstractProxyModel) ConnectMapFromSource(f func(sourceIndex *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapFromSource"); signal != nil {
			f := func(sourceIndex *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(sourceIndex)
				return f(sourceIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapFromSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapFromSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectMapFromSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapFromSource")
	}
}

func (ptr *QAbstractProxyModel) MapFromSource(sourceIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractProxyModel_MapFromSource(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractProxyModel_MapSelectionFromSource
func callbackQAbstractProxyModel_MapSelectionFromSource(ptr unsafe.Pointer, sourceSelection unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapSelectionFromSource"); signal != nil {
		return PointerFromQItemSelection((*(*func(*QItemSelection) *QItemSelection)(signal))(NewQItemSelectionFromPointer(sourceSelection)))
	}

	return PointerFromQItemSelection(NewQAbstractProxyModelFromPointer(ptr).MapSelectionFromSourceDefault(NewQItemSelectionFromPointer(sourceSelection)))
}

func (ptr *QAbstractProxyModel) ConnectMapSelectionFromSource(f func(sourceSelection *QItemSelection) *QItemSelection) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapSelectionFromSource"); signal != nil {
			f := func(sourceSelection *QItemSelection) *QItemSelection {
				(*(*func(*QItemSelection) *QItemSelection)(signal))(sourceSelection)
				return f(sourceSelection)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapSelectionFromSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapSelectionFromSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectMapSelectionFromSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapSelectionFromSource")
	}
}

func (ptr *QAbstractProxyModel) MapSelectionFromSource(sourceSelection QItemSelection_ITF) *QItemSelection {
	if ptr.Pointer() != nil {
		tmpValue := NewQItemSelectionFromPointer(C.QAbstractProxyModel_MapSelectionFromSource(ptr.Pointer(), PointerFromQItemSelection(sourceSelection)))
		runtime.SetFinalizer(tmpValue, (*QItemSelection).DestroyQItemSelection)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractProxyModel) MapSelectionFromSourceDefault(sourceSelection QItemSelection_ITF) *QItemSelection {
	if ptr.Pointer() != nil {
		tmpValue := NewQItemSelectionFromPointer(C.QAbstractProxyModel_MapSelectionFromSourceDefault(ptr.Pointer(), PointerFromQItemSelection(sourceSelection)))
		runtime.SetFinalizer(tmpValue, (*QItemSelection).DestroyQItemSelection)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractProxyModel_MapSelectionToSource
func callbackQAbstractProxyModel_MapSelectionToSource(ptr unsafe.Pointer, proxySelection unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapSelectionToSource"); signal != nil {
		return PointerFromQItemSelection((*(*func(*QItemSelection) *QItemSelection)(signal))(NewQItemSelectionFromPointer(proxySelection)))
	}

	return PointerFromQItemSelection(NewQAbstractProxyModelFromPointer(ptr).MapSelectionToSourceDefault(NewQItemSelectionFromPointer(proxySelection)))
}

func (ptr *QAbstractProxyModel) ConnectMapSelectionToSource(f func(proxySelection *QItemSelection) *QItemSelection) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapSelectionToSource"); signal != nil {
			f := func(proxySelection *QItemSelection) *QItemSelection {
				(*(*func(*QItemSelection) *QItemSelection)(signal))(proxySelection)
				return f(proxySelection)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapSelectionToSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapSelectionToSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectMapSelectionToSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapSelectionToSource")
	}
}

func (ptr *QAbstractProxyModel) MapSelectionToSource(proxySelection QItemSelection_ITF) *QItemSelection {
	if ptr.Pointer() != nil {
		tmpValue := NewQItemSelectionFromPointer(C.QAbstractProxyModel_MapSelectionToSource(ptr.Pointer(), PointerFromQItemSelection(proxySelection)))
		runtime.SetFinalizer(tmpValue, (*QItemSelection).DestroyQItemSelection)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractProxyModel) MapSelectionToSourceDefault(proxySelection QItemSelection_ITF) *QItemSelection {
	if ptr.Pointer() != nil {
		tmpValue := NewQItemSelectionFromPointer(C.QAbstractProxyModel_MapSelectionToSourceDefault(ptr.Pointer(), PointerFromQItemSelection(proxySelection)))
		runtime.SetFinalizer(tmpValue, (*QItemSelection).DestroyQItemSelection)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractProxyModel_MapToSource
func callbackQAbstractProxyModel_MapToSource(ptr unsafe.Pointer, proxyIndex unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapToSource"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(proxyIndex)))
	}

	return PointerFromQModelIndex(NewQModelIndex())
}

func (ptr *QAbstractProxyModel) ConnectMapToSource(f func(proxyIndex *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapToSource"); signal != nil {
			f := func(proxyIndex *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(proxyIndex)
				return f(proxyIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapToSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapToSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectMapToSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapToSource")
	}
}

func (ptr *QAbstractProxyModel) MapToSource(proxyIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractProxyModel_MapToSource(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractProxyModel_Revert
func callbackQAbstractProxyModel_Revert(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "revert"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractProxyModelFromPointer(ptr).RevertDefault()
	}
}

func (ptr *QAbstractProxyModel) ConnectRevert(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "revert"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "revert", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "revert", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectRevert() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "revert")
	}
}

func (ptr *QAbstractProxyModel) Revert() {
	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_Revert(ptr.Pointer())
	}
}

func (ptr *QAbstractProxyModel) RevertDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_RevertDefault(ptr.Pointer())
	}
}

//export callbackQAbstractProxyModel_SetSourceModel
func callbackQAbstractProxyModel_SetSourceModel(ptr unsafe.Pointer, sourceModel unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setSourceModel"); signal != nil {
		(*(*func(*QAbstractItemModel))(signal))(NewQAbstractItemModelFromPointer(sourceModel))
	} else {
		NewQAbstractProxyModelFromPointer(ptr).SetSourceModelDefault(NewQAbstractItemModelFromPointer(sourceModel))
	}
}

func (ptr *QAbstractProxyModel) ConnectSetSourceModel(f func(sourceModel *QAbstractItemModel)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setSourceModel"); signal != nil {
			f := func(sourceModel *QAbstractItemModel) {
				(*(*func(*QAbstractItemModel))(signal))(sourceModel)
				f(sourceModel)
			}
			qt.ConnectSignal(ptr.Pointer(), "setSourceModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setSourceModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectSetSourceModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setSourceModel")
	}
}

func (ptr *QAbstractProxyModel) SetSourceModel(sourceModel QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_SetSourceModel(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
	}
}

func (ptr *QAbstractProxyModel) SetSourceModelDefault(sourceModel QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_SetSourceModelDefault(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
	}
}

func (ptr *QAbstractProxyModel) SourceModel() *QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemModelFromPointer(C.QAbstractProxyModel_SourceModel(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAbstractProxyModel_SourceModelChanged
func callbackQAbstractProxyModel_SourceModelChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "sourceModelChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractProxyModel) ConnectSourceModelChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sourceModelChanged") {
			C.QAbstractProxyModel_ConnectSourceModelChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "sourceModelChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sourceModelChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "sourceModelChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sourceModelChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectSourceModelChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_DisconnectSourceModelChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sourceModelChanged")
	}
}

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

	return C.char(int8(qt.GoBoolToInt(NewQAbstractProxyModelFromPointer(ptr).SubmitDefault())))
}

func (ptr *QAbstractProxyModel) ConnectSubmit(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "submit"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "submit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "submit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectSubmit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "submit")
	}
}

func (ptr *QAbstractProxyModel) Submit() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractProxyModel_Submit(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractProxyModel) SubmitDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractProxyModel_SubmitDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQAbstractProxyModel_DestroyQAbstractProxyModel
func callbackQAbstractProxyModel_DestroyQAbstractProxyModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractProxyModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractProxyModelFromPointer(ptr).DestroyQAbstractProxyModelDefault()
	}
}

func (ptr *QAbstractProxyModel) ConnectDestroyQAbstractProxyModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractProxyModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractProxyModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractProxyModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractProxyModel) DisconnectDestroyQAbstractProxyModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAbstractProxyModel")
	}
}

func (ptr *QAbstractProxyModel) DestroyQAbstractProxyModel() {
	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_DestroyQAbstractProxyModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractProxyModel) DestroyQAbstractProxyModelDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_DestroyQAbstractProxyModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQAbstractProxyModel_ColumnCount
func callbackQAbstractProxyModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQAbstractProxyModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QAbstractProxyModel) ColumnCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QAbstractProxyModel) ColumnCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractProxyModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQAbstractProxyModel_Index
func callbackQAbstractProxyModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return PointerFromQModelIndex((*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
	}

	return PointerFromQModelIndex(NewQAbstractProxyModelFromPointer(ptr).IndexDefault(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
}

func (ptr *QAbstractProxyModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractProxyModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractProxyModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractProxyModel_IndexDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractProxyModel_Parent
func callbackQAbstractProxyModel_Parent(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(index)))
	}

	return PointerFromQModelIndex(NewQAbstractProxyModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(index)))
}

func (ptr *QAbstractProxyModel) Parent(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractProxyModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractProxyModel) ParentDefault(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractProxyModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractProxyModel_RowCount
func callbackQAbstractProxyModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQAbstractProxyModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QAbstractProxyModel) RowCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QAbstractProxyModel) RowCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractProxyModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

type QAbstractState struct {
	QObject
}

type QAbstractState_ITF interface {
	QObject_ITF
	QAbstractState_PTR() *QAbstractState
}

func (ptr *QAbstractState) QAbstractState_PTR() *QAbstractState {
	return ptr
}

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

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

func PointerFromQAbstractState(ptr QAbstractState_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractState_PTR().Pointer()
	}
	return nil
}

func NewQAbstractStateFromPointer(ptr unsafe.Pointer) (n *QAbstractState) {
	n = new(QAbstractState)
	n.SetPointer(ptr)
	return
}
func NewQAbstractState(parent QState_ITF) *QAbstractState {
	tmpValue := NewQAbstractStateFromPointer(C.QAbstractState_NewQAbstractState(PointerFromQState(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QAbstractState) Active() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractState_Active(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQAbstractState_ActiveChanged
func callbackQAbstractState_ActiveChanged(ptr unsafe.Pointer, active C.char) {
	if signal := qt.GetSignal(ptr, "activeChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(active) != 0)
	}

}

func (ptr *QAbstractState) ConnectActiveChanged(f func(active bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activeChanged") {
			C.QAbstractState_ConnectActiveChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "activeChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "activeChanged"); signal != nil {
			f := func(active bool) {
				(*(*func(bool))(signal))(active)
				f(active)
			}
			qt.ConnectSignal(ptr.Pointer(), "activeChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "activeChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractState) DisconnectActiveChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractState_DisconnectActiveChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activeChanged")
	}
}

func (ptr *QAbstractState) ActiveChanged(active bool) {
	if ptr.Pointer() != nil {
		C.QAbstractState_ActiveChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(active))))
	}
}

//export callbackQAbstractState_Entered
func callbackQAbstractState_Entered(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "entered"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractState) ConnectEntered(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "entered") {
			C.QAbstractState_ConnectEntered(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "entered")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "entered"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "entered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "entered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractState) DisconnectEntered() {
	if ptr.Pointer() != nil {
		C.QAbstractState_DisconnectEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "entered")
	}
}

//export callbackQAbstractState_Exited
func callbackQAbstractState_Exited(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "exited"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractState) ConnectExited(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "exited") {
			C.QAbstractState_ConnectExited(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "exited")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "exited"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "exited", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "exited", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractState) DisconnectExited() {
	if ptr.Pointer() != nil {
		C.QAbstractState_DisconnectExited(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "exited")
	}
}

func (ptr *QAbstractState) Machine() *QStateMachine {
	if ptr.Pointer() != nil {
		tmpValue := NewQStateMachineFromPointer(C.QAbstractState_Machine(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAbstractState_OnEntry
func callbackQAbstractState_OnEntry(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onEntry"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	}

}

func (ptr *QAbstractState) ConnectOnEntry(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onEntry"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onEntry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onEntry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractState) DisconnectOnEntry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onEntry")
	}
}

func (ptr *QAbstractState) OnEntry(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
	}
}

//export callbackQAbstractState_OnExit
func callbackQAbstractState_OnExit(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onExit"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	}

}

func (ptr *QAbstractState) ConnectOnExit(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onExit"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onExit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onExit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractState) DisconnectOnExit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onExit")
	}
}

func (ptr *QAbstractState) OnExit(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractState) ParentState() *QState {
	if ptr.Pointer() != nil {
		tmpValue := NewQStateFromPointer(C.QAbstractState_ParentState(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAbstractState_DestroyQAbstractState
func callbackQAbstractState_DestroyQAbstractState(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractState"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractStateFromPointer(ptr).DestroyQAbstractStateDefault()
	}
}

func (ptr *QAbstractState) ConnectDestroyQAbstractState(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractState"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractState", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractState", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractState) DisconnectDestroyQAbstractState() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAbstractState")
	}
}

func (ptr *QAbstractState) DestroyQAbstractState() {
	if ptr.Pointer() != nil {
		C.QAbstractState_DestroyQAbstractState(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractState) DestroyQAbstractStateDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractState_DestroyQAbstractStateDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QAbstractTableModel struct {
	QAbstractItemModel
}

type QAbstractTableModel_ITF interface {
	QAbstractItemModel_ITF
	QAbstractTableModel_PTR() *QAbstractTableModel
}

func (ptr *QAbstractTableModel) QAbstractTableModel_PTR() *QAbstractTableModel {
	return ptr
}

func (ptr *QAbstractTableModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemModel_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQAbstractTableModel(ptr QAbstractTableModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractTableModel_PTR().Pointer()
	}
	return nil
}

func NewQAbstractTableModelFromPointer(ptr unsafe.Pointer) (n *QAbstractTableModel) {
	n = new(QAbstractTableModel)
	n.SetPointer(ptr)
	return
}
func NewQAbstractTableModel(parent QObject_ITF) *QAbstractTableModel {
	tmpValue := NewQAbstractTableModelFromPointer(C.QAbstractTableModel_NewQAbstractTableModel(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQAbstractTableModel_Index
func callbackQAbstractTableModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return PointerFromQModelIndex((*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
	}

	return PointerFromQModelIndex(NewQAbstractTableModelFromPointer(ptr).IndexDefault(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
}

func (ptr *QAbstractTableModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "index"); signal != nil {
			f := func(row int, column int, parent *QModelIndex) *QModelIndex {
				(*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(row, column, parent)
				return f(row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractTableModel) DisconnectIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "index")
	}
}

func (ptr *QAbstractTableModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractTableModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractTableModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractTableModel_IndexDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractTableModel_DestroyQAbstractTableModel
func callbackQAbstractTableModel_DestroyQAbstractTableModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractTableModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractTableModelFromPointer(ptr).DestroyQAbstractTableModelDefault()
	}
}

func (ptr *QAbstractTableModel) ConnectDestroyQAbstractTableModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractTableModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractTableModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractTableModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractTableModel) DisconnectDestroyQAbstractTableModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAbstractTableModel")
	}
}

func (ptr *QAbstractTableModel) DestroyQAbstractTableModel() {
	if ptr.Pointer() != nil {
		C.QAbstractTableModel_DestroyQAbstractTableModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractTableModel) DestroyQAbstractTableModelDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractTableModel_DestroyQAbstractTableModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQAbstractTableModel_ColumnCount
func callbackQAbstractTableModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQAbstractTableModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QAbstractTableModel) ColumnCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractTableModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QAbstractTableModel) ColumnCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractTableModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQAbstractTableModel_Data
func callbackQAbstractTableModel_Data(ptr unsafe.Pointer, index unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return PointerFromQVariant((*(*func(*QModelIndex, int) *QVariant)(signal))(NewQModelIndexFromPointer(index), int(int32(role))))
	}

	return PointerFromQVariant(NewQAbstractTableModelFromPointer(ptr).DataDefault(NewQModelIndexFromPointer(index), int(int32(role))))
}

func (ptr *QAbstractTableModel) Data(index QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractTableModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractTableModel) DataDefault(index QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAbstractTableModel_DataDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractTableModel_Parent
func callbackQAbstractTableModel_Parent(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(index)))
	}

	return PointerFromQModelIndex(NewQAbstractTableModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(index)))
}

func (ptr *QAbstractTableModel) Parent(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractTableModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractTableModel) ParentDefault(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QAbstractTableModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractTableModel_RowCount
func callbackQAbstractTableModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQAbstractTableModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QAbstractTableModel) RowCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractTableModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QAbstractTableModel) RowCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractTableModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

type QAbstractTransition struct {
	QObject
}

type QAbstractTransition_ITF interface {
	QObject_ITF
	QAbstractTransition_PTR() *QAbstractTransition
}

func (ptr *QAbstractTransition) QAbstractTransition_PTR() *QAbstractTransition {
	return ptr
}

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

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

func PointerFromQAbstractTransition(ptr QAbstractTransition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractTransition_PTR().Pointer()
	}
	return nil
}

func NewQAbstractTransitionFromPointer(ptr unsafe.Pointer) (n *QAbstractTransition) {
	n = new(QAbstractTransition)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QAbstractTransition__TransitionType
//QAbstractTransition::TransitionType
type QAbstractTransition__TransitionType int64

const (
	QAbstractTransition__ExternalTransition QAbstractTransition__TransitionType = QAbstractTransition__TransitionType(0)
	QAbstractTransition__InternalTransition QAbstractTransition__TransitionType = QAbstractTransition__TransitionType(1)
)

func NewQAbstractTransition(sourceState QState_ITF) *QAbstractTransition {
	tmpValue := NewQAbstractTransitionFromPointer(C.QAbstractTransition_NewQAbstractTransition(PointerFromQState(sourceState)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QAbstractTransition) AddAnimation(animation QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_AddAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QAbstractTransition) Animations() []*QAbstractAnimation {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QAbstractAnimation {
			out := make([]*QAbstractAnimation, int(l.len))
			tmpList := NewQAbstractTransitionFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__animations_atList(i)
			}
			return out
		}(C.QAbstractTransition_Animations(ptr.Pointer()))
	}
	return make([]*QAbstractAnimation, 0)
}

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

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QAbstractTransition) ConnectEventTest(f func(event *QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "eventTest"); signal != nil {
			f := func(event *QEvent) bool {
				(*(*func(*QEvent) bool)(signal))(event)
				return f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "eventTest", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "eventTest", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractTransition) DisconnectEventTest() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "eventTest")
	}
}

func (ptr *QAbstractTransition) EventTest(event QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractTransition_EventTest(ptr.Pointer(), PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QAbstractTransition) Machine() *QStateMachine {
	if ptr.Pointer() != nil {
		tmpValue := NewQStateMachineFromPointer(C.QAbstractTransition_Machine(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAbstractTransition_OnTransition
func callbackQAbstractTransition_OnTransition(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onTransition"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	}

}

func (ptr *QAbstractTransition) ConnectOnTransition(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onTransition"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onTransition", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onTransition", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractTransition) DisconnectOnTransition() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onTransition")
	}
}

func (ptr *QAbstractTransition) OnTransition(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_OnTransition(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractTransition) RemoveAnimation(animation QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_RemoveAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QAbstractTransition) SetTargetState(target QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_SetTargetState(ptr.Pointer(), PointerFromQAbstractState(target))
	}
}

func (ptr *QAbstractTransition) SetTargetStates(targets []*QAbstractState) {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_SetTargetStates(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQAbstractTransitionFromPointer(NewQAbstractTransitionFromPointer(nil).__setTargetStates_targets_newList())
			for _, v := range targets {
				tmpList.__setTargetStates_targets_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QAbstractTransition) SetTransitionType(ty QAbstractTransition__TransitionType) {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_SetTransitionType(ptr.Pointer(), C.longlong(ty))
	}
}

func (ptr *QAbstractTransition) SourceState() *QState {
	if ptr.Pointer() != nil {
		tmpValue := NewQStateFromPointer(C.QAbstractTransition_SourceState(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractTransition) TargetState() *QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractStateFromPointer(C.QAbstractTransition_TargetState(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAbstractTransition_TargetStateChanged
func callbackQAbstractTransition_TargetStateChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "targetStateChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractTransition) ConnectTargetStateChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "targetStateChanged") {
			C.QAbstractTransition_ConnectTargetStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "targetStateChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "targetStateChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "targetStateChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "targetStateChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractTransition) DisconnectTargetStateChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_DisconnectTargetStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "targetStateChanged")
	}
}

func (ptr *QAbstractTransition) TargetStates() []*QAbstractState {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QAbstractState {
			out := make([]*QAbstractState, int(l.len))
			tmpList := NewQAbstractTransitionFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__targetStates_atList(i)
			}
			return out
		}(C.QAbstractTransition_TargetStates(ptr.Pointer()))
	}
	return make([]*QAbstractState, 0)
}

//export callbackQAbstractTransition_TargetStatesChanged
func callbackQAbstractTransition_TargetStatesChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "targetStatesChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractTransition) ConnectTargetStatesChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "targetStatesChanged") {
			C.QAbstractTransition_ConnectTargetStatesChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "targetStatesChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "targetStatesChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "targetStatesChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "targetStatesChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractTransition) DisconnectTargetStatesChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_DisconnectTargetStatesChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "targetStatesChanged")
	}
}

func (ptr *QAbstractTransition) TransitionType() QAbstractTransition__TransitionType {
	if ptr.Pointer() != nil {
		return QAbstractTransition__TransitionType(C.QAbstractTransition_TransitionType(ptr.Pointer()))
	}
	return 0
}

//export callbackQAbstractTransition_Triggered
func callbackQAbstractTransition_Triggered(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "triggered"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QAbstractTransition) ConnectTriggered(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "triggered") {
			C.QAbstractTransition_ConnectTriggered(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "triggered")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "triggered"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "triggered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "triggered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractTransition) DisconnectTriggered() {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_DisconnectTriggered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "triggered")
	}
}

//export callbackQAbstractTransition_DestroyQAbstractTransition
func callbackQAbstractTransition_DestroyQAbstractTransition(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractTransition"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractTransitionFromPointer(ptr).DestroyQAbstractTransitionDefault()
	}
}

func (ptr *QAbstractTransition) ConnectDestroyQAbstractTransition(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractTransition"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractTransition", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAbstractTransition", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractTransition) DisconnectDestroyQAbstractTransition() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAbstractTransition")
	}
}

func (ptr *QAbstractTransition) DestroyQAbstractTransition() {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_DestroyQAbstractTransition(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractTransition) DestroyQAbstractTransitionDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractTransition_DestroyQAbstractTransitionDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractTransition) __animations_atList(i int) *QAbstractAnimation {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractAnimationFromPointer(C.QAbstractTransition___animations_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractTransition) __animations_setList(i QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractTransition___animations_setList(ptr.Pointer(), PointerFromQAbstractAnimation(i))
	}
}

func (ptr *QAbstractTransition) __animations_newList() unsafe.Pointer {
	return C.QAbstractTransition___animations_newList(ptr.Pointer())
}

func (ptr *QAbstractTransition) __setTargetStates_targets_atList(i int) *QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractStateFromPointer(C.QAbstractTransition___setTargetStates_targets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractTransition) __setTargetStates_targets_setList(i QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractTransition___setTargetStates_targets_setList(ptr.Pointer(), PointerFromQAbstractState(i))
	}
}

func (ptr *QAbstractTransition) __setTargetStates_targets_newList() unsafe.Pointer {
	return C.QAbstractTransition___setTargetStates_targets_newList(ptr.Pointer())
}

func (ptr *QAbstractTransition) __targetStates_atList(i int) *QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractStateFromPointer(C.QAbstractTransition___targetStates_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractTransition) __targetStates_setList(i QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractTransition___targetStates_setList(ptr.Pointer(), PointerFromQAbstractState(i))
	}
}

func (ptr *QAbstractTransition) __targetStates_newList() unsafe.Pointer {
	return C.QAbstractTransition___targetStates_newList(ptr.Pointer())
}

type QAnimationGroup struct {
	QAbstractAnimation
}

type QAnimationGroup_ITF interface {
	QAbstractAnimation_ITF
	QAnimationGroup_PTR() *QAnimationGroup
}

func (ptr *QAnimationGroup) QAnimationGroup_PTR() *QAnimationGroup {
	return ptr
}

func (ptr *QAnimationGroup) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractAnimation_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQAnimationGroup(ptr QAnimationGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAnimationGroup_PTR().Pointer()
	}
	return nil
}

func NewQAnimationGroupFromPointer(ptr unsafe.Pointer) (n *QAnimationGroup) {
	n = new(QAnimationGroup)
	n.SetPointer(ptr)
	return
}
func NewQAnimationGroup(parent QObject_ITF) *QAnimationGroup {
	tmpValue := NewQAnimationGroupFromPointer(C.QAnimationGroup_NewQAnimationGroup(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QAnimationGroup) AddAnimation(animation QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QAnimationGroup_AddAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QAnimationGroup) AnimationAt(index int) *QAbstractAnimation {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractAnimationFromPointer(C.QAnimationGroup_AnimationAt(ptr.Pointer(), C.int(int32(index))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAnimationGroup) AnimationCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAnimationGroup_AnimationCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAnimationGroup) Clear() {
	if ptr.Pointer() != nil {
		C.QAnimationGroup_Clear(ptr.Pointer())
	}
}

func (ptr *QAnimationGroup) IndexOfAnimation(animation QAbstractAnimation_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAnimationGroup_IndexOfAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))))
	}
	return 0
}

func (ptr *QAnimationGroup) InsertAnimation(index int, animation QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QAnimationGroup_InsertAnimation(ptr.Pointer(), C.int(int32(index)), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QAnimationGroup) RemoveAnimation(animation QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QAnimationGroup_RemoveAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QAnimationGroup) TakeAnimation(index int) *QAbstractAnimation {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractAnimationFromPointer(C.QAnimationGroup_TakeAnimation(ptr.Pointer(), C.int(int32(index))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAnimationGroup_DestroyQAnimationGroup
func callbackQAnimationGroup_DestroyQAnimationGroup(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAnimationGroup"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAnimationGroupFromPointer(ptr).DestroyQAnimationGroupDefault()
	}
}

func (ptr *QAnimationGroup) ConnectDestroyQAnimationGroup(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QAnimationGroup"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QAnimationGroup", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QAnimationGroup", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAnimationGroup) DisconnectDestroyQAnimationGroup() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QAnimationGroup")
	}
}

func (ptr *QAnimationGroup) DestroyQAnimationGroup() {
	if ptr.Pointer() != nil {
		C.QAnimationGroup_DestroyQAnimationGroup(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAnimationGroup) DestroyQAnimationGroupDefault() {
	if ptr.Pointer() != nil {
		C.QAnimationGroup_DestroyQAnimationGroupDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQAnimationGroup_Duration
func callbackQAnimationGroup_Duration(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "duration"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQAnimationGroupFromPointer(ptr).DurationDefault()))
}

func (ptr *QAnimationGroup) Duration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAnimationGroup_Duration(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAnimationGroup) DurationDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAnimationGroup_DurationDefault(ptr.Pointer())))
	}
	return 0
}

//export callbackQAnimationGroup_UpdateCurrentTime
func callbackQAnimationGroup_UpdateCurrentTime(ptr unsafe.Pointer, currentTime C.int) {
	if signal := qt.GetSignal(ptr, "updateCurrentTime"); signal != nil {
		(*(*func(int))(signal))(int(int32(currentTime)))
	} else {
		NewQAnimationGroupFromPointer(ptr).UpdateCurrentTimeDefault(int(int32(currentTime)))
	}
}

func (ptr *QAnimationGroup) UpdateCurrentTime(currentTime int) {
	if ptr.Pointer() != nil {
		C.QAnimationGroup_UpdateCurrentTime(ptr.Pointer(), C.int(int32(currentTime)))
	}
}

func (ptr *QAnimationGroup) UpdateCurrentTimeDefault(currentTime int) {
	if ptr.Pointer() != nil {
		C.QAnimationGroup_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(int32(currentTime)))
	}
}

type QArgument struct {
	QGenericArgument
}

type QArgument_ITF interface {
	QGenericArgument_ITF
	QArgument_PTR() *QArgument
}

func (ptr *QArgument) QArgument_PTR() *QArgument {
	return ptr
}

func (ptr *QArgument) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericArgument_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQArgument(ptr QArgument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QArgument_PTR().Pointer()
	}
	return nil
}

func NewQArgumentFromPointer(ptr unsafe.Pointer) (n *QArgument) {
	n = new(QArgument)
	n.SetPointer(ptr)
	return
}

func (ptr *QArgument) DestroyQArgument() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QArrayData struct {
	ptr unsafe.Pointer
}

type QArrayData_ITF interface {
	QArrayData_PTR() *QArrayData
}

func (ptr *QArrayData) QArrayData_PTR() *QArrayData {
	return ptr
}

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

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

func PointerFromQArrayData(ptr QArrayData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QArrayData_PTR().Pointer()
	}
	return nil
}

func NewQArrayDataFromPointer(ptr unsafe.Pointer) (n *QArrayData) {
	n = new(QArrayData)
	n.SetPointer(ptr)
	return
}

func (ptr *QArrayData) DestroyQArrayData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QArrayDataPointer struct {
	ptr unsafe.Pointer
}

type QArrayDataPointer_ITF interface {
	QArrayDataPointer_PTR() *QArrayDataPointer
}

func (ptr *QArrayDataPointer) QArrayDataPointer_PTR() *QArrayDataPointer {
	return ptr
}

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

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

func PointerFromQArrayDataPointer(ptr QArrayDataPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QArrayDataPointer_PTR().Pointer()
	}
	return nil
}

func NewQArrayDataPointerFromPointer(ptr unsafe.Pointer) (n *QArrayDataPointer) {
	n = new(QArrayDataPointer)
	n.SetPointer(ptr)
	return
}

func (ptr *QArrayDataPointer) DestroyQArrayDataPointer() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QAssociativeIterable struct {
	ptr unsafe.Pointer
}

type QAssociativeIterable_ITF interface {
	QAssociativeIterable_PTR() *QAssociativeIterable
}

func (ptr *QAssociativeIterable) QAssociativeIterable_PTR() *QAssociativeIterable {
	return ptr
}

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

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

func PointerFromQAssociativeIterable(ptr QAssociativeIterable_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAssociativeIterable_PTR().Pointer()
	}
	return nil
}

func NewQAssociativeIterableFromPointer(ptr unsafe.Pointer) (n *QAssociativeIterable) {
	n = new(QAssociativeIterable)
	n.SetPointer(ptr)
	return
}

func (ptr *QAssociativeIterable) DestroyQAssociativeIterable() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAssociativeIterable) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAssociativeIterable_Size(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAssociativeIterable) Value(key QVariant_ITF) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QAssociativeIterable_Value(ptr.Pointer(), PointerFromQVariant(key)))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

type QAtomicInt struct {
	QAtomicInteger
}

type QAtomicInt_ITF interface {
	QAtomicInteger_ITF
	QAtomicInt_PTR() *QAtomicInt
}

func (ptr *QAtomicInt) QAtomicInt_PTR() *QAtomicInt {
	return ptr
}

func (ptr *QAtomicInt) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAtomicInteger_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQAtomicInt(ptr QAtomicInt_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAtomicInt_PTR().Pointer()
	}
	return nil
}

func NewQAtomicIntFromPointer(ptr unsafe.Pointer) (n *QAtomicInt) {
	n = new(QAtomicInt)
	n.SetPointer(ptr)
	return
}

func (ptr *QAtomicInt) DestroyQAtomicInt() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QAtomicInteger struct {
	QBasicAtomicInteger
}

type QAtomicInteger_ITF interface {
	QBasicAtomicInteger_ITF
	QAtomicInteger_PTR() *QAtomicInteger
}

func (ptr *QAtomicInteger) QAtomicInteger_PTR() *QAtomicInteger {
	return ptr
}

func (ptr *QAtomicInteger) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QBasicAtomicInteger_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQAtomicInteger(ptr QAtomicInteger_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAtomicInteger_PTR().Pointer()
	}
	return nil
}

func NewQAtomicIntegerFromPointer(ptr unsafe.Pointer) (n *QAtomicInteger) {
	n = new(QAtomicInteger)
	n.SetPointer(ptr)
	return
}

func (ptr *QAtomicInteger) DestroyQAtomicInteger() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QAtomicOps struct {
	ptr unsafe.Pointer
}

type QAtomicOps_ITF interface {
	QAtomicOps_PTR() *QAtomicOps
}

func (ptr *QAtomicOps) QAtomicOps_PTR() *QAtomicOps {
	return ptr
}

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

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

func PointerFromQAtomicOps(ptr QAtomicOps_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAtomicOps_PTR().Pointer()
	}
	return nil
}

func NewQAtomicOpsFromPointer(ptr unsafe.Pointer) (n *QAtomicOps) {
	n = new(QAtomicOps)
	n.SetPointer(ptr)
	return
}

func (ptr *QAtomicOps) DestroyQAtomicOps() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QAtomicPointer struct {
	QBasicAtomicPointer
}

type QAtomicPointer_ITF interface {
	QBasicAtomicPointer_ITF
	QAtomicPointer_PTR() *QAtomicPointer
}

func (ptr *QAtomicPointer) QAtomicPointer_PTR() *QAtomicPointer {
	return ptr
}

func (ptr *QAtomicPointer) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QBasicAtomicPointer_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQAtomicPointer(ptr QAtomicPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAtomicPointer_PTR().Pointer()
	}
	return nil
}

func NewQAtomicPointerFromPointer(ptr unsafe.Pointer) (n *QAtomicPointer) {
	n = new(QAtomicPointer)
	n.SetPointer(ptr)
	return
}

func (ptr *QAtomicPointer) DestroyQAtomicPointer() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QAtomicTraits struct {
	ptr unsafe.Pointer
}

type QAtomicTraits_ITF interface {
	QAtomicTraits_PTR() *QAtomicTraits
}

func (ptr *QAtomicTraits) QAtomicTraits_PTR() *QAtomicTraits {
	return ptr
}

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

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

func PointerFromQAtomicTraits(ptr QAtomicTraits_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAtomicTraits_PTR().Pointer()
	}
	return nil
}

func NewQAtomicTraitsFromPointer(ptr unsafe.Pointer) (n *QAtomicTraits) {
	n = new(QAtomicTraits)
	n.SetPointer(ptr)
	return
}

func (ptr *QAtomicTraits) DestroyQAtomicTraits() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QBEInteger struct {
	ptr unsafe.Pointer
}

type QBEInteger_ITF interface {
	QBEInteger_PTR() *QBEInteger
}

func (ptr *QBEInteger) QBEInteger_PTR() *QBEInteger {
	return ptr
}

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

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

func PointerFromQBEInteger(ptr QBEInteger_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBEInteger_PTR().Pointer()
	}
	return nil
}

func NewQBEIntegerFromPointer(ptr unsafe.Pointer) (n *QBEInteger) {
	n = new(QBEInteger)
	n.SetPointer(ptr)
	return
}

func (ptr *QBEInteger) DestroyQBEInteger() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QBasicAtomicInteger struct {
	ptr unsafe.Pointer
}

type QBasicAtomicInteger_ITF interface {
	QBasicAtomicInteger_PTR() *QBasicAtomicInteger
}

func (ptr *QBasicAtomicInteger) QBasicAtomicInteger_PTR() *QBasicAtomicInteger {
	return ptr
}

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

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

func PointerFromQBasicAtomicInteger(ptr QBasicAtomicInteger_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBasicAtomicInteger_PTR().Pointer()
	}
	return nil
}

func NewQBasicAtomicIntegerFromPointer(ptr unsafe.Pointer) (n *QBasicAtomicInteger) {
	n = new(QBasicAtomicInteger)
	n.SetPointer(ptr)
	return
}

func (ptr *QBasicAtomicInteger) DestroyQBasicAtomicInteger() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QBasicAtomicPointer struct {
	ptr unsafe.Pointer
}

type QBasicAtomicPointer_ITF interface {
	QBasicAtomicPointer_PTR() *QBasicAtomicPointer
}

func (ptr *QBasicAtomicPointer) QBasicAtomicPointer_PTR() *QBasicAtomicPointer {
	return ptr
}

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

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

func PointerFromQBasicAtomicPointer(ptr QBasicAtomicPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBasicAtomicPointer_PTR().Pointer()
	}
	return nil
}

func NewQBasicAtomicPointerFromPointer(ptr unsafe.Pointer) (n *QBasicAtomicPointer) {
	n = new(QBasicAtomicPointer)
	n.SetPointer(ptr)
	return
}

func (ptr *QBasicAtomicPointer) DestroyQBasicAtomicPointer() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QBasicMutex struct {
	ptr unsafe.Pointer
}

type QBasicMutex_ITF interface {
	QBasicMutex_PTR() *QBasicMutex
}

func (ptr *QBasicMutex) QBasicMutex_PTR() *QBasicMutex {
	return ptr
}

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

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

func PointerFromQBasicMutex(ptr QBasicMutex_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBasicMutex_PTR().Pointer()
	}
	return nil
}

func NewQBasicMutexFromPointer(ptr unsafe.Pointer) (n *QBasicMutex) {
	n = new(QBasicMutex)
	n.SetPointer(ptr)
	return
}

func (ptr *QBasicMutex) DestroyQBasicMutex() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QBasicMutex) IsRecursive2() bool {
	if ptr.Pointer() != nil {
		return int8(C.QBasicMutex_IsRecursive2(ptr.Pointer())) != 0
	}
	return false
}

type QBasicTimer struct {
	ptr unsafe.Pointer
}

type QBasicTimer_ITF interface {
	QBasicTimer_PTR() *QBasicTimer
}

func (ptr *QBasicTimer) QBasicTimer_PTR() *QBasicTimer {
	return ptr
}

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

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

func PointerFromQBasicTimer(ptr QBasicTimer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBasicTimer_PTR().Pointer()
	}
	return nil
}

func NewQBasicTimerFromPointer(ptr unsafe.Pointer) (n *QBasicTimer) {
	n = new(QBasicTimer)
	n.SetPointer(ptr)
	return
}
func NewQBasicTimer() *QBasicTimer {
	tmpValue := NewQBasicTimerFromPointer(C.QBasicTimer_NewQBasicTimer())
	runtime.SetFinalizer(tmpValue, (*QBasicTimer).DestroyQBasicTimer)
	return tmpValue
}

func (ptr *QBasicTimer) IsActive() bool {
	if ptr.Pointer() != nil {
		return int8(C.QBasicTimer_IsActive(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QBasicTimer) Start(msec int, object QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QBasicTimer_Start(ptr.Pointer(), C.int(int32(msec)), PointerFromQObject(object))
	}
}

func (ptr *QBasicTimer) Start2(msec int, timerType Qt__TimerType, obj QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QBasicTimer_Start2(ptr.Pointer(), C.int(int32(msec)), C.longlong(timerType), PointerFromQObject(obj))
	}
}

func (ptr *QBasicTimer) Stop() {
	if ptr.Pointer() != nil {
		C.QBasicTimer_Stop(ptr.Pointer())
	}
}

func (ptr *QBasicTimer) TimerId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QBasicTimer_TimerId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QBasicTimer) DestroyQBasicTimer() {
	if ptr.Pointer() != nil {
		C.QBasicTimer_DestroyQBasicTimer(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QBigEndianStorageType struct {
	ptr unsafe.Pointer
}

type QBigEndianStorageType_ITF interface {
	QBigEndianStorageType_PTR() *QBigEndianStorageType
}

func (ptr *QBigEndianStorageType) QBigEndianStorageType_PTR() *QBigEndianStorageType {
	return ptr
}

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

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

func PointerFromQBigEndianStorageType(ptr QBigEndianStorageType_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBigEndianStorageType_PTR().Pointer()
	}
	return nil
}

func NewQBigEndianStorageTypeFromPointer(ptr unsafe.Pointer) (n *QBigEndianStorageType) {
	n = new(QBigEndianStorageType)
	n.SetPointer(ptr)
	return
}

func (ptr *QBigEndianStorageType) DestroyQBigEndianStorageType() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QBitArray struct {
	ptr unsafe.Pointer
}

type QBitArray_ITF interface {
	QBitArray_PTR() *QBitArray
}

func (ptr *QBitArray) QBitArray_PTR() *QBitArray {
	return ptr
}

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

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

func PointerFromQBitArray(ptr QBitArray_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBitArray_PTR().Pointer()
	}
	return nil
}

func NewQBitArrayFromPointer(ptr unsafe.Pointer) (n *QBitArray) {
	n = new(QBitArray)
	n.SetPointer(ptr)
	return
}

func (ptr *QBitArray) DestroyQBitArray() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQBitArray() *QBitArray {
	tmpValue := NewQBitArrayFromPointer(C.QBitArray_NewQBitArray())
	runtime.SetFinalizer(tmpValue, (*QBitArray).DestroyQBitArray)
	return tmpValue
}

func NewQBitArray2(size int, value bool) *QBitArray {
	tmpValue := NewQBitArrayFromPointer(C.QBitArray_NewQBitArray2(C.int(int32(size)), C.char(int8(qt.GoBoolToInt(value)))))
	runtime.SetFinalizer(tmpValue, (*QBitArray).DestroyQBitArray)
	return tmpValue
}

func NewQBitArray3(other QBitArray_ITF) *QBitArray {
	tmpValue := NewQBitArrayFromPointer(C.QBitArray_NewQBitArray3(PointerFromQBitArray(other)))
	runtime.SetFinalizer(tmpValue, (*QBitArray).DestroyQBitArray)
	return tmpValue
}

func NewQBitArray4(other QBitArray_ITF) *QBitArray {
	tmpValue := NewQBitArrayFromPointer(C.QBitArray_NewQBitArray4(PointerFromQBitArray(other)))
	runtime.SetFinalizer(tmpValue, (*QBitArray).DestroyQBitArray)
	return tmpValue
}

func (ptr *QBitArray) At(i int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QBitArray_At(ptr.Pointer(), C.int(int32(i)))) != 0
	}
	return false
}

func (ptr *QBitArray) Bits() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QBitArray_Bits(ptr.Pointer()))
	}
	return ""
}

func (ptr *QBitArray) Clear() {
	if ptr.Pointer() != nil {
		C.QBitArray_Clear(ptr.Pointer())
	}
}

func (ptr *QBitArray) ClearBit(i int) {
	if ptr.Pointer() != nil {
		C.QBitArray_ClearBit(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QBitArray) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QBitArray_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QBitArray) Count2(on bool) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QBitArray_Count2(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))))
	}
	return 0
}

func (ptr *QBitArray) Fill(value bool, size int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QBitArray_Fill(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(value))), C.int(int32(size)))) != 0
	}
	return false
}

func (ptr *QBitArray) Fill2(value bool, begin int, end int) {
	if ptr.Pointer() != nil {
		C.QBitArray_Fill2(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(value))), C.int(int32(begin)), C.int(int32(end)))
	}
}

func (ptr *QBitArray) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QBitArray_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QBitArray) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QBitArray_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QBitArray) Resize(size int) {
	if ptr.Pointer() != nil {
		C.QBitArray_Resize(ptr.Pointer(), C.int(int32(size)))
	}
}

func (ptr *QBitArray) SetBit(i int) {
	if ptr.Pointer() != nil {
		C.QBitArray_SetBit(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QBitArray) SetBit2(i int, value bool) {
	if ptr.Pointer() != nil {
		C.QBitArray_SetBit2(ptr.Pointer(), C.int(int32(i)), C.char(int8(qt.GoBoolToInt(value))))
	}
}

func (ptr *QBitArray) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QBitArray_Size(ptr.Pointer())))
	}
	return 0
}

func (ptr *QBitArray) Swap(other QBitArray_ITF) {
	if ptr.Pointer() != nil {
		C.QBitArray_Swap(ptr.Pointer(), PointerFromQBitArray(other))
	}
}

func (ptr *QBitArray) TestBit(i int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QBitArray_TestBit(ptr.Pointer(), C.int(int32(i)))) != 0
	}
	return false
}

func (ptr *QBitArray) ToggleBit(i int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QBitArray_ToggleBit(ptr.Pointer(), C.int(int32(i)))) != 0
	}
	return false
}

func (ptr *QBitArray) Truncate(pos int) {
	if ptr.Pointer() != nil {
		C.QBitArray_Truncate(ptr.Pointer(), C.int(int32(pos)))
	}
}

type QBuffer struct {
	QIODevice
}

type QBuffer_ITF interface {
	QIODevice_ITF
	QBuffer_PTR() *QBuffer
}

func (ptr *QBuffer) QBuffer_PTR() *QBuffer {
	return ptr
}

func (ptr *QBuffer) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QIODevice_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQBuffer(ptr QBuffer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBuffer_PTR().Pointer()
	}
	return nil
}

func NewQBufferFromPointer(ptr unsafe.Pointer) (n *QBuffer) {
	n = new(QBuffer)
	n.SetPointer(ptr)
	return
}
func NewQBuffer(parent QObject_ITF) *QBuffer {
	tmpValue := NewQBufferFromPointer(C.QBuffer_NewQBuffer(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQBuffer2(byteArray QByteArray_ITF, parent QObject_ITF) *QBuffer {
	tmpValue := NewQBufferFromPointer(C.QBuffer_NewQBuffer2(PointerFromQByteArray(byteArray), PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QBuffer) Buffer() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QBuffer_Buffer(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QBuffer) Buffer2() *QByteArray {
	if ptr.Pointer() != nil {
		return NewQByteArrayFromPointer(C.QBuffer_Buffer2(ptr.Pointer()))
	}
	return nil
}

func (ptr *QBuffer) Data() *QByteArray {
	if ptr.Pointer() != nil {
		return NewQByteArrayFromPointer(C.QBuffer_Data(ptr.Pointer()))
	}
	return nil
}

//export callbackQBuffer_ReadData
func callbackQBuffer_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, l C.longlong) C.longlong {
	if signal := qt.GetSignal(ptr, "readData"); signal != nil {
		retS := cGoUnpackString(data)
		ret := C.longlong((*(*func(*string, int64) int64)(signal))(&retS, int64(l)))
		if ret > 0 {
			C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&retS)).Data), C.size_t(ret))
		}
		return ret
	}
	retS := cGoUnpackString(data)
	ret := C.longlong(NewQBufferFromPointer(ptr).ReadDataDefault(&retS, int64(l)))
	if ret > 0 {
		C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&retS)).Data), C.size_t(ret))
	}
	return ret
}

func (ptr *QBuffer) ConnectReadData(f func(data *string, l int64) int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "readData"); signal != nil {
			f := func(data *string, l int64) int64 {
				(*(*func(*string, int64) int64)(signal))(data, l)
				return f(data, l)
			}
			qt.ConnectSignal(ptr.Pointer(), "readData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "readData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QBuffer) DisconnectReadData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "readData")
	}
}

func (ptr *QBuffer) ReadData(data *string, l int64) int64 {
	if ptr.Pointer() != nil {
		dataC := C.CString(strings.Repeat("0", int(l)))
		defer C.free(unsafe.Pointer(dataC))
		ret := int64(C.QBuffer_ReadData(ptr.Pointer(), dataC, C.longlong(l)))
		if ret > 0 {
			*data = C.GoStringN(dataC, C.int(ret))
		}
		return ret
	}
	return 0
}

func (ptr *QBuffer) ReadDataDefault(data *string, l int64) int64 {
	if ptr.Pointer() != nil {
		dataC := C.CString(strings.Repeat("0", int(l)))
		defer C.free(unsafe.Pointer(dataC))
		ret := int64(C.QBuffer_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(l)))
		if ret > 0 {
			*data = C.GoStringN(dataC, C.int(ret))
		}
		return ret
	}
	return 0
}

func (ptr *QBuffer) SetBuffer(byteArray QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QBuffer_SetBuffer(ptr.Pointer(), PointerFromQByteArray(byteArray))
	}
}

func (ptr *QBuffer) SetData(data QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QBuffer_SetData(ptr.Pointer(), PointerFromQByteArray(data))
	}
}

func (ptr *QBuffer) SetData2(data []byte, size int) {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		C.QBuffer_SetData2(ptr.Pointer(), dataC, C.int(int32(size)))
	}
}

//export callbackQBuffer_WriteData
func callbackQBuffer_WriteData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, l C.longlong) C.longlong {
	if signal := qt.GetSignal(ptr, "writeData"); signal != nil {
		return C.longlong((*(*func([]byte, int64) int64)(signal))(cGoUnpackBytes(data), int64(l)))
	}

	return C.longlong(NewQBufferFromPointer(ptr).WriteDataDefault(cGoUnpackBytes(data), int64(l)))
}

func (ptr *QBuffer) ConnectWriteData(f func(data []byte, l int64) int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "writeData"); signal != nil {
			f := func(data []byte, l int64) int64 {
				(*(*func([]byte, int64) int64)(signal))(data, l)
				return f(data, l)
			}
			qt.ConnectSignal(ptr.Pointer(), "writeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "writeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QBuffer) DisconnectWriteData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "writeData")
	}
}

func (ptr *QBuffer) WriteData(data []byte, l int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QBuffer_WriteData(ptr.Pointer(), dataC, C.longlong(l)))
	}
	return 0
}

func (ptr *QBuffer) WriteDataDefault(data []byte, l int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QBuffer_WriteDataDefault(ptr.Pointer(), dataC, C.longlong(l)))
	}
	return 0
}

//export callbackQBuffer_DestroyQBuffer
func callbackQBuffer_DestroyQBuffer(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QBuffer"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQBufferFromPointer(ptr).DestroyQBufferDefault()
	}
}

func (ptr *QBuffer) ConnectDestroyQBuffer(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QBuffer"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QBuffer", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QBuffer", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QBuffer) DisconnectDestroyQBuffer() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QBuffer")
	}
}

func (ptr *QBuffer) DestroyQBuffer() {
	if ptr.Pointer() != nil {
		C.QBuffer_DestroyQBuffer(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QBuffer) DestroyQBufferDefault() {
	if ptr.Pointer() != nil {
		C.QBuffer_DestroyQBufferDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QByteArray struct {
	ptr unsafe.Pointer
}

type QByteArray_ITF interface {
	QByteArray_PTR() *QByteArray
}

func (ptr *QByteArray) QByteArray_PTR() *QByteArray {
	return ptr
}

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

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

func PointerFromQByteArray(ptr QByteArray_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QByteArray_PTR().Pointer()
	}
	return nil
}

func NewQByteArrayFromPointer(ptr unsafe.Pointer) (n *QByteArray) {
	n = new(QByteArray)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QByteArray__Base64Option
//QByteArray::Base64Option
type QByteArray__Base64Option int64

const (
	QByteArray__Base64Encoding     QByteArray__Base64Option = QByteArray__Base64Option(0)
	QByteArray__Base64UrlEncoding  QByteArray__Base64Option = QByteArray__Base64Option(1)
	QByteArray__KeepTrailingEquals QByteArray__Base64Option = QByteArray__Base64Option(0)
	QByteArray__OmitTrailingEquals QByteArray__Base64Option = QByteArray__Base64Option(2)
)

func NewQByteArray() *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_NewQByteArray())
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func NewQByteArray2(data string, size int) *QByteArray {
	var dataC *C.char
	if data != "" {
		dataC = C.CString(data)
		defer C.free(unsafe.Pointer(dataC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_NewQByteArray2(dataC, C.int(int32(size))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func NewQByteArray3(size int, ch string) *QByteArray {
	var chC *C.char
	if ch != "" {
		chC = C.CString(ch)
		defer C.free(unsafe.Pointer(chC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_NewQByteArray3(C.int(int32(size)), chC))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func NewQByteArray4(other QByteArray_ITF) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_NewQByteArray4(PointerFromQByteArray(other)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) Append(ba QByteArray_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Append(ptr.Pointer(), PointerFromQByteArray(ba)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Append2(ch string) *QByteArray {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Append2(ptr.Pointer(), chC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Append3(count int, ch string) *QByteArray {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Append3(ptr.Pointer(), C.int(int32(count)), chC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Append4(str string) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Append4(ptr.Pointer(), strC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Append5(str string, l int) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Append5(ptr.Pointer(), strC, C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Append6(str string) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Append6(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) At(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QByteArray_At(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QByteArray) Back() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QByteArray_Back(ptr.Pointer()))
	}
	return ""
}

func (ptr *QByteArray) Capacity() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QByteArray_Capacity(ptr.Pointer())))
	}
	return 0
}

func (ptr *QByteArray) Chop(n int) {
	if ptr.Pointer() != nil {
		C.QByteArray_Chop(ptr.Pointer(), C.int(int32(n)))
	}
}

func (ptr *QByteArray) Chopped(l int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Chopped(ptr.Pointer(), C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Clear() {
	if ptr.Pointer() != nil {
		C.QByteArray_Clear(ptr.Pointer())
	}
}

func (ptr *QByteArray) Compare(c string, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		var cC *C.char
		if c != "" {
			cC = C.CString(c)
			defer C.free(unsafe.Pointer(cC))
		}
		return int(int32(C.QByteArray_Compare(ptr.Pointer(), cC, C.longlong(cs))))
	}
	return 0
}

func (ptr *QByteArray) Compare2(a QByteArray_ITF, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QByteArray_Compare2(ptr.Pointer(), PointerFromQByteArray(a), C.longlong(cs))))
	}
	return 0
}

func (ptr *QByteArray) ConstData() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QByteArray_ConstData(ptr.Pointer()))
	}
	return ""
}

func (ptr *QByteArray) Contains(ba QByteArray_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QByteArray_Contains(ptr.Pointer(), PointerFromQByteArray(ba))) != 0
	}
	return false
}

func (ptr *QByteArray) Contains2(ch string) bool {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		return int8(C.QByteArray_Contains2(ptr.Pointer(), chC)) != 0
	}
	return false
}

func (ptr *QByteArray) Contains3(str string) bool {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int8(C.QByteArray_Contains3(ptr.Pointer(), strC)) != 0
	}
	return false
}

func (ptr *QByteArray) Count(ba QByteArray_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QByteArray_Count(ptr.Pointer(), PointerFromQByteArray(ba))))
	}
	return 0
}

func (ptr *QByteArray) Count2(ch string) int {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		return int(int32(C.QByteArray_Count2(ptr.Pointer(), chC)))
	}
	return 0
}

func (ptr *QByteArray) Count3(str string) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QByteArray_Count3(ptr.Pointer(), strC)))
	}
	return 0
}

func (ptr *QByteArray) Count4() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QByteArray_Count4(ptr.Pointer())))
	}
	return 0
}

func (ptr *QByteArray) Data() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QByteArray_Data(ptr.Pointer()))
	}
	return ""
}

func (ptr *QByteArray) Data2() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QByteArray_Data2(ptr.Pointer()))
	}
	return ""
}

func (ptr *QByteArray) EndsWith(ba QByteArray_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QByteArray_EndsWith(ptr.Pointer(), PointerFromQByteArray(ba))) != 0
	}
	return false
}

func (ptr *QByteArray) EndsWith2(ch string) bool {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		return int8(C.QByteArray_EndsWith2(ptr.Pointer(), chC)) != 0
	}
	return false
}

func (ptr *QByteArray) EndsWith3(str string) bool {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int8(C.QByteArray_EndsWith3(ptr.Pointer(), strC)) != 0
	}
	return false
}

func (ptr *QByteArray) Fill(ch string, size int) *QByteArray {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Fill(ptr.Pointer(), chC, C.int(int32(size))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func QByteArray_FromBase64(base64 QByteArray_ITF) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromBase64(PointerFromQByteArray(base64)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) FromBase64(base64 QByteArray_ITF) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromBase64(PointerFromQByteArray(base64)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QByteArray_FromBase642(base64 QByteArray_ITF, options QByteArray__Base64Option) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromBase642(PointerFromQByteArray(base64), C.longlong(options)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) FromBase642(base64 QByteArray_ITF, options QByteArray__Base64Option) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromBase642(PointerFromQByteArray(base64), C.longlong(options)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QByteArray_FromHex(hexEncoded QByteArray_ITF) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromHex(PointerFromQByteArray(hexEncoded)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) FromHex(hexEncoded QByteArray_ITF) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromHex(PointerFromQByteArray(hexEncoded)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QByteArray_FromPercentEncoding(input QByteArray_ITF, percent string) *QByteArray {
	var percentC *C.char
	if percent != "" {
		percentC = C.CString(percent)
		defer C.free(unsafe.Pointer(percentC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromPercentEncoding(PointerFromQByteArray(input), percentC))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) FromPercentEncoding(input QByteArray_ITF, percent string) *QByteArray {
	var percentC *C.char
	if percent != "" {
		percentC = C.CString(percent)
		defer C.free(unsafe.Pointer(percentC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromPercentEncoding(PointerFromQByteArray(input), percentC))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QByteArray_FromRawData(data []byte, size int) *QByteArray {
	var dataC *C.char
	if len(data) != 0 {
		dataC = (*C.char)(unsafe.Pointer(&data[0]))
	}
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromRawData(dataC, C.int(int32(size))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) FromRawData(data []byte, size int) *QByteArray {
	var dataC *C.char
	if len(data) != 0 {
		dataC = (*C.char)(unsafe.Pointer(&data[0]))
	}
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_FromRawData(dataC, C.int(int32(size))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) Front() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QByteArray_Front(ptr.Pointer()))
	}
	return ""
}

func (ptr *QByteArray) IndexOf(ba QByteArray_ITF, from int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QByteArray_IndexOf(ptr.Pointer(), PointerFromQByteArray(ba), C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArray) IndexOf2(ch string, from int) int {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		return int(int32(C.QByteArray_IndexOf2(ptr.Pointer(), chC, C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArray) IndexOf3(str string, from int) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QByteArray_IndexOf3(ptr.Pointer(), strC, C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArray) IndexOf4(str string, from int) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QByteArray_IndexOf4(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArray) Insert(i int, ba QByteArray_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Insert(ptr.Pointer(), C.int(int32(i)), PointerFromQByteArray(ba)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Insert2(i int, ch string) *QByteArray {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Insert2(ptr.Pointer(), C.int(int32(i)), chC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Insert3(i int, count int, ch string) *QByteArray {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Insert3(ptr.Pointer(), C.int(int32(i)), C.int(int32(count)), chC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Insert4(i int, str string) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Insert4(ptr.Pointer(), C.int(int32(i)), strC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Insert5(i int, str string, l int) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Insert5(ptr.Pointer(), C.int(int32(i)), strC, C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Insert6(i int, str string) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Insert6(ptr.Pointer(), C.int(int32(i)), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QByteArray_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QByteArray) IsLower() bool {
	if ptr.Pointer() != nil {
		return int8(C.QByteArray_IsLower(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QByteArray) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QByteArray_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QByteArray) IsUpper() bool {
	if ptr.Pointer() != nil {
		return int8(C.QByteArray_IsUpper(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QByteArray) LastIndexOf(ba QByteArray_ITF, from int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QByteArray_LastIndexOf(ptr.Pointer(), PointerFromQByteArray(ba), C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArray) LastIndexOf2(ch string, from int) int {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		return int(int32(C.QByteArray_LastIndexOf2(ptr.Pointer(), chC, C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArray) LastIndexOf3(str string, from int) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QByteArray_LastIndexOf3(ptr.Pointer(), strC, C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArray) LastIndexOf4(str string, from int) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QByteArray_LastIndexOf4(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArray) Left(l int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Left(ptr.Pointer(), C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) LeftJustified(width int, fill string, truncate bool) *QByteArray {
	if ptr.Pointer() != nil {
		var fillC *C.char
		if fill != "" {
			fillC = C.CString(fill)
			defer C.free(unsafe.Pointer(fillC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_LeftJustified(ptr.Pointer(), C.int(int32(width)), fillC, C.char(int8(qt.GoBoolToInt(truncate)))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Length() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QByteArray_Length(ptr.Pointer())))
	}
	return 0
}

func (ptr *QByteArray) Mid(pos int, l int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Mid(ptr.Pointer(), C.int(int32(pos)), C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func QByteArray_Number(n int, base int) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number(C.int(int32(n)), C.int(int32(base))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) Number(n int, base int) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number(C.int(int32(n)), C.int(int32(base))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QByteArray_Number2(n uint, base int) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number2(C.uint(uint32(n)), C.int(int32(base))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) Number2(n uint, base int) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number2(C.uint(uint32(n)), C.int(int32(base))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QByteArray_Number3(n int64, base int) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number3(C.longlong(n), C.int(int32(base))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) Number3(n int64, base int) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number3(C.longlong(n), C.int(int32(base))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QByteArray_Number4(n uint64, base int) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number4(C.ulonglong(n), C.int(int32(base))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) Number4(n uint64, base int) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number4(C.ulonglong(n), C.int(int32(base))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QByteArray_Number5(n float64, ff string, prec int) *QByteArray {
	var ffC *C.char
	if ff != "" {
		ffC = C.CString(ff)
		defer C.free(unsafe.Pointer(ffC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number5(C.double(n), ffC, C.int(int32(prec))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) Number5(n float64, ff string, prec int) *QByteArray {
	var ffC *C.char
	if ff != "" {
		ffC = C.CString(ff)
		defer C.free(unsafe.Pointer(ffC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QByteArray_QByteArray_Number5(C.double(n), ffC, C.int(int32(prec))))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QByteArray) Prepend(ba QByteArray_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Prepend(ptr.Pointer(), PointerFromQByteArray(ba)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Prepend2(ch string) *QByteArray {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Prepend2(ptr.Pointer(), chC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Prepend3(count int, ch string) *QByteArray {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Prepend3(ptr.Pointer(), C.int(int32(count)), chC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Prepend4(str string) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Prepend4(ptr.Pointer(), strC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Prepend5(str string, l int) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Prepend5(ptr.Pointer(), strC, C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Push_back(other QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QByteArray_Push_back(ptr.Pointer(), PointerFromQByteArray(other))
	}
}

func (ptr *QByteArray) Push_back2(ch string) {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		C.QByteArray_Push_back2(ptr.Pointer(), chC)
	}
}

func (ptr *QByteArray) Push_back3(str string) {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		C.QByteArray_Push_back3(ptr.Pointer(), strC)
	}
}

func (ptr *QByteArray) Push_front(other QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QByteArray_Push_front(ptr.Pointer(), PointerFromQByteArray(other))
	}
}

func (ptr *QByteArray) Push_front2(ch string) {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		C.QByteArray_Push_front2(ptr.Pointer(), chC)
	}
}

func (ptr *QByteArray) Push_front3(str string) {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		C.QByteArray_Push_front3(ptr.Pointer(), strC)
	}
}

func (ptr *QByteArray) Remove(pos int, l int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Remove(ptr.Pointer(), C.int(int32(pos)), C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Repeated(times int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Repeated(ptr.Pointer(), C.int(int32(times))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace(pos int, l int, after QByteArray_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace(ptr.Pointer(), C.int(int32(pos)), C.int(int32(l)), PointerFromQByteArray(after)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace2(pos int, l int, after string) *QByteArray {
	if ptr.Pointer() != nil {
		var afterC *C.char
		if after != "" {
			afterC = C.CString(after)
			defer C.free(unsafe.Pointer(afterC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace2(ptr.Pointer(), C.int(int32(pos)), C.int(int32(l)), afterC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace3(pos int, l int, after string, alen int) *QByteArray {
	if ptr.Pointer() != nil {
		var afterC *C.char
		if after != "" {
			afterC = C.CString(after)
			defer C.free(unsafe.Pointer(afterC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace3(ptr.Pointer(), C.int(int32(pos)), C.int(int32(l)), afterC, C.int(int32(alen))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace4(before string, after string) *QByteArray {
	if ptr.Pointer() != nil {
		var beforeC *C.char
		if before != "" {
			beforeC = C.CString(before)
			defer C.free(unsafe.Pointer(beforeC))
		}
		var afterC *C.char
		if after != "" {
			afterC = C.CString(after)
			defer C.free(unsafe.Pointer(afterC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace4(ptr.Pointer(), beforeC, afterC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace5(before string, after QByteArray_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		var beforeC *C.char
		if before != "" {
			beforeC = C.CString(before)
			defer C.free(unsafe.Pointer(beforeC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace5(ptr.Pointer(), beforeC, PointerFromQByteArray(after)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace6(before string, after string) *QByteArray {
	if ptr.Pointer() != nil {
		var beforeC *C.char
		if before != "" {
			beforeC = C.CString(before)
			defer C.free(unsafe.Pointer(beforeC))
		}
		var afterC *C.char
		if after != "" {
			afterC = C.CString(after)
			defer C.free(unsafe.Pointer(afterC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace6(ptr.Pointer(), beforeC, afterC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace7(before string, bsize int, after string, asize int) *QByteArray {
	if ptr.Pointer() != nil {
		var beforeC *C.char
		if before != "" {
			beforeC = C.CString(before)
			defer C.free(unsafe.Pointer(beforeC))
		}
		var afterC *C.char
		if after != "" {
			afterC = C.CString(after)
			defer C.free(unsafe.Pointer(afterC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace7(ptr.Pointer(), beforeC, C.int(int32(bsize)), afterC, C.int(int32(asize))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace8(before QByteArray_ITF, after QByteArray_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace8(ptr.Pointer(), PointerFromQByteArray(before), PointerFromQByteArray(after)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace9(before QByteArray_ITF, after string) *QByteArray {
	if ptr.Pointer() != nil {
		var afterC *C.char
		if after != "" {
			afterC = C.CString(after)
			defer C.free(unsafe.Pointer(afterC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace9(ptr.Pointer(), PointerFromQByteArray(before), afterC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace10(before string, after QByteArray_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		var beforeC *C.char
		if before != "" {
			beforeC = C.CString(before)
			defer C.free(unsafe.Pointer(beforeC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace10(ptr.Pointer(), beforeC, PointerFromQByteArray(after)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace11(before string, after string) *QByteArray {
	if ptr.Pointer() != nil {
		var beforeC *C.char
		if before != "" {
			beforeC = C.CString(before)
			defer C.free(unsafe.Pointer(beforeC))
		}
		var afterC *C.char
		if after != "" {
			afterC = C.CString(after)
			defer C.free(unsafe.Pointer(afterC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace11(ptr.Pointer(), beforeC, afterC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace12(before string, after string) *QByteArray {
	if ptr.Pointer() != nil {
		var beforeC *C.char
		if before != "" {
			beforeC = C.CString(before)
			defer C.free(unsafe.Pointer(beforeC))
		}
		var afterC *C.char
		if after != "" {
			afterC = C.CString(after)
			defer C.free(unsafe.Pointer(afterC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace12(ptr.Pointer(), C.struct_QtCore_PackedString{data: beforeC, len: C.longlong(len(before))}, afterC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace13(before string, after string) *QByteArray {
	if ptr.Pointer() != nil {
		var beforeC *C.char
		if before != "" {
			beforeC = C.CString(before)
			defer C.free(unsafe.Pointer(beforeC))
		}
		var afterC *C.char
		if after != "" {
			afterC = C.CString(after)
			defer C.free(unsafe.Pointer(afterC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace13(ptr.Pointer(), beforeC, C.struct_QtCore_PackedString{data: afterC, len: C.longlong(len(after))}))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Replace14(before string, after QByteArray_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		var beforeC *C.char
		if before != "" {
			beforeC = C.CString(before)
			defer C.free(unsafe.Pointer(beforeC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Replace14(ptr.Pointer(), C.struct_QtCore_PackedString{data: beforeC, len: C.longlong(len(before))}, PointerFromQByteArray(after)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Reserve(size int) {
	if ptr.Pointer() != nil {
		C.QByteArray_Reserve(ptr.Pointer(), C.int(int32(size)))
	}
}

func (ptr *QByteArray) Resize(size int) {
	if ptr.Pointer() != nil {
		C.QByteArray_Resize(ptr.Pointer(), C.int(int32(size)))
	}
}

func (ptr *QByteArray) Right(l int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Right(ptr.Pointer(), C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) RightJustified(width int, fill string, truncate bool) *QByteArray {
	if ptr.Pointer() != nil {
		var fillC *C.char
		if fill != "" {
			fillC = C.CString(fill)
			defer C.free(unsafe.Pointer(fillC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_RightJustified(ptr.Pointer(), C.int(int32(width)), fillC, C.char(int8(qt.GoBoolToInt(truncate)))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) SetNum(n int, base int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum(ptr.Pointer(), C.int(int32(n)), C.int(int32(base))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) SetNum2(n int16, base int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum2(ptr.Pointer(), C.short(n), C.int(int32(base))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) SetNum3(n uint16, base int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum3(ptr.Pointer(), C.ushort(n), C.int(int32(base))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) SetNum4(n uint, base int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum4(ptr.Pointer(), C.uint(uint32(n)), C.int(int32(base))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) SetNum5(n int64, base int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum5(ptr.Pointer(), C.longlong(n), C.int(int32(base))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) SetNum6(n uint64, base int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum6(ptr.Pointer(), C.ulonglong(n), C.int(int32(base))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) SetNum7(n float32, ff string, prec int) *QByteArray {
	if ptr.Pointer() != nil {
		var ffC *C.char
		if ff != "" {
			ffC = C.CString(ff)
			defer C.free(unsafe.Pointer(ffC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum7(ptr.Pointer(), C.float(n), ffC, C.int(int32(prec))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) SetNum8(n float64, ff string, prec int) *QByteArray {
	if ptr.Pointer() != nil {
		var ffC *C.char
		if ff != "" {
			ffC = C.CString(ff)
			defer C.free(unsafe.Pointer(ffC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetNum8(ptr.Pointer(), C.double(n), ffC, C.int(int32(prec))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) SetRawData(data []byte, size uint) *QByteArray {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_SetRawData(ptr.Pointer(), dataC, C.uint(uint32(size))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Shrink_to_fit() {
	if ptr.Pointer() != nil {
		C.QByteArray_Shrink_to_fit(ptr.Pointer())
	}
}

func (ptr *QByteArray) Simplified() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Simplified(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QByteArray_Size(ptr.Pointer())))
	}
	return 0
}

func (ptr *QByteArray) Split(sep string) []*QByteArray {
	if ptr.Pointer() != nil {
		var sepC *C.char
		if sep != "" {
			sepC = C.CString(sep)
			defer C.free(unsafe.Pointer(sepC))
		}
		return func(l C.struct_QtCore_PackedList) []*QByteArray {
			out := make([]*QByteArray, int(l.len))
			tmpList := NewQByteArrayFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__split_atList(i)
			}
			return out
		}(C.QByteArray_Split(ptr.Pointer(), sepC))
	}
	return make([]*QByteArray, 0)
}

func (ptr *QByteArray) Squeeze() {
	if ptr.Pointer() != nil {
		C.QByteArray_Squeeze(ptr.Pointer())
	}
}

func (ptr *QByteArray) StartsWith(ba QByteArray_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QByteArray_StartsWith(ptr.Pointer(), PointerFromQByteArray(ba))) != 0
	}
	return false
}

func (ptr *QByteArray) StartsWith2(ch string) bool {
	if ptr.Pointer() != nil {
		var chC *C.char
		if ch != "" {
			chC = C.CString(ch)
			defer C.free(unsafe.Pointer(chC))
		}
		return int8(C.QByteArray_StartsWith2(ptr.Pointer(), chC)) != 0
	}
	return false
}

func (ptr *QByteArray) StartsWith3(str string) bool {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int8(C.QByteArray_StartsWith3(ptr.Pointer(), strC)) != 0
	}
	return false
}

func (ptr *QByteArray) Swap(other QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QByteArray_Swap(ptr.Pointer(), PointerFromQByteArray(other))
	}
}

func (ptr *QByteArray) ToBase64() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_ToBase64(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) ToBase642(options QByteArray__Base64Option) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_ToBase642(ptr.Pointer(), C.longlong(options)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) ToDouble(ok *bool) float64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float64(C.QByteArray_ToDouble(ptr.Pointer(), &okC))
	}
	return 0
}

func (ptr *QByteArray) ToFloat(ok *bool) float32 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float32(C.QByteArray_ToFloat(ptr.Pointer(), &okC))
	}
	return 0
}

func (ptr *QByteArray) ToHex() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_ToHex(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) ToHex2(separator string) *QByteArray {
	if ptr.Pointer() != nil {
		var separatorC *C.char
		if separator != "" {
			separatorC = C.CString(separator)
			defer C.free(unsafe.Pointer(separatorC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_ToHex2(ptr.Pointer(), separatorC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) ToInt(ok *bool, base int) int {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QByteArray_ToInt(ptr.Pointer(), &okC, C.int(int32(base)))))
	}
	return 0
}

func (ptr *QByteArray) ToLong(ok *bool, base int) int {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QByteArray_ToLong(ptr.Pointer(), &okC, C.int(int32(base)))))
	}
	return 0
}

func (ptr *QByteArray) ToLongLong(ok *bool, base int) int64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int64(C.QByteArray_ToLongLong(ptr.Pointer(), &okC, C.int(int32(base))))
	}
	return 0
}

func (ptr *QByteArray) ToLower() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_ToLower(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) ToPercentEncoding(exclude QByteArray_ITF, include QByteArray_ITF, percent string) *QByteArray {
	if ptr.Pointer() != nil {
		var percentC *C.char
		if percent != "" {
			percentC = C.CString(percent)
			defer C.free(unsafe.Pointer(percentC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_ToPercentEncoding(ptr.Pointer(), PointerFromQByteArray(exclude), PointerFromQByteArray(include), percentC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) ToShort(ok *bool, base int) int16 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int16(C.QByteArray_ToShort(ptr.Pointer(), &okC, C.int(int32(base))))
	}
	return 0
}

func (ptr *QByteArray) ToUInt(ok *bool, base int) uint {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QByteArray_ToUInt(ptr.Pointer(), &okC, C.int(int32(base)))))
	}
	return 0
}

func (ptr *QByteArray) ToULong(ok *bool, base int) uint {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QByteArray_ToULong(ptr.Pointer(), &okC, C.int(int32(base)))))
	}
	return 0
}

func (ptr *QByteArray) ToULongLong(ok *bool, base int) uint64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint64(C.QByteArray_ToULongLong(ptr.Pointer(), &okC, C.int(int32(base))))
	}
	return 0
}

func (ptr *QByteArray) ToUShort(ok *bool, base int) uint16 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint16(C.QByteArray_ToUShort(ptr.Pointer(), &okC, C.int(int32(base))))
	}
	return 0
}

func (ptr *QByteArray) ToUpper() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_ToUpper(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Trimmed() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray_Trimmed(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) Truncate(pos int) {
	if ptr.Pointer() != nil {
		C.QByteArray_Truncate(ptr.Pointer(), C.int(int32(pos)))
	}
}

func (ptr *QByteArray) DestroyQByteArray() {
	if ptr.Pointer() != nil {
		C.QByteArray_DestroyQByteArray(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QByteArray) __split_atList(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArray___split_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArray) __split_setList(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QByteArray___split_setList(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QByteArray) __split_newList() unsafe.Pointer {
	return C.QByteArray___split_newList(ptr.Pointer())
}

type QByteArrayList struct {
	ptr unsafe.Pointer
}

type QByteArrayList_ITF interface {
	QByteArrayList_PTR() *QByteArrayList
}

func (ptr *QByteArrayList) QByteArrayList_PTR() *QByteArrayList {
	return ptr
}

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

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

func PointerFromQByteArrayList(ptr QByteArrayList_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QByteArrayList_PTR().Pointer()
	}
	return nil
}

func NewQByteArrayListFromPointer(ptr unsafe.Pointer) (n *QByteArrayList) {
	n = new(QByteArrayList)
	n.SetPointer(ptr)
	return
}

func (ptr *QByteArrayList) DestroyQByteArrayList() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QByteArrayList) IndexOf(needle string, from int) int {
	if ptr.Pointer() != nil {
		var needleC *C.char
		if needle != "" {
			needleC = C.CString(needle)
			defer C.free(unsafe.Pointer(needleC))
		}
		return int(int32(C.QByteArrayList_IndexOf(ptr.Pointer(), needleC, C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArrayList) Join() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArrayList_Join(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArrayList) Join2(separator QByteArray_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArrayList_Join2(ptr.Pointer(), PointerFromQByteArray(separator)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArrayList) Join3(separator string) *QByteArray {
	if ptr.Pointer() != nil {
		var separatorC *C.char
		if separator != "" {
			separatorC = C.CString(separator)
			defer C.free(unsafe.Pointer(separatorC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QByteArrayList_Join3(ptr.Pointer(), separatorC))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

type QByteArrayMatcher struct {
	ptr unsafe.Pointer
}

type QByteArrayMatcher_ITF interface {
	QByteArrayMatcher_PTR() *QByteArrayMatcher
}

func (ptr *QByteArrayMatcher) QByteArrayMatcher_PTR() *QByteArrayMatcher {
	return ptr
}

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

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

func PointerFromQByteArrayMatcher(ptr QByteArrayMatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QByteArrayMatcher_PTR().Pointer()
	}
	return nil
}

func NewQByteArrayMatcherFromPointer(ptr unsafe.Pointer) (n *QByteArrayMatcher) {
	n = new(QByteArrayMatcher)
	n.SetPointer(ptr)
	return
}
func NewQByteArrayMatcher() *QByteArrayMatcher {
	tmpValue := NewQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher())
	runtime.SetFinalizer(tmpValue, (*QByteArrayMatcher).DestroyQByteArrayMatcher)
	return tmpValue
}

func NewQByteArrayMatcher2(pattern QByteArray_ITF) *QByteArrayMatcher {
	tmpValue := NewQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher2(PointerFromQByteArray(pattern)))
	runtime.SetFinalizer(tmpValue, (*QByteArrayMatcher).DestroyQByteArrayMatcher)
	return tmpValue
}

func NewQByteArrayMatcher3(pattern string, length int) *QByteArrayMatcher {
	var patternC *C.char
	if pattern != "" {
		patternC = C.CString(pattern)
		defer C.free(unsafe.Pointer(patternC))
	}
	tmpValue := NewQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher3(patternC, C.int(int32(length))))
	runtime.SetFinalizer(tmpValue, (*QByteArrayMatcher).DestroyQByteArrayMatcher)
	return tmpValue
}

func NewQByteArrayMatcher4(other QByteArrayMatcher_ITF) *QByteArrayMatcher {
	tmpValue := NewQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher4(PointerFromQByteArrayMatcher(other)))
	runtime.SetFinalizer(tmpValue, (*QByteArrayMatcher).DestroyQByteArrayMatcher)
	return tmpValue
}

func (ptr *QByteArrayMatcher) IndexIn(ba QByteArray_ITF, from int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QByteArrayMatcher_IndexIn(ptr.Pointer(), PointerFromQByteArray(ba), C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArrayMatcher) IndexIn2(str string, l int, from int) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QByteArrayMatcher_IndexIn2(ptr.Pointer(), strC, C.int(int32(l)), C.int(int32(from)))))
	}
	return 0
}

func (ptr *QByteArrayMatcher) Pattern() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QByteArrayMatcher_Pattern(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QByteArrayMatcher) SetPattern(pattern QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QByteArrayMatcher_SetPattern(ptr.Pointer(), PointerFromQByteArray(pattern))
	}
}

func (ptr *QByteArrayMatcher) DestroyQByteArrayMatcher() {
	if ptr.Pointer() != nil {
		C.QByteArrayMatcher_DestroyQByteArrayMatcher(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QByteRef struct {
	ptr unsafe.Pointer
}

type QByteRef_ITF interface {
	QByteRef_PTR() *QByteRef
}

func (ptr *QByteRef) QByteRef_PTR() *QByteRef {
	return ptr
}

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

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

func PointerFromQByteRef(ptr QByteRef_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QByteRef_PTR().Pointer()
	}
	return nil
}

func NewQByteRefFromPointer(ptr unsafe.Pointer) (n *QByteRef) {
	n = new(QByteRef)
	n.SetPointer(ptr)
	return
}

func (ptr *QByteRef) DestroyQByteRef() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QCache struct {
	ptr unsafe.Pointer
}

type QCache_ITF interface {
	QCache_PTR() *QCache
}

func (ptr *QCache) QCache_PTR() *QCache {
	return ptr
}

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

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

func PointerFromQCache(ptr QCache_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCache_PTR().Pointer()
	}
	return nil
}

func NewQCacheFromPointer(ptr unsafe.Pointer) (n *QCache) {
	n = new(QCache)
	n.SetPointer(ptr)
	return
}

type QCborArray struct {
	ptr unsafe.Pointer
}

type QCborArray_ITF interface {
	QCborArray_PTR() *QCborArray
}

func (ptr *QCborArray) QCborArray_PTR() *QCborArray {
	return ptr
}

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

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

func PointerFromQCborArray(ptr QCborArray_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCborArray_PTR().Pointer()
	}
	return nil
}

func NewQCborArrayFromPointer(ptr unsafe.Pointer) (n *QCborArray) {
	n = new(QCborArray)
	n.SetPointer(ptr)
	return
}
func NewQCborArray() *QCborArray {
	tmpValue := NewQCborArrayFromPointer(C.QCborArray_NewQCborArray())
	runtime.SetFinalizer(tmpValue, (*QCborArray).DestroyQCborArray)
	return tmpValue
}

func NewQCborArray2(other QCborArray_ITF) *QCborArray {
	tmpValue := NewQCborArrayFromPointer(C.QCborArray_NewQCborArray2(PointerFromQCborArray(other)))
	runtime.SetFinalizer(tmpValue, (*QCborArray).DestroyQCborArray)
	return tmpValue
}

func (ptr *QCborArray) Append(value QCborValue_ITF) {
	if ptr.Pointer() != nil {
		C.QCborArray_Append(ptr.Pointer(), PointerFromQCborValue(value))
	}
}

func (ptr *QCborArray) Append2(value QCborValue_ITF) {
	if ptr.Pointer() != nil {
		C.QCborArray_Append2(ptr.Pointer(), PointerFromQCborValue(value))
	}
}

func (ptr *QCborArray) Clear() {
	if ptr.Pointer() != nil {
		C.QCborArray_Clear(ptr.Pointer())
	}
}

func (ptr *QCborArray) Compare(other QCborArray_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCborArray_Compare(ptr.Pointer(), PointerFromQCborArray(other))))
	}
	return 0
}

func (ptr *QCborArray) Contains(value QCborValue_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCborArray_Contains(ptr.Pointer(), PointerFromQCborValue(value))) != 0
	}
	return false
}

func (ptr *QCborArray) Empty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCborArray_Empty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QCborArray) First() *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborArray_First(ptr.Pointer()))
	}
	return nil
}

func QCborArray_FromJsonArray(array QJsonArray_ITF) *QCborArray {
	tmpValue := NewQCborArrayFromPointer(C.QCborArray_QCborArray_FromJsonArray(PointerFromQJsonArray(array)))
	runtime.SetFinalizer(tmpValue, (*QCborArray).DestroyQCborArray)
	return tmpValue
}

func (ptr *QCborArray) FromJsonArray(array QJsonArray_ITF) *QCborArray {
	tmpValue := NewQCborArrayFromPointer(C.QCborArray_QCborArray_FromJsonArray(PointerFromQJsonArray(array)))
	runtime.SetFinalizer(tmpValue, (*QCborArray).DestroyQCborArray)
	return tmpValue
}

func QCborArray_FromStringList(list []string) *QCborArray {
	listC := C.CString(strings.Join(list, "¡¦!"))
	defer C.free(unsafe.Pointer(listC))
	tmpValue := NewQCborArrayFromPointer(C.QCborArray_QCborArray_FromStringList(C.struct_QtCore_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "¡¦!")))}))
	runtime.SetFinalizer(tmpValue, (*QCborArray).DestroyQCborArray)
	return tmpValue
}

func (ptr *QCborArray) FromStringList(list []string) *QCborArray {
	listC := C.CString(strings.Join(list, "¡¦!"))
	defer C.free(unsafe.Pointer(listC))
	tmpValue := NewQCborArrayFromPointer(C.QCborArray_QCborArray_FromStringList(C.struct_QtCore_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "¡¦!")))}))
	runtime.SetFinalizer(tmpValue, (*QCborArray).DestroyQCborArray)
	return tmpValue
}

func QCborArray_FromVariantList(list []*QVariant) *QCborArray {
	tmpValue := NewQCborArrayFromPointer(C.QCborArray_QCborArray_FromVariantList(func() unsafe.Pointer {
		tmpList := NewQCborArrayFromPointer(NewQCborArrayFromPointer(nil).__fromVariantList_list_newList())
		for _, v := range list {
			tmpList.__fromVariantList_list_setList(v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QCborArray).DestroyQCborArray)
	return tmpValue
}

func (ptr *QCborArray) FromVariantList(list []*QVariant) *QCborArray {
	tmpValue := NewQCborArrayFromPointer(C.QCborArray_QCborArray_FromVariantList(func() unsafe.Pointer {
		tmpList := NewQCborArrayFromPointer(NewQCborArrayFromPointer(nil).__fromVariantList_list_newList())
		for _, v := range list {
			tmpList.__fromVariantList_list_setList(v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QCborArray).DestroyQCborArray)
	return tmpValue
}

func (ptr *QCborArray) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCborArray_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QCborArray) Last() *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborArray_Last(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCborArray) Pop_back() {
	if ptr.Pointer() != nil {
		C.QCborArray_Pop_back(ptr.Pointer())
	}
}

func (ptr *QCborArray) Pop_front() {
	if ptr.Pointer() != nil {
		C.QCborArray_Pop_front(ptr.Pointer())
	}
}

func (ptr *QCborArray) Prepend(value QCborValue_ITF) {
	if ptr.Pointer() != nil {
		C.QCborArray_Prepend(ptr.Pointer(), PointerFromQCborValue(value))
	}
}

func (ptr *QCborArray) Prepend2(value QCborValue_ITF) {
	if ptr.Pointer() != nil {
		C.QCborArray_Prepend2(ptr.Pointer(), PointerFromQCborValue(value))
	}
}

func (ptr *QCborArray) Push_back(t QCborValue_ITF) {
	if ptr.Pointer() != nil {
		C.QCborArray_Push_back(ptr.Pointer(), PointerFromQCborValue(t))
	}
}

func (ptr *QCborArray) Push_front(t QCborValue_ITF) {
	if ptr.Pointer() != nil {
		C.QCborArray_Push_front(ptr.Pointer(), PointerFromQCborValue(t))
	}
}

func (ptr *QCborArray) RemoveFirst() {
	if ptr.Pointer() != nil {
		C.QCborArray_RemoveFirst(ptr.Pointer())
	}
}

func (ptr *QCborArray) RemoveLast() {
	if ptr.Pointer() != nil {
		C.QCborArray_RemoveLast(ptr.Pointer())
	}
}

func (ptr *QCborArray) Swap(other QCborArray_ITF) {
	if ptr.Pointer() != nil {
		C.QCborArray_Swap(ptr.Pointer(), PointerFromQCborArray(other))
	}
}

func (ptr *QCborArray) TakeFirst() *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborArray_TakeFirst(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCborArray) TakeLast() *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborArray_TakeLast(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCborArray) ToCborValue() *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborArray_ToCborValue(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCborArray) ToJsonArray() *QJsonArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonArrayFromPointer(C.QCborArray_ToJsonArray(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
		return tmpValue
	}
	return nil
}

func (ptr *QCborArray) ToVariantList() []*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QVariant {
			out := make([]*QVariant, int(l.len))
			tmpList := NewQCborArrayFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__toVariantList_atList(i)
			}
			return out
		}(C.QCborArray_ToVariantList(ptr.Pointer()))
	}
	return make([]*QVariant, 0)
}

func (ptr *QCborArray) DestroyQCborArray() {
	if ptr.Pointer() != nil {
		C.QCborArray_DestroyQCborArray(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCborArray) __fromVariantList_list_atList(i int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QCborArray___fromVariantList_list_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QCborArray) __fromVariantList_list_setList(i QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QCborArray___fromVariantList_list_setList(ptr.Pointer(), PointerFromQVariant(i))
	}
}

func (ptr *QCborArray) __fromVariantList_list_newList() unsafe.Pointer {
	return C.QCborArray___fromVariantList_list_newList(ptr.Pointer())
}

func (ptr *QCborArray) __toVariantList_atList(i int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QCborArray___toVariantList_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QCborArray) __toVariantList_setList(i QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QCborArray___toVariantList_setList(ptr.Pointer(), PointerFromQVariant(i))
	}
}

func (ptr *QCborArray) __toVariantList_newList() unsafe.Pointer {
	return C.QCborArray___toVariantList_newList(ptr.Pointer())
}

type QCborError struct {
	ptr unsafe.Pointer
}

type QCborError_ITF interface {
	QCborError_PTR() *QCborError
}

func (ptr *QCborError) QCborError_PTR() *QCborError {
	return ptr
}

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

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

func PointerFromQCborError(ptr QCborError_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCborError_PTR().Pointer()
	}
	return nil
}

func NewQCborErrorFromPointer(ptr unsafe.Pointer) (n *QCborError) {
	n = new(QCborError)
	n.SetPointer(ptr)
	return
}

func (ptr *QCborError) DestroyQCborError() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QCborError__Code
//QCborError::Code
type QCborError__Code int64

const (
	QCborError__UnknownError      QCborError__Code = QCborError__Code(1)
	QCborError__AdvancePastEnd    QCborError__Code = QCborError__Code(3)
	QCborError__InputOutputError  QCborError__Code = QCborError__Code(4)
	QCborError__GarbageAtEnd      QCborError__Code = QCborError__Code(256)
	QCborError__EndOfFile         QCborError__Code = QCborError__Code(257)
	QCborError__UnexpectedBreak   QCborError__Code = QCborError__Code(258)
	QCborError__UnknownType       QCborError__Code = QCborError__Code(259)
	QCborError__IllegalType       QCborError__Code = QCborError__Code(260)
	QCborError__IllegalNumber     QCborError__Code = QCborError__Code(261)
	QCborError__IllegalSimpleType QCborError__Code = QCborError__Code(262)
	QCborError__InvalidUtf8String QCborError__Code = QCborError__Code(516)
	QCborError__DataTooLarge      QCborError__Code = QCborError__Code(1024)
	QCborError__NestingTooDeep    QCborError__Code = QCborError__Code(1025)
	QCborError__UnsupportedType   QCborError__Code = QCborError__Code(1026)
	QCborError__NoError           QCborError__Code = QCborError__Code(0)
)

func (ptr *QCborError) ToString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCborError_ToString(ptr.Pointer()))
	}
	return ""
}

type QCborMap struct {
	ptr unsafe.Pointer
}

type QCborMap_ITF interface {
	QCborMap_PTR() *QCborMap
}

func (ptr *QCborMap) QCborMap_PTR() *QCborMap {
	return ptr
}

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

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

func PointerFromQCborMap(ptr QCborMap_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCborMap_PTR().Pointer()
	}
	return nil
}

func NewQCborMapFromPointer(ptr unsafe.Pointer) (n *QCborMap) {
	n = new(QCborMap)
	n.SetPointer(ptr)
	return
}
func NewQCborMap() *QCborMap {
	tmpValue := NewQCborMapFromPointer(C.QCborMap_NewQCborMap())
	runtime.SetFinalizer(tmpValue, (*QCborMap).DestroyQCborMap)
	return tmpValue
}

func NewQCborMap2(other QCborMap_ITF) *QCborMap {
	tmpValue := NewQCborMapFromPointer(C.QCborMap_NewQCborMap2(PointerFromQCborMap(other)))
	runtime.SetFinalizer(tmpValue, (*QCborMap).DestroyQCborMap)
	return tmpValue
}

func (ptr *QCborMap) Clear() {
	if ptr.Pointer() != nil {
		C.QCborMap_Clear(ptr.Pointer())
	}
}

func (ptr *QCborMap) Compare(other QCborMap_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCborMap_Compare(ptr.Pointer(), PointerFromQCborMap(other))))
	}
	return 0
}

func (ptr *QCborMap) Contains(key int64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCborMap_Contains(ptr.Pointer(), C.longlong(key))) != 0
	}
	return false
}

func (ptr *QCborMap) Contains2(key QLatin1String_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCborMap_Contains2(ptr.Pointer(), PointerFromQLatin1String(key))) != 0
	}
	return false
}

func (ptr *QCborMap) Contains3(key string) bool {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		return int8(C.QCborMap_Contains3(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})) != 0
	}
	return false
}

func (ptr *QCborMap) Contains4(key QCborValue_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCborMap_Contains4(ptr.Pointer(), PointerFromQCborValue(key))) != 0
	}
	return false
}

func (ptr *QCborMap) Empty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCborMap_Empty(ptr.Pointer())) != 0
	}
	return false
}

func QCborMap_FromJsonObject(obj QJsonObject_ITF) *QCborMap {
	tmpValue := NewQCborMapFromPointer(C.QCborMap_QCborMap_FromJsonObject(PointerFromQJsonObject(obj)))
	runtime.SetFinalizer(tmpValue, (*QCborMap).DestroyQCborMap)
	return tmpValue
}

func (ptr *QCborMap) FromJsonObject(obj QJsonObject_ITF) *QCborMap {
	tmpValue := NewQCborMapFromPointer(C.QCborMap_QCborMap_FromJsonObject(PointerFromQJsonObject(obj)))
	runtime.SetFinalizer(tmpValue, (*QCborMap).DestroyQCborMap)
	return tmpValue
}

func QCborMap_FromVariantHash(hash map[string]*QVariant) *QCborMap {
	tmpValue := NewQCborMapFromPointer(C.QCborMap_QCborMap_FromVariantHash(func() unsafe.Pointer {
		tmpList := NewQCborMapFromPointer(NewQCborMapFromPointer(nil).__fromVariantHash_hash_newList())
		for k, v := range hash {
			tmpList.__fromVariantHash_hash_setList(k, v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QCborMap).DestroyQCborMap)
	return tmpValue
}

func (ptr *QCborMap) FromVariantHash(hash map[string]*QVariant) *QCborMap {
	tmpValue := NewQCborMapFromPointer(C.QCborMap_QCborMap_FromVariantHash(func() unsafe.Pointer {
		tmpList := NewQCborMapFromPointer(NewQCborMapFromPointer(nil).__fromVariantHash_hash_newList())
		for k, v := range hash {
			tmpList.__fromVariantHash_hash_setList(k, v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QCborMap).DestroyQCborMap)
	return tmpValue
}

func (ptr *QCborMap) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCborMap_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QCborMap) Keys() []*QCborValue {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QCborValue {
			out := make([]*QCborValue, int(l.len))
			tmpList := NewQCborMapFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__keys_atList(i)
			}
			return out
		}(C.QCborMap_Keys(ptr.Pointer()))
	}
	return make([]*QCborValue, 0)
}

func (ptr *QCborMap) Remove(key int64) {
	if ptr.Pointer() != nil {
		C.QCborMap_Remove(ptr.Pointer(), C.longlong(key))
	}
}

func (ptr *QCborMap) Remove2(key QLatin1String_ITF) {
	if ptr.Pointer() != nil {
		C.QCborMap_Remove2(ptr.Pointer(), PointerFromQLatin1String(key))
	}
}

func (ptr *QCborMap) Remove3(key string) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QCborMap_Remove3(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})
	}
}

func (ptr *QCborMap) Remove4(key QCborValue_ITF) {
	if ptr.Pointer() != nil {
		C.QCborMap_Remove4(ptr.Pointer(), PointerFromQCborValue(key))
	}
}

func (ptr *QCborMap) Swap(other QCborMap_ITF) {
	if ptr.Pointer() != nil {
		C.QCborMap_Swap(ptr.Pointer(), PointerFromQCborMap(other))
	}
}

func (ptr *QCborMap) Take(key int64) *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborMap_Take(ptr.Pointer(), C.longlong(key)))
	}
	return nil
}

func (ptr *QCborMap) Take2(key QLatin1String_ITF) *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborMap_Take2(ptr.Pointer(), PointerFromQLatin1String(key)))
	}
	return nil
}

func (ptr *QCborMap) Take3(key string) *QCborValue {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		return NewQCborValueFromPointer(C.QCborMap_Take3(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}))
	}
	return nil
}

func (ptr *QCborMap) Take4(key QCborValue_ITF) *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborMap_Take4(ptr.Pointer(), PointerFromQCborValue(key)))
	}
	return nil
}

func (ptr *QCborMap) ToCborValue() *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborMap_ToCborValue(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCborMap) ToJsonObject() *QJsonObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonObjectFromPointer(C.QCborMap_ToJsonObject(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
		return tmpValue
	}
	return nil
}

func (ptr *QCborMap) ToVariantHash() map[string]*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[string]*QVariant {
			out := make(map[string]*QVariant, int(l.len))
			tmpList := NewQCborMapFromPointer(l.data)
			for i, v := range tmpList.__toVariantHash_keyList() {
				out[v] = tmpList.__toVariantHash_atList(v, i)
			}
			return out
		}(C.QCborMap_ToVariantHash(ptr.Pointer()))
	}
	return make(map[string]*QVariant, 0)
}

func (ptr *QCborMap) ToVariantMap() map[string]*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[string]*QVariant {
			out := make(map[string]*QVariant, int(l.len))
			tmpList := NewQCborMapFromPointer(l.data)
			for i, v := range tmpList.__toVariantMap_keyList() {
				out[v] = tmpList.__toVariantMap_atList(v, i)
			}
			return out
		}(C.QCborMap_ToVariantMap(ptr.Pointer()))
	}
	return make(map[string]*QVariant, 0)
}

func (ptr *QCborMap) Value(key int64) *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborMap_Value(ptr.Pointer(), C.longlong(key)))
	}
	return nil
}

func (ptr *QCborMap) Value2(key QLatin1String_ITF) *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborMap_Value2(ptr.Pointer(), PointerFromQLatin1String(key)))
	}
	return nil
}

func (ptr *QCborMap) Value3(key string) *QCborValue {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		return NewQCborValueFromPointer(C.QCborMap_Value3(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}))
	}
	return nil
}

func (ptr *QCborMap) Value4(key QCborValue_ITF) *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborMap_Value4(ptr.Pointer(), PointerFromQCborValue(key)))
	}
	return nil
}

func (ptr *QCborMap) DestroyQCborMap() {
	if ptr.Pointer() != nil {
		C.QCborMap_DestroyQCborMap(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCborMap) __fromVariantHash_hash_atList(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QCborMap___fromVariantHash_hash_atList(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QCborMap) __fromVariantHash_hash_setList(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QCborMap___fromVariantHash_hash_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QCborMap) __fromVariantHash_hash_newList() unsafe.Pointer {
	return C.QCborMap___fromVariantHash_hash_newList(ptr.Pointer())
}

func (ptr *QCborMap) __fromVariantHash_hash_keyList() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQCborMapFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____fromVariantHash_hash_keyList_atList(i)
			}
			return out
		}(C.QCborMap___fromVariantHash_hash_keyList(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QCborMap) __keys_atList(i int) *QCborValue {
	if ptr.Pointer() != nil {
		return NewQCborValueFromPointer(C.QCborMap___keys_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QCborMap) __keys_setList(i QCborValue_ITF) {
	if ptr.Pointer() != nil {
		C.QCborMap___keys_setList(ptr.Pointer(), PointerFromQCborValue(i))
	}
}

func (ptr *QCborMap) __keys_newList() unsafe.Pointer {
	return C.QCborMap___keys_newList(ptr.Pointer())
}

func (ptr *QCborMap) __toVariantHash_atList(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QCborMap___toVariantHash_atList(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QCborMap) __toVariantHash_setList(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QCborMap___toVariantHash_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QCborMap) __toVariantHash_newList() unsafe.Pointer {
	return C.QCborMap___toVariantHash_newList(ptr.Pointer())
}

func (ptr *QCborMap) __toVariantHash_keyList() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQCborMapFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____toVariantHash_keyList_atList(i)
			}
			return out
		}(C.QCborMap___toVariantHash_keyList(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QCborMap) __toVariantMap_atList(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QCborMap___toVariantMap_atList(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QCborMap) __toVariantMap_setList(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QCborMap___toVariantMap_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QCborMap) __toVariantMap_newList() unsafe.Pointer {
	return C.QCborMap___toVariantMap_newList(ptr.Pointer())
}

func (ptr *QCborMap) __toVariantMap_keyList() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQCborMapFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____toVariantMap_keyList_atList(i)
			}
			return out
		}(C.QCborMap___toVariantMap_keyList(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QCborMap) ____fromVariantHash_hash_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCborMap_____fromVariantHash_hash_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QCborMap) ____fromVariantHash_hash_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QCborMap_____fromVariantHash_hash_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QCborMap) ____fromVariantHash_hash_keyList_newList() unsafe.Pointer {
	return C.QCborMap_____fromVariantHash_hash_keyList_newList(ptr.Pointer())
}

func (ptr *QCborMap) ____fromVariantMap_map_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCborMap_____fromVariantMap_map_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QCborMap) ____fromVariantMap_map_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QCborMap_____fromVariantMap_map_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QCborMap) ____fromVariantMap_map_keyList_newList() unsafe.Pointer {
	return C.QCborMap_____fromVariantMap_map_keyList_newList(ptr.Pointer())
}

func (ptr *QCborMap) ____toVariantHash_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCborMap_____toVariantHash_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QCborMap) ____toVariantHash_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QCborMap_____toVariantHash_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QCborMap) ____toVariantHash_keyList_newList() unsafe.Pointer {
	return C.QCborMap_____toVariantHash_keyList_newList(ptr.Pointer())
}

func (ptr *QCborMap) ____toVariantMap_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCborMap_____toVariantMap_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QCborMap) ____toVariantMap_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QCborMap_____toVariantMap_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QCborMap) ____toVariantMap_keyList_newList() unsafe.Pointer {
	return C.QCborMap_____toVariantMap_keyList_newList(ptr.Pointer())
}

type QCborParserError struct {
	ptr unsafe.Pointer
}

type QCborParserError_ITF interface {
	QCborParserError_PTR() *QCborParserError
}

func (ptr *QCborParserError) QCborParserError_PTR() *QCborParserError {
	return ptr
}

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

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

func PointerFromQCborParserError(ptr QCborParserError_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCborParserError_PTR().Pointer()
	}
	return nil
}

func NewQCborParserErrorFromPointer(ptr unsafe.Pointer) (n *QCborParserError) {
	n = new(QCborParserError)
	n.SetPointer(ptr)
	return
}

func (ptr *QCborParserError) DestroyQCborParserError() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

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

func (ptr *QCborParserError) Offset() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QCborParserError_Offset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCborParserError) SetOffset(vqi int64) {
	if ptr.Pointer() != nil {
		C.QCborParserError_SetOffset(ptr.Pointer(), C.longlong(vqi))
	}
}

func (ptr *QCborParserError) SetError(vqc QCborError_ITF) {
	if ptr.Pointer() != nil {
		C.QCborParserError_SetError(ptr.Pointer(), PointerFromQCborError(vqc))
	}
}

type QCborStreamReader struct {
	ptr unsafe.Pointer
}

type QCborStreamReader_ITF interface {
	QCborStreamReader_PTR() *QCborStreamReader
}

func (ptr *QCborStreamReader) QCborStreamReader_PTR() *QCborStreamReader {
	return ptr
}

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

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

func PointerFromQCborStreamReader(ptr QCborStreamReader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCborStreamReader_PTR().Pointer()
	}
	return nil
}

func NewQCborStreamReaderFromPointer(ptr unsafe.Pointer) (n *QCborStreamReader) {
	n = new(QCborStreamReader)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QCborStreamReader__Type
//QCborStreamReader::Type
type QCborStreamReader__Type int64

const (
	QCborStreamReader__UnsignedInteger QCborStreamReader__Type = QCborStreamReader__Type(0x00)
	QCborStreamReader__NegativeInteger QCborStreamReader__Type = QCborStreamReader__Type(0x20)
	QCborStreamReader__ByteString      QCborStreamReader__Type = QCborStreamReader__Type(0x40)
	QCborStreamReader__ByteArray       QCborStreamReader__Type = QCborStreamReader__Type(QCborStreamReader__ByteString)
	QCborStreamReader__TextString      QCborStreamReader__Type = QCborStreamReader__Type(0x60)
	QCborStreamReader__String          QCborStreamReader__Type = QCborStreamReader__Type(QCborStreamReader__TextString)
	QCborStreamReader__Array           QCborStreamReader__Type = QCborStreamReader__Type(0x80)
	QCborStreamReader__Map             QCborStreamReader__Type = QCborStreamReader__Type(0xa0)
	QCborStreamReader__Tag             QCborStreamReader__Type = QCborStreamReader__Type(0xc0)
	QCborStreamReader__SimpleType      QCborStreamReader__Type = QCborStreamReader__Type(0xe0)
	QCborStreamReader__HalfFloat       QCborStreamReader__Type = QCborStreamReader__Type(0xf9)
	QCborStreamReader__Float16         QCborStreamReader__Type = QCborStreamReader__Type(QCborStreamReader__HalfFloat)
	QCborStreamReader__Float           QCborStreamReader__Type = QCborStreamReader__Type(0xfa)
	QCborStreamReader__Double          QCborStreamReader__Type = QCborStreamReader__Type(0xfb)
	QCborStreamReader__Invalid         QCborStreamReader__Type = QCborStreamReader__Type(0xff)
)

//go:generate stringer -type=QCborStreamReader__StringResultCode
//QCborStreamReader::StringResultCode
type QCborStreamReader__StringResultCode int64

const (
	QCborStreamReader__EndOfString QCborStreamReader__StringResultCode = QCborStreamReader__StringResultCode(0)
	QCborStreamReader__Ok          QCborStreamReader__StringResultCode = QCborStreamReader__StringResultCode(1)
	QCborStreamReader__Error       QCborStreamReader__StringResultCode = QCborStreamReader__StringResultCode(-1)
)

type QCborStreamWriter struct {
	ptr unsafe.Pointer
}

type QCborStreamWriter_ITF interface {
	QCborStreamWriter_PTR() *QCborStreamWriter
}

func (ptr *QCborStreamWriter) QCborStreamWriter_PTR() *QCborStreamWriter {
	return ptr
}

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

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

func PointerFromQCborStreamWriter(ptr QCborStreamWriter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCborStreamWriter_PTR().Pointer()
	}
	return nil
}

func NewQCborStreamWriterFromPointer(ptr unsafe.Pointer) (n *QCborStreamWriter) {
	n = new(QCborStreamWriter)
	n.SetPointer(ptr)
	return
}

type QCborValue struct {
	ptr unsafe.Pointer
}

type QCborValue_ITF interface {
	QCborValue_PTR() *QCborValue
}

func (ptr *QCborValue) QCborValue_PTR() *QCborValue {
	return ptr
}

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

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

func PointerFromQCborValue(ptr QCborValue_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCborValue_PTR().Pointer()
	}
	return nil
}

func NewQCborValueFromPointer(ptr unsafe.Pointer) (n *QCborValue) {
	n = new(QCborValue)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QCborValue__EncodingOption
//QCborValue::EncodingOption
type QCborValue__EncodingOption int64

const (
	QCborValue__SortKeysInMaps   QCborValue__EncodingOption = QCborValue__EncodingOption(0x01)
	QCborValue__UseFloat         QCborValue__EncodingOption = QCborValue__EncodingOption(0x02)
	QCborValue__UseFloat16       QCborValue__EncodingOption = QCborValue__EncodingOption(QCborValue__UseFloat | 0x04)
	QCborValue__UseIntegers      QCborValue__EncodingOption = QCborValue__EncodingOption(0x08)
	QCborValue__NoTransformation QCborValue__EncodingOption = QCborValue__EncodingOption(0)
)

//go:generate stringer -type=QCborValue__DiagnosticNotationOption
//QCborValue::DiagnosticNotationOption
type QCborValue__DiagnosticNotationOption int64

const (
	QCborValue__Compact        QCborValue__DiagnosticNotationOption = QCborValue__DiagnosticNotationOption(0x00)
	QCborValue__LineWrapped    QCborValue__DiagnosticNotationOption = QCborValue__DiagnosticNotationOption(0x01)
	QCborValue__ExtendedFormat QCborValue__DiagnosticNotationOption = QCborValue__DiagnosticNotationOption(0x02)
)

//go:generate stringer -type=QCborValue__Type
//QCborValue::Type
type QCborValue__Type int64

var (
	QCborValue__Integer           QCborValue__Type = QCborValue__Type(0x00)
	QCborValue__ByteArray         QCborValue__Type = QCborValue__Type(0x40)
	QCborValue__String            QCborValue__Type = QCborValue__Type(0x60)
	QCborValue__Array             QCborValue__Type = QCborValue__Type(0x80)
	QCborValue__Map               QCborValue__Type = QCborValue__Type(0xa0)
	QCborValue__Tag               QCborValue__Type = QCborValue__Type(0xc0)
	QCborValue__SimpleType        QCborValue__Type = QCborValue__Type(0x100)
	QCborValue__False             QCborValue__Type = QCborValue__Type(C.QCborValue_False_Type())
	QCborValue__True              QCborValue__Type = QCborValue__Type(C.QCborValue_True_Type())
	QCborValue__Null              QCborValue__Type = QCborValue__Type(C.QCborValue_Null_Type())
	QCborValue__Undefined         QCborValue__Type = QCborValue__Type(C.QCborValue_Undefined_Type())
	QCborValue__Double            QCborValue__Type = QCborValue__Type(0x202)
	QCborValue__DateTime          QCborValue__Type = QCborValue__Type(0x10000)
	QCborValue__Url               QCborValue__Type = QCborValue__Type(0x10020)
	QCborValue__RegularExpression QCborValue__Type = QCborValue__Type(0x10023)
	QCborValue__Uuid              QCborValue__Type = QCborValue__Type(0x10025)
	QCborValue__Invalid           QCborValue__Type = QCborValue__Type(-1)
)

type QCborValueRef struct {
	ptr unsafe.Pointer
}

type QCborValueRef_ITF interface {
	QCborValueRef_PTR() *QCborValueRef
}

func (ptr *QCborValueRef) QCborValueRef_PTR() *QCborValueRef {
	return ptr
}

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

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

func PointerFromQCborValueRef(ptr QCborValueRef_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCborValueRef_PTR().Pointer()
	}
	return nil
}

func NewQCborValueRefFromPointer(ptr unsafe.Pointer) (n *QCborValueRef) {
	n = new(QCborValueRef)
	n.SetPointer(ptr)
	return
}

func (ptr *QCborValueRef) DestroyQCborValueRef() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QChar struct {
	ptr unsafe.Pointer
}

type QChar_ITF interface {
	QChar_PTR() *QChar
}

func (ptr *QChar) QChar_PTR() *QChar {
	return ptr
}

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

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

func PointerFromQChar(ptr QChar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QChar_PTR().Pointer()
	}
	return nil
}

func NewQCharFromPointer(ptr unsafe.Pointer) (n *QChar) {
	n = new(QChar)
	n.SetPointer(ptr)
	return
}

func (ptr *QChar) DestroyQChar() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QChar__SpecialCharacter
//QChar::SpecialCharacter
type QChar__SpecialCharacter int64

const (
	QChar__Null                       QChar__SpecialCharacter = QChar__SpecialCharacter(0x0000)
	QChar__Tabulation                 QChar__SpecialCharacter = QChar__SpecialCharacter(0x0009)
	QChar__LineFeed                   QChar__SpecialCharacter = QChar__SpecialCharacter(0x000a)
	QChar__CarriageReturn             QChar__SpecialCharacter = QChar__SpecialCharacter(0x000d)
	QChar__Space                      QChar__SpecialCharacter = QChar__SpecialCharacter(0x0020)
	QChar__Nbsp                       QChar__SpecialCharacter = QChar__SpecialCharacter(0x00a0)
	QChar__SoftHyphen                 QChar__SpecialCharacter = QChar__SpecialCharacter(0x00ad)
	QChar__ReplacementCharacter       QChar__SpecialCharacter = QChar__SpecialCharacter(0xfffd)
	QChar__ObjectReplacementCharacter QChar__SpecialCharacter = QChar__SpecialCharacter(0xfffc)
	QChar__ByteOrderMark              QChar__SpecialCharacter = QChar__SpecialCharacter(0xfeff)
	QChar__ByteOrderSwapped           QChar__SpecialCharacter = QChar__SpecialCharacter(0xfffe)
	QChar__ParagraphSeparator         QChar__SpecialCharacter = QChar__SpecialCharacter(0x2029)
	QChar__LineSeparator              QChar__SpecialCharacter = QChar__SpecialCharacter(0x2028)
	QChar__LastValidCodePoint         QChar__SpecialCharacter = QChar__SpecialCharacter(0x10ffff)
)

//go:generate stringer -type=QChar__Category
//QChar::Category
type QChar__Category int64

const (
	QChar__Mark_NonSpacing          QChar__Category = QChar__Category(0)
	QChar__Mark_SpacingCombining    QChar__Category = QChar__Category(1)
	QChar__Mark_Enclosing           QChar__Category = QChar__Category(2)
	QChar__Number_DecimalDigit      QChar__Category = QChar__Category(3)
	QChar__Number_Letter            QChar__Category = QChar__Category(4)
	QChar__Number_Other             QChar__Category = QChar__Category(5)
	QChar__Separator_Space          QChar__Category = QChar__Category(6)
	QChar__Separator_Line           QChar__Category = QChar__Category(7)
	QChar__Separator_Paragraph      QChar__Category = QChar__Category(8)
	QChar__Other_Control            QChar__Category = QChar__Category(9)
	QChar__Other_Format             QChar__Category = QChar__Category(10)
	QChar__Other_Surrogate          QChar__Category = QChar__Category(11)
	QChar__Other_PrivateUse         QChar__Category = QChar__Category(12)
	QChar__Other_NotAssigned        QChar__Category = QChar__Category(13)
	QChar__Letter_Uppercase         QChar__Category = QChar__Category(14)
	QChar__Letter_Lowercase         QChar__Category = QChar__Category(15)
	QChar__Letter_Titlecase         QChar__Category = QChar__Category(16)
	QChar__Letter_Modifier          QChar__Category = QChar__Category(17)
	QChar__Letter_Other             QChar__Category = QChar__Category(18)
	QChar__Punctuation_Connector    QChar__Category = QChar__Category(19)
	QChar__Punctuation_Dash         QChar__Category = QChar__Category(20)
	QChar__Punctuation_Open         QChar__Category = QChar__Category(21)
	QChar__Punctuation_Close        QChar__Category = QChar__Category(22)
	QChar__Punctuation_InitialQuote QChar__Category = QChar__Category(23)
	QChar__Punctuation_FinalQuote   QChar__Category = QChar__Category(24)
	QChar__Punctuation_Other        QChar__Category = QChar__Category(25)
	QChar__Symbol_Math              QChar__Category = QChar__Category(26)
	QChar__Symbol_Currency          QChar__Category = QChar__Category(27)
	QChar__Symbol_Modifier          QChar__Category = QChar__Category(28)
	QChar__Symbol_Other             QChar__Category = QChar__Category(29)
)

//go:generate stringer -type=QChar__Script
//QChar::Script
type QChar__Script int64

const (
	QChar__Script_Unknown               QChar__Script = QChar__Script(0)
	QChar__Script_Inherited             QChar__Script = QChar__Script(1)
	QChar__Script_Common                QChar__Script = QChar__Script(2)
	QChar__Script_Latin                 QChar__Script = QChar__Script(3)
	QChar__Script_Greek                 QChar__Script = QChar__Script(4)
	QChar__Script_Cyrillic              QChar__Script = QChar__Script(5)
	QChar__Script_Armenian              QChar__Script = QChar__Script(6)
	QChar__Script_Hebrew                QChar__Script = QChar__Script(7)
	QChar__Script_Arabic                QChar__Script = QChar__Script(8)
	QChar__Script_Syriac                QChar__Script = QChar__Script(9)
	QChar__Script_Thaana                QChar__Script = QChar__Script(10)
	QChar__Script_Devanagari            QChar__Script = QChar__Script(11)
	QChar__Script_Bengali               QChar__Script = QChar__Script(12)
	QChar__Script_Gurmukhi              QChar__Script = QChar__Script(13)
	QChar__Script_Gujarati              QChar__Script = QChar__Script(14)
	QChar__Script_Oriya                 QChar__Script = QChar__Script(15)
	QChar__Script_Tamil                 QChar__Script = QChar__Script(16)
	QChar__Script_Telugu                QChar__Script = QChar__Script(17)
	QChar__Script_Kannada               QChar__Script = QChar__Script(18)
	QChar__Script_Malayalam             QChar__Script = QChar__Script(19)
	QChar__Script_Sinhala               QChar__Script = QChar__Script(20)
	QChar__Script_Thai                  QChar__Script = QChar__Script(21)
	QChar__Script_Lao                   QChar__Script = QChar__Script(22)
	QChar__Script_Tibetan               QChar__Script = QChar__Script(23)
	QChar__Script_Myanmar               QChar__Script = QChar__Script(24)
	QChar__Script_Georgian              QChar__Script = QChar__Script(25)
	QChar__Script_Hangul                QChar__Script = QChar__Script(26)
	QChar__Script_Ethiopic              QChar__Script = QChar__Script(27)
	QChar__Script_Cherokee              QChar__Script = QChar__Script(28)
	QChar__Script_CanadianAboriginal    QChar__Script = QChar__Script(29)
	QChar__Script_Ogham                 QChar__Script = QChar__Script(30)
	QChar__Script_Runic                 QChar__Script = QChar__Script(31)
	QChar__Script_Khmer                 QChar__Script = QChar__Script(32)
	QChar__Script_Mongolian             QChar__Script = QChar__Script(33)
	QChar__Script_Hiragana              QChar__Script = QChar__Script(34)
	QChar__Script_Katakana              QChar__Script = QChar__Script(35)
	QChar__Script_Bopomofo              QChar__Script = QChar__Script(36)
	QChar__Script_Han                   QChar__Script = QChar__Script(37)
	QChar__Script_Yi                    QChar__Script = QChar__Script(38)
	QChar__Script_OldItalic             QChar__Script = QChar__Script(39)
	QChar__Script_Gothic                QChar__Script = QChar__Script(40)
	QChar__Script_Deseret               QChar__Script = QChar__Script(41)
	QChar__Script_Tagalog               QChar__Script = QChar__Script(42)
	QChar__Script_Hanunoo               QChar__Script = QChar__Script(43)
	QChar__Script_Buhid                 QChar__Script = QChar__Script(44)
	QChar__Script_Tagbanwa              QChar__Script = QChar__Script(45)
	QChar__Script_Coptic                QChar__Script = QChar__Script(46)
	QChar__Script_Limbu                 QChar__Script = QChar__Script(47)
	QChar__Script_TaiLe                 QChar__Script = QChar__Script(48)
	QChar__Script_LinearB               QChar__Script = QChar__Script(49)
	QChar__Script_Ugaritic              QChar__Script = QChar__Script(50)
	QChar__Script_Shavian               QChar__Script = QChar__Script(51)
	QChar__Script_Osmanya               QChar__Script = QChar__Script(52)
	QChar__Script_Cypriot               QChar__Script = QChar__Script(53)
	QChar__Script_Braille               QChar__Script = QChar__Script(54)
	QChar__Script_Buginese              QChar__Script = QChar__Script(55)
	QChar__Script_NewTaiLue             QChar__Script = QChar__Script(56)
	QChar__Script_Glagolitic            QChar__Script = QChar__Script(57)
	QChar__Script_Tifinagh              QChar__Script = QChar__Script(58)
	QChar__Script_SylotiNagri           QChar__Script = QChar__Script(59)
	QChar__Script_OldPersian            QChar__Script = QChar__Script(60)
	QChar__Script_Kharoshthi            QChar__Script = QChar__Script(61)
	QChar__Script_Balinese              QChar__Script = QChar__Script(62)
	QChar__Script_Cuneiform             QChar__Script = QChar__Script(63)
	QChar__Script_Phoenician            QChar__Script = QChar__Script(64)
	QChar__Script_PhagsPa               QChar__Script = QChar__Script(65)
	QChar__Script_Nko                   QChar__Script = QChar__Script(66)
	QChar__Script_Sundanese             QChar__Script = QChar__Script(67)
	QChar__Script_Lepcha                QChar__Script = QChar__Script(68)
	QChar__Script_OlChiki               QChar__Script = QChar__Script(69)
	QChar__Script_Vai                   QChar__Script = QChar__Script(70)
	QChar__Script_Saurashtra            QChar__Script = QChar__Script(71)
	QChar__Script_KayahLi               QChar__Script = QChar__Script(72)
	QChar__Script_Rejang                QChar__Script = QChar__Script(73)
	QChar__Script_Lycian                QChar__Script = QChar__Script(74)
	QChar__Script_Carian                QChar__Script = QChar__Script(75)
	QChar__Script_Lydian                QChar__Script = QChar__Script(76)
	QChar__Script_Cham                  QChar__Script = QChar__Script(77)
	QChar__Script_TaiTham               QChar__Script = QChar__Script(78)
	QChar__Script_TaiViet               QChar__Script = QChar__Script(79)
	QChar__Script_Avestan               QChar__Script = QChar__Script(80)
	QChar__Script_EgyptianHieroglyphs   QChar__Script = QChar__Script(81)
	QChar__Script_Samaritan             QChar__Script = QChar__Script(82)
	QChar__Script_Lisu                  QChar__Script = QChar__Script(83)
	QChar__Script_Bamum                 QChar__Script = QChar__Script(84)
	QChar__Script_Javanese              QChar__Script = QChar__Script(85)
	QChar__Script_MeeteiMayek           QChar__Script = QChar__Script(86)
	QChar__Script_ImperialAramaic       QChar__Script = QChar__Script(87)
	QChar__Script_OldSouthArabian       QChar__Script = QChar__Script(88)
	QChar__Script_InscriptionalParthian QChar__Script = QChar__Script(89)
	QChar__Script_InscriptionalPahlavi  QChar__Script = QChar__Script(90)
	QChar__Script_OldTurkic             QChar__Script = QChar__Script(91)
	QChar__Script_Kaithi                QChar__Script = QChar__Script(92)
	QChar__Script_Batak                 QChar__Script = QChar__Script(93)
	QChar__Script_Brahmi                QChar__Script = QChar__Script(94)
	QChar__Script_Mandaic               QChar__Script = QChar__Script(95)
	QChar__Script_Chakma                QChar__Script = QChar__Script(96)
	QChar__Script_MeroiticCursive       QChar__Script = QChar__Script(97)
	QChar__Script_MeroiticHieroglyphs   QChar__Script = QChar__Script(98)
	QChar__Script_Miao                  QChar__Script = QChar__Script(99)
	QChar__Script_Sharada               QChar__Script = QChar__Script(100)
	QChar__Script_SoraSompeng           QChar__Script = QChar__Script(101)
	QChar__Script_Takri                 QChar__Script = QChar__Script(102)
	QChar__Script_CaucasianAlbanian     QChar__Script = QChar__Script(103)
	QChar__Script_BassaVah              QChar__Script = QChar__Script(104)
	QChar__Script_Duployan              QChar__Script = QChar__Script(105)
	QChar__Script_Elbasan               QChar__Script = QChar__Script(106)
	QChar__Script_Grantha               QChar__Script = QChar__Script(107)
	QChar__Script_PahawhHmong           QChar__Script = QChar__Script(108)
	QChar__Script_Khojki                QChar__Script = QChar__Script(109)
	QChar__Script_LinearA               QChar__Script = QChar__Script(110)
	QChar__Script_Mahajani              QChar__Script = QChar__Script(111)
	QChar__Script_Manichaean            QChar__Script = QChar__Script(112)
	QChar__Script_MendeKikakui          QChar__Script = QChar__Script(113)
	QChar__Script_Modi                  QChar__Script = QChar__Script(114)
	QChar__Script_Mro                   QChar__Script = QChar__Script(115)
	QChar__Script_OldNorthArabian       QChar__Script = QChar__Script(116)
	QChar__Script_Nabataean             QChar__Script = QChar__Script(117)
	QChar__Script_Palmyrene             QChar__Script = QChar__Script(118)
	QChar__Script_PauCinHau             QChar__Script = QChar__Script(119)
	QChar__Script_OldPermic             QChar__Script = QChar__Script(120)
	QChar__Script_PsalterPahlavi        QChar__Script = QChar__Script(121)
	QChar__Script_Siddham               QChar__Script = QChar__Script(122)
	QChar__Script_Khudawadi             QChar__Script = QChar__Script(123)
	QChar__Script_Tirhuta               QChar__Script = QChar__Script(124)
	QChar__Script_WarangCiti            QChar__Script = QChar__Script(125)
	QChar__Script_Ahom                  QChar__Script = QChar__Script(126)
	QChar__Script_AnatolianHieroglyphs  QChar__Script = QChar__Script(127)
	QChar__Script_Hatran                QChar__Script = QChar__Script(128)
	QChar__Script_Multani               QChar__Script = QChar__Script(129)
	QChar__Script_OldHungarian          QChar__Script = QChar__Script(130)
	QChar__Script_SignWriting           QChar__Script = QChar__Script(131)
	QChar__Script_Adlam                 QChar__Script = QChar__Script(132)
	QChar__Script_Bhaiksuki             QChar__Script = QChar__Script(133)
	QChar__Script_Marchen               QChar__Script = QChar__Script(134)
	QChar__Script_Newa                  QChar__Script = QChar__Script(135)
	QChar__Script_Osage                 QChar__Script = QChar__Script(136)
	QChar__Script_Tangut                QChar__Script = QChar__Script(137)
	QChar__Script_MasaramGondi          QChar__Script = QChar__Script(138)
	QChar__Script_Nushu                 QChar__Script = QChar__Script(139)
	QChar__Script_Soyombo               QChar__Script = QChar__Script(140)
	QChar__Script_ZanabazarSquare       QChar__Script = QChar__Script(141)
	QChar__ScriptCount                  QChar__Script = QChar__Script(142)
)

//go:generate stringer -type=QChar__Direction
//QChar::Direction
type QChar__Direction int64

const (
	QChar__DirL   QChar__Direction = QChar__Direction(0)
	QChar__DirR   QChar__Direction = QChar__Direction(1)
	QChar__DirEN  QChar__Direction = QChar__Direction(2)
	QChar__DirES  QChar__Direction = QChar__Direction(3)
	QChar__DirET  QChar__Direction = QChar__Direction(4)
	QChar__DirAN  QChar__Direction = QChar__Direction(5)
	QChar__DirCS  QChar__Direction = QChar__Direction(6)
	QChar__DirB   QChar__Direction = QChar__Direction(7)
	QChar__DirS   QChar__Direction = QChar__Direction(8)
	QChar__DirWS  QChar__Direction = QChar__Direction(9)
	QChar__DirON  QChar__Direction = QChar__Direction(10)
	QChar__DirLRE QChar__Direction = QChar__Direction(11)
	QChar__DirLRO QChar__Direction = QChar__Direction(12)
	QChar__DirAL  QChar__Direction = QChar__Direction(13)
	QChar__DirRLE QChar__Direction = QChar__Direction(14)
	QChar__DirRLO QChar__Direction = QChar__Direction(15)
	QChar__DirPDF QChar__Direction = QChar__Direction(16)
	QChar__DirNSM QChar__Direction = QChar__Direction(17)
	QChar__DirBN  QChar__Direction = QChar__Direction(18)
	QChar__DirLRI QChar__Direction = QChar__Direction(19)
	QChar__DirRLI QChar__Direction = QChar__Direction(20)
	QChar__DirFSI QChar__Direction = QChar__Direction(21)
	QChar__DirPDI QChar__Direction = QChar__Direction(22)
)

//go:generate stringer -type=QChar__Decomposition
//QChar::Decomposition
type QChar__Decomposition int64

const (
	QChar__NoDecomposition QChar__Decomposition = QChar__Decomposition(0)
	QChar__Canonical       QChar__Decomposition = QChar__Decomposition(1)
	QChar__Font            QChar__Decomposition = QChar__Decomposition(2)
	QChar__NoBreak         QChar__Decomposition = QChar__Decomposition(3)
	QChar__Initial         QChar__Decomposition = QChar__Decomposition(4)
	QChar__Medial          QChar__Decomposition = QChar__Decomposition(5)
	QChar__Final           QChar__Decomposition = QChar__Decomposition(6)
	QChar__Isolated        QChar__Decomposition = QChar__Decomposition(7)
	QChar__Circle          QChar__Decomposition = QChar__Decomposition(8)
	QChar__Super           QChar__Decomposition = QChar__Decomposition(9)
	QChar__Sub             QChar__Decomposition = QChar__Decomposition(10)
	QChar__Vertical        QChar__Decomposition = QChar__Decomposition(11)
	QChar__Wide            QChar__Decomposition = QChar__Decomposition(12)
	QChar__Narrow          QChar__Decomposition = QChar__Decomposition(13)
	QChar__Small           QChar__Decomposition = QChar__Decomposition(14)
	QChar__Square          QChar__Decomposition = QChar__Decomposition(15)
	QChar__Compat          QChar__Decomposition = QChar__Decomposition(16)
	QChar__Fraction        QChar__Decomposition = QChar__Decomposition(17)
)

//go:generate stringer -type=QChar__JoiningType
//QChar::JoiningType
type QChar__JoiningType int64

const (
	QChar__Joining_None        QChar__JoiningType = QChar__JoiningType(0)
	QChar__Joining_Causing     QChar__JoiningType = QChar__JoiningType(1)
	QChar__Joining_Dual        QChar__JoiningType = QChar__JoiningType(2)
	QChar__Joining_Right       QChar__JoiningType = QChar__JoiningType(3)
	QChar__Joining_Left        QChar__JoiningType = QChar__JoiningType(4)
	QChar__Joining_Transparent QChar__JoiningType = QChar__JoiningType(5)
)

//go:generate stringer -type=QChar__UnicodeVersion
//QChar::UnicodeVersion
type QChar__UnicodeVersion int64

const (
	QChar__Unicode_Unassigned QChar__UnicodeVersion = QChar__UnicodeVersion(0)
	QChar__Unicode_1_1        QChar__UnicodeVersion = QChar__UnicodeVersion(1)
	QChar__Unicode_2_0        QChar__UnicodeVersion = QChar__UnicodeVersion(2)
	QChar__Unicode_2_1_2      QChar__UnicodeVersion = QChar__UnicodeVersion(3)
	QChar__Unicode_3_0        QChar__UnicodeVersion = QChar__UnicodeVersion(4)
	QChar__Unicode_3_1        QChar__UnicodeVersion = QChar__UnicodeVersion(5)
	QChar__Unicode_3_2        QChar__UnicodeVersion = QChar__UnicodeVersion(6)
	QChar__Unicode_4_0        QChar__UnicodeVersion = QChar__UnicodeVersion(7)
	QChar__Unicode_4_1        QChar__UnicodeVersion = QChar__UnicodeVersion(8)
	QChar__Unicode_5_0        QChar__UnicodeVersion = QChar__UnicodeVersion(9)
	QChar__Unicode_5_1        QChar__UnicodeVersion = QChar__UnicodeVersion(10)
	QChar__Unicode_5_2        QChar__UnicodeVersion = QChar__UnicodeVersion(11)
	QChar__Unicode_6_0        QChar__UnicodeVersion = QChar__UnicodeVersion(12)
	QChar__Unicode_6_1        QChar__UnicodeVersion = QChar__UnicodeVersion(13)
	QChar__Unicode_6_2        QChar__UnicodeVersion = QChar__UnicodeVersion(14)
	QChar__Unicode_6_3        QChar__UnicodeVersion = QChar__UnicodeVersion(15)
	QChar__Unicode_7_0        QChar__UnicodeVersion = QChar__UnicodeVersion(16)
	QChar__Unicode_8_0        QChar__UnicodeVersion = QChar__UnicodeVersion(17)
	QChar__Unicode_9_0        QChar__UnicodeVersion = QChar__UnicodeVersion(18)
	QChar__Unicode_10_0       QChar__UnicodeVersion = QChar__UnicodeVersion(19)
)

func NewQChar() *QChar {
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar())
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func NewQChar2(code uint16) *QChar {
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar2(C.ushort(code)))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func NewQChar3(cell string, row string) *QChar {
	var cellC *C.char
	if cell != "" {
		cellC = C.CString(cell)
		defer C.free(unsafe.Pointer(cellC))
	}
	var rowC *C.char
	if row != "" {
		rowC = C.CString(row)
		defer C.free(unsafe.Pointer(rowC))
	}
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar3(cellC, rowC))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func NewQChar4(code int16) *QChar {
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar4(C.short(code)))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func NewQChar5(code uint) *QChar {
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar5(C.uint(uint32(code))))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func NewQChar6(code int) *QChar {
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar6(C.int(int32(code))))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func NewQChar7(ch QChar__SpecialCharacter) *QChar {
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar7(C.longlong(ch)))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func NewQChar8(ch QLatin1Char_ITF) *QChar {
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar8(PointerFromQLatin1Char(ch)))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func NewQChar11(ch string) *QChar {
	var chC *C.char
	if ch != "" {
		chC = C.CString(ch)
		defer C.free(unsafe.Pointer(chC))
	}
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar11(chC))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func NewQChar12(ch string) *QChar {
	var chC *C.char
	if ch != "" {
		chC = C.CString(ch)
		defer C.free(unsafe.Pointer(chC))
	}
	tmpValue := NewQCharFromPointer(C.QChar_NewQChar12(chC))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func (ptr *QChar) Category() QChar__Category {
	if ptr.Pointer() != nil {
		return QChar__Category(C.QChar_Category(ptr.Pointer()))
	}
	return 0
}

func QChar_Category2(ucs4 uint) QChar__Category {
	return QChar__Category(C.QChar_QChar_Category2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) Category2(ucs4 uint) QChar__Category {
	return QChar__Category(C.QChar_QChar_Category2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) Cell() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QChar_Cell(ptr.Pointer()))
	}
	return ""
}

func QChar_CurrentUnicodeVersion() QChar__UnicodeVersion {
	return QChar__UnicodeVersion(C.QChar_QChar_CurrentUnicodeVersion())
}

func (ptr *QChar) CurrentUnicodeVersion() QChar__UnicodeVersion {
	return QChar__UnicodeVersion(C.QChar_QChar_CurrentUnicodeVersion())
}

func (ptr *QChar) Decomposition() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QChar_Decomposition(ptr.Pointer()))
	}
	return ""
}

func QChar_Decomposition2(ucs4 uint) string {
	return cGoUnpackString(C.QChar_QChar_Decomposition2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) Decomposition2(ucs4 uint) string {
	return cGoUnpackString(C.QChar_QChar_Decomposition2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) DecompositionTag() QChar__Decomposition {
	if ptr.Pointer() != nil {
		return QChar__Decomposition(C.QChar_DecompositionTag(ptr.Pointer()))
	}
	return 0
}

func QChar_DecompositionTag2(ucs4 uint) QChar__Decomposition {
	return QChar__Decomposition(C.QChar_QChar_DecompositionTag2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) DecompositionTag2(ucs4 uint) QChar__Decomposition {
	return QChar__Decomposition(C.QChar_QChar_DecompositionTag2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) DigitValue() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QChar_DigitValue(ptr.Pointer())))
	}
	return 0
}

func QChar_DigitValue2(ucs4 uint) int {
	return int(int32(C.QChar_QChar_DigitValue2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) DigitValue2(ucs4 uint) int {
	return int(int32(C.QChar_QChar_DigitValue2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) Direction() QChar__Direction {
	if ptr.Pointer() != nil {
		return QChar__Direction(C.QChar_Direction(ptr.Pointer()))
	}
	return 0
}

func QChar_Direction2(ucs4 uint) QChar__Direction {
	return QChar__Direction(C.QChar_QChar_Direction2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) Direction2(ucs4 uint) QChar__Direction {
	return QChar__Direction(C.QChar_QChar_Direction2(C.uint(uint32(ucs4))))
}

func QChar_FromLatin1(c string) *QChar {
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	tmpValue := NewQCharFromPointer(C.QChar_QChar_FromLatin1(cC))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func (ptr *QChar) FromLatin1(c string) *QChar {
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	tmpValue := NewQCharFromPointer(C.QChar_QChar_FromLatin1(cC))
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func (ptr *QChar) HasMirrored() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_HasMirrored(ptr.Pointer())) != 0
	}
	return false
}

func QChar_HasMirrored2(ucs4 uint) bool {
	return int8(C.QChar_QChar_HasMirrored2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) HasMirrored2(ucs4 uint) bool {
	return int8(C.QChar_QChar_HasMirrored2(C.uint(uint32(ucs4)))) != 0
}

func QChar_HighSurrogate(ucs4 uint) uint16 {
	return uint16(C.QChar_QChar_HighSurrogate(C.uint(uint32(ucs4))))
}

func (ptr *QChar) HighSurrogate(ucs4 uint) uint16 {
	return uint16(C.QChar_QChar_HighSurrogate(C.uint(uint32(ucs4))))
}

func (ptr *QChar) IsDigit() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsDigit(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsDigit2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsDigit2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsDigit2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsDigit2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsHighSurrogate() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsHighSurrogate(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsHighSurrogate2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsHighSurrogate2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsHighSurrogate2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsHighSurrogate2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsLetter() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsLetter(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsLetter2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsLetter2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsLetter2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsLetter2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsLetterOrNumber() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsLetterOrNumber(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsLetterOrNumber2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsLetterOrNumber2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsLetterOrNumber2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsLetterOrNumber2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsLowSurrogate() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsLowSurrogate(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsLowSurrogate2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsLowSurrogate2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsLowSurrogate2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsLowSurrogate2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsLower() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsLower(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsLower2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsLower2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsLower2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsLower2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsMark() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsMark(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsMark2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsMark2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsMark2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsMark2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsNonCharacter() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsNonCharacter(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsNonCharacter2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsNonCharacter2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsNonCharacter2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsNonCharacter2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QChar) IsNumber() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsNumber(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsNumber2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsNumber2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsNumber2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsNumber2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsPrint() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsPrint(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsPrint2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsPrint2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsPrint2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsPrint2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsPunct() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsPunct(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsPunct2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsPunct2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsPunct2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsPunct2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsSpace() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsSpace(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsSpace2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsSpace2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsSpace2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsSpace2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsSurrogate() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsSurrogate(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsSurrogate2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsSurrogate2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsSurrogate2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsSurrogate2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsSymbol() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsSymbol(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsSymbol2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsSymbol2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsSymbol2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsSymbol2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsTitleCase() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsTitleCase(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsTitleCase2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsTitleCase2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsTitleCase2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsTitleCase2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsUpper() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChar_IsUpper(ptr.Pointer())) != 0
	}
	return false
}

func QChar_IsUpper2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsUpper2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) IsUpper2(ucs4 uint) bool {
	return int8(C.QChar_QChar_IsUpper2(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) JoiningType() QChar__JoiningType {
	if ptr.Pointer() != nil {
		return QChar__JoiningType(C.QChar_JoiningType(ptr.Pointer()))
	}
	return 0
}

func QChar_JoiningType2(ucs4 uint) QChar__JoiningType {
	return QChar__JoiningType(C.QChar_QChar_JoiningType2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) JoiningType2(ucs4 uint) QChar__JoiningType {
	return QChar__JoiningType(C.QChar_QChar_JoiningType2(C.uint(uint32(ucs4))))
}

func QChar_LowSurrogate(ucs4 uint) uint16 {
	return uint16(C.QChar_QChar_LowSurrogate(C.uint(uint32(ucs4))))
}

func (ptr *QChar) LowSurrogate(ucs4 uint) uint16 {
	return uint16(C.QChar_QChar_LowSurrogate(C.uint(uint32(ucs4))))
}

func (ptr *QChar) MirroredChar() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QChar_MirroredChar(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func QChar_MirroredChar2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_MirroredChar2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) MirroredChar2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_MirroredChar2(C.uint(uint32(ucs4)))))
}

func QChar_RequiresSurrogates(ucs4 uint) bool {
	return int8(C.QChar_QChar_RequiresSurrogates(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) RequiresSurrogates(ucs4 uint) bool {
	return int8(C.QChar_QChar_RequiresSurrogates(C.uint(uint32(ucs4)))) != 0
}

func (ptr *QChar) Row() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QChar_Row(ptr.Pointer()))
	}
	return ""
}

func (ptr *QChar) Script() QChar__Script {
	if ptr.Pointer() != nil {
		return QChar__Script(C.QChar_Script(ptr.Pointer()))
	}
	return 0
}

func QChar_Script2(ucs4 uint) QChar__Script {
	return QChar__Script(C.QChar_QChar_Script2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) Script2(ucs4 uint) QChar__Script {
	return QChar__Script(C.QChar_QChar_Script2(C.uint(uint32(ucs4))))
}

func QChar_SurrogateToUcs4(high uint16, low uint16) uint {
	return uint(uint32(C.QChar_QChar_SurrogateToUcs4(C.ushort(high), C.ushort(low))))
}

func (ptr *QChar) SurrogateToUcs4(high uint16, low uint16) uint {
	return uint(uint32(C.QChar_QChar_SurrogateToUcs4(C.ushort(high), C.ushort(low))))
}

func QChar_SurrogateToUcs42(high QChar_ITF, low QChar_ITF) uint {
	return uint(uint32(C.QChar_QChar_SurrogateToUcs42(PointerFromQChar(high), PointerFromQChar(low))))
}

func (ptr *QChar) SurrogateToUcs42(high QChar_ITF, low QChar_ITF) uint {
	return uint(uint32(C.QChar_QChar_SurrogateToUcs42(PointerFromQChar(high), PointerFromQChar(low))))
}

func (ptr *QChar) ToCaseFolded() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QChar_ToCaseFolded(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func QChar_ToCaseFolded2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_ToCaseFolded2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) ToCaseFolded2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_ToCaseFolded2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) ToLatin1() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QChar_ToLatin1(ptr.Pointer()))
	}
	return ""
}

func (ptr *QChar) ToLower() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QChar_ToLower(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func QChar_ToLower2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_ToLower2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) ToLower2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_ToLower2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) ToTitleCase() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QChar_ToTitleCase(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func QChar_ToTitleCase2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_ToTitleCase2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) ToTitleCase2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_ToTitleCase2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) ToUpper() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QChar_ToUpper(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func QChar_ToUpper2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_ToUpper2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) ToUpper2(ucs4 uint) uint {
	return uint(uint32(C.QChar_QChar_ToUpper2(C.uint(uint32(ucs4)))))
}

func (ptr *QChar) Unicode() uint16 {
	if ptr.Pointer() != nil {
		return uint16(C.QChar_Unicode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QChar) Unicode2() uint16 {
	if ptr.Pointer() != nil {
		return uint16(C.QChar_Unicode2(ptr.Pointer()))
	}
	return 0
}

func (ptr *QChar) UnicodeVersion() QChar__UnicodeVersion {
	if ptr.Pointer() != nil {
		return QChar__UnicodeVersion(C.QChar_UnicodeVersion(ptr.Pointer()))
	}
	return 0
}

func QChar_UnicodeVersion2(ucs4 uint) QChar__UnicodeVersion {
	return QChar__UnicodeVersion(C.QChar_QChar_UnicodeVersion2(C.uint(uint32(ucs4))))
}

func (ptr *QChar) UnicodeVersion2(ucs4 uint) QChar__UnicodeVersion {
	return QChar__UnicodeVersion(C.QChar_QChar_UnicodeVersion2(C.uint(uint32(ucs4))))
}

type QChildEvent struct {
	QEvent
}

type QChildEvent_ITF interface {
	QEvent_ITF
	QChildEvent_PTR() *QChildEvent
}

func (ptr *QChildEvent) QChildEvent_PTR() *QChildEvent {
	return ptr
}

func (ptr *QChildEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QEvent_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQChildEvent(ptr QChildEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QChildEvent_PTR().Pointer()
	}
	return nil
}

func NewQChildEventFromPointer(ptr unsafe.Pointer) (n *QChildEvent) {
	n = new(QChildEvent)
	n.SetPointer(ptr)
	return
}

func (ptr *QChildEvent) DestroyQChildEvent() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(ptr.Pointer(), "")
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQChildEvent(ty QEvent__Type, child QObject_ITF) *QChildEvent {
	tmpValue := NewQChildEventFromPointer(C.QChildEvent_NewQChildEvent(C.longlong(ty), PointerFromQObject(child)))
	runtime.SetFinalizer(tmpValue, (*QChildEvent).DestroyQChildEvent)
	return tmpValue
}

func (ptr *QChildEvent) Added() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChildEvent_Added(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QChildEvent) Child() *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QChildEvent_Child(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QChildEvent) Polished() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChildEvent_Polished(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QChildEvent) Removed() bool {
	if ptr.Pointer() != nil {
		return int8(C.QChildEvent_Removed(ptr.Pointer())) != 0
	}
	return false
}

type QCollator struct {
	ptr unsafe.Pointer
}

type QCollator_ITF interface {
	QCollator_PTR() *QCollator
}

func (ptr *QCollator) QCollator_PTR() *QCollator {
	return ptr
}

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

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

func PointerFromQCollator(ptr QCollator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCollator_PTR().Pointer()
	}
	return nil
}

func NewQCollatorFromPointer(ptr unsafe.Pointer) (n *QCollator) {
	n = new(QCollator)
	n.SetPointer(ptr)
	return
}
func NewQCollator(locale QLocale_ITF) *QCollator {
	tmpValue := NewQCollatorFromPointer(C.QCollator_NewQCollator(PointerFromQLocale(locale)))
	runtime.SetFinalizer(tmpValue, (*QCollator).DestroyQCollator)
	return tmpValue
}

func NewQCollator2(other QCollator_ITF) *QCollator {
	tmpValue := NewQCollatorFromPointer(C.QCollator_NewQCollator2(PointerFromQCollator(other)))
	runtime.SetFinalizer(tmpValue, (*QCollator).DestroyQCollator)
	return tmpValue
}

func NewQCollator3(other QCollator_ITF) *QCollator {
	tmpValue := NewQCollatorFromPointer(C.QCollator_NewQCollator3(PointerFromQCollator(other)))
	runtime.SetFinalizer(tmpValue, (*QCollator).DestroyQCollator)
	return tmpValue
}

func (ptr *QCollator) CaseSensitivity() Qt__CaseSensitivity {
	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QCollator_CaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCollator) Compare(s1 string, s2 string) int {
	if ptr.Pointer() != nil {
		var s1C *C.char
		if s1 != "" {
			s1C = C.CString(s1)
			defer C.free(unsafe.Pointer(s1C))
		}
		var s2C *C.char
		if s2 != "" {
			s2C = C.CString(s2)
			defer C.free(unsafe.Pointer(s2C))
		}
		return int(int32(C.QCollator_Compare(ptr.Pointer(), C.struct_QtCore_PackedString{data: s1C, len: C.longlong(len(s1))}, C.struct_QtCore_PackedString{data: s2C, len: C.longlong(len(s2))})))
	}
	return 0
}

func (ptr *QCollator) Compare2(s1 QStringRef_ITF, s2 QStringRef_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCollator_Compare2(ptr.Pointer(), PointerFromQStringRef(s1), PointerFromQStringRef(s2))))
	}
	return 0
}

func (ptr *QCollator) Compare3(s1 QChar_ITF, len1 int, s2 QChar_ITF, len2 int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCollator_Compare3(ptr.Pointer(), PointerFromQChar(s1), C.int(int32(len1)), PointerFromQChar(s2), C.int(int32(len2)))))
	}
	return 0
}

func (ptr *QCollator) IgnorePunctuation() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCollator_IgnorePunctuation(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QCollator) Locale() *QLocale {
	if ptr.Pointer() != nil {
		tmpValue := NewQLocaleFromPointer(C.QCollator_Locale(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
		return tmpValue
	}
	return nil
}

func (ptr *QCollator) NumericMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCollator_NumericMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QCollator) SetCaseSensitivity(sensitivity Qt__CaseSensitivity) {
	if ptr.Pointer() != nil {
		C.QCollator_SetCaseSensitivity(ptr.Pointer(), C.longlong(sensitivity))
	}
}

func (ptr *QCollator) SetIgnorePunctuation(on bool) {
	if ptr.Pointer() != nil {
		C.QCollator_SetIgnorePunctuation(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QCollator) SetLocale(locale QLocale_ITF) {
	if ptr.Pointer() != nil {
		C.QCollator_SetLocale(ptr.Pointer(), PointerFromQLocale(locale))
	}
}

func (ptr *QCollator) SetNumericMode(on bool) {
	if ptr.Pointer() != nil {
		C.QCollator_SetNumericMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QCollator) SortKey(stri string) *QCollatorSortKey {
	if ptr.Pointer() != nil {
		var striC *C.char
		if stri != "" {
			striC = C.CString(stri)
			defer C.free(unsafe.Pointer(striC))
		}
		tmpValue := NewQCollatorSortKeyFromPointer(C.QCollator_SortKey(ptr.Pointer(), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}))
		runtime.SetFinalizer(tmpValue, (*QCollatorSortKey).DestroyQCollatorSortKey)
		return tmpValue
	}
	return nil
}

func (ptr *QCollator) Swap(other QCollator_ITF) {
	if ptr.Pointer() != nil {
		C.QCollator_Swap(ptr.Pointer(), PointerFromQCollator(other))
	}
}

func (ptr *QCollator) DestroyQCollator() {
	if ptr.Pointer() != nil {
		C.QCollator_DestroyQCollator(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QCollatorSortKey struct {
	ptr unsafe.Pointer
}

type QCollatorSortKey_ITF interface {
	QCollatorSortKey_PTR() *QCollatorSortKey
}

func (ptr *QCollatorSortKey) QCollatorSortKey_PTR() *QCollatorSortKey {
	return ptr
}

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

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

func PointerFromQCollatorSortKey(ptr QCollatorSortKey_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCollatorSortKey_PTR().Pointer()
	}
	return nil
}

func NewQCollatorSortKeyFromPointer(ptr unsafe.Pointer) (n *QCollatorSortKey) {
	n = new(QCollatorSortKey)
	n.SetPointer(ptr)
	return
}
func NewQCollatorSortKey(other QCollatorSortKey_ITF) *QCollatorSortKey {
	tmpValue := NewQCollatorSortKeyFromPointer(C.QCollatorSortKey_NewQCollatorSortKey(PointerFromQCollatorSortKey(other)))
	runtime.SetFinalizer(tmpValue, (*QCollatorSortKey).DestroyQCollatorSortKey)
	return tmpValue
}

func (ptr *QCollatorSortKey) Compare(otherKey QCollatorSortKey_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCollatorSortKey_Compare(ptr.Pointer(), PointerFromQCollatorSortKey(otherKey))))
	}
	return 0
}

func (ptr *QCollatorSortKey) Swap(other QCollatorSortKey_ITF) {
	if ptr.Pointer() != nil {
		C.QCollatorSortKey_Swap(ptr.Pointer(), PointerFromQCollatorSortKey(other))
	}
}

func (ptr *QCollatorSortKey) DestroyQCollatorSortKey() {
	if ptr.Pointer() != nil {
		C.QCollatorSortKey_DestroyQCollatorSortKey(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QCommandLineOption struct {
	ptr unsafe.Pointer
}

type QCommandLineOption_ITF interface {
	QCommandLineOption_PTR() *QCommandLineOption
}

func (ptr *QCommandLineOption) QCommandLineOption_PTR() *QCommandLineOption {
	return ptr
}

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

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

func PointerFromQCommandLineOption(ptr QCommandLineOption_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCommandLineOption_PTR().Pointer()
	}
	return nil
}

func NewQCommandLineOptionFromPointer(ptr unsafe.Pointer) (n *QCommandLineOption) {
	n = new(QCommandLineOption)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QCommandLineOption__Flag
//QCommandLineOption::Flag
type QCommandLineOption__Flag int64

const (
	QCommandLineOption__HiddenFromHelp   QCommandLineOption__Flag = QCommandLineOption__Flag(0x1)
	QCommandLineOption__ShortOptionStyle QCommandLineOption__Flag = QCommandLineOption__Flag(0x2)
)

func NewQCommandLineOption(name string) *QCommandLineOption {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	tmpValue := NewQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption(C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}))
	runtime.SetFinalizer(tmpValue, (*QCommandLineOption).DestroyQCommandLineOption)
	return tmpValue
}

func NewQCommandLineOption2(names []string) *QCommandLineOption {
	namesC := C.CString(strings.Join(names, "¡¦!"))
	defer C.free(unsafe.Pointer(namesC))
	tmpValue := NewQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption2(C.struct_QtCore_PackedString{data: namesC, len: C.longlong(len(strings.Join(names, "¡¦!")))}))
	runtime.SetFinalizer(tmpValue, (*QCommandLineOption).DestroyQCommandLineOption)
	return tmpValue
}

func NewQCommandLineOption3(name string, description string, valueName string, defaultValue string) *QCommandLineOption {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	var descriptionC *C.char
	if description != "" {
		descriptionC = C.CString(description)
		defer C.free(unsafe.Pointer(descriptionC))
	}
	var valueNameC *C.char
	if valueName != "" {
		valueNameC = C.CString(valueName)
		defer C.free(unsafe.Pointer(valueNameC))
	}
	var defaultValueC *C.char
	if defaultValue != "" {
		defaultValueC = C.CString(defaultValue)
		defer C.free(unsafe.Pointer(defaultValueC))
	}
	tmpValue := NewQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption3(C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.struct_QtCore_PackedString{data: descriptionC, len: C.longlong(len(description))}, C.struct_QtCore_PackedString{data: valueNameC, len: C.longlong(len(valueName))}, C.struct_QtCore_PackedString{data: defaultValueC, len: C.longlong(len(defaultValue))}))
	runtime.SetFinalizer(tmpValue, (*QCommandLineOption).DestroyQCommandLineOption)
	return tmpValue
}

func NewQCommandLineOption4(names []string, description string, valueName string, defaultValue string) *QCommandLineOption {
	namesC := C.CString(strings.Join(names, "¡¦!"))
	defer C.free(unsafe.Pointer(namesC))
	var descriptionC *C.char
	if description != "" {
		descriptionC = C.CString(description)
		defer C.free(unsafe.Pointer(descriptionC))
	}
	var valueNameC *C.char
	if valueName != "" {
		valueNameC = C.CString(valueName)
		defer C.free(unsafe.Pointer(valueNameC))
	}
	var defaultValueC *C.char
	if defaultValue != "" {
		defaultValueC = C.CString(defaultValue)
		defer C.free(unsafe.Pointer(defaultValueC))
	}
	tmpValue := NewQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption4(C.struct_QtCore_PackedString{data: namesC, len: C.longlong(len(strings.Join(names, "¡¦!")))}, C.struct_QtCore_PackedString{data: descriptionC, len: C.longlong(len(description))}, C.struct_QtCore_PackedString{data: valueNameC, len: C.longlong(len(valueName))}, C.struct_QtCore_PackedString{data: defaultValueC, len: C.longlong(len(defaultValue))}))
	runtime.SetFinalizer(tmpValue, (*QCommandLineOption).DestroyQCommandLineOption)
	return tmpValue
}

func NewQCommandLineOption5(other QCommandLineOption_ITF) *QCommandLineOption {
	tmpValue := NewQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption5(PointerFromQCommandLineOption(other)))
	runtime.SetFinalizer(tmpValue, (*QCommandLineOption).DestroyQCommandLineOption)
	return tmpValue
}

func (ptr *QCommandLineOption) DefaultValues() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QCommandLineOption_DefaultValues(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QCommandLineOption) Description() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCommandLineOption_Description(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineOption) Flags() QCommandLineOption__Flag {
	if ptr.Pointer() != nil {
		return QCommandLineOption__Flag(C.QCommandLineOption_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCommandLineOption) Names() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QCommandLineOption_Names(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QCommandLineOption) SetDefaultValue(defaultValue string) {
	if ptr.Pointer() != nil {
		var defaultValueC *C.char
		if defaultValue != "" {
			defaultValueC = C.CString(defaultValue)
			defer C.free(unsafe.Pointer(defaultValueC))
		}
		C.QCommandLineOption_SetDefaultValue(ptr.Pointer(), C.struct_QtCore_PackedString{data: defaultValueC, len: C.longlong(len(defaultValue))})
	}
}

func (ptr *QCommandLineOption) SetDefaultValues(defaultValues []string) {
	if ptr.Pointer() != nil {
		defaultValuesC := C.CString(strings.Join(defaultValues, "¡¦!"))
		defer C.free(unsafe.Pointer(defaultValuesC))
		C.QCommandLineOption_SetDefaultValues(ptr.Pointer(), C.struct_QtCore_PackedString{data: defaultValuesC, len: C.longlong(len(strings.Join(defaultValues, "¡¦!")))})
	}
}

func (ptr *QCommandLineOption) SetDescription(description string) {
	if ptr.Pointer() != nil {
		var descriptionC *C.char
		if description != "" {
			descriptionC = C.CString(description)
			defer C.free(unsafe.Pointer(descriptionC))
		}
		C.QCommandLineOption_SetDescription(ptr.Pointer(), C.struct_QtCore_PackedString{data: descriptionC, len: C.longlong(len(description))})
	}
}

func (ptr *QCommandLineOption) SetFlags(flags QCommandLineOption__Flag) {
	if ptr.Pointer() != nil {
		C.QCommandLineOption_SetFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QCommandLineOption) SetValueName(valueName string) {
	if ptr.Pointer() != nil {
		var valueNameC *C.char
		if valueName != "" {
			valueNameC = C.CString(valueName)
			defer C.free(unsafe.Pointer(valueNameC))
		}
		C.QCommandLineOption_SetValueName(ptr.Pointer(), C.struct_QtCore_PackedString{data: valueNameC, len: C.longlong(len(valueName))})
	}
}

func (ptr *QCommandLineOption) Swap(other QCommandLineOption_ITF) {
	if ptr.Pointer() != nil {
		C.QCommandLineOption_Swap(ptr.Pointer(), PointerFromQCommandLineOption(other))
	}
}

func (ptr *QCommandLineOption) ValueName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCommandLineOption_ValueName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineOption) DestroyQCommandLineOption() {
	if ptr.Pointer() != nil {
		C.QCommandLineOption_DestroyQCommandLineOption(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QCommandLineParser struct {
	ptr unsafe.Pointer
}

type QCommandLineParser_ITF interface {
	QCommandLineParser_PTR() *QCommandLineParser
}

func (ptr *QCommandLineParser) QCommandLineParser_PTR() *QCommandLineParser {
	return ptr
}

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

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

func PointerFromQCommandLineParser(ptr QCommandLineParser_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCommandLineParser_PTR().Pointer()
	}
	return nil
}

func NewQCommandLineParserFromPointer(ptr unsafe.Pointer) (n *QCommandLineParser) {
	n = new(QCommandLineParser)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QCommandLineParser__SingleDashWordOptionMode
//QCommandLineParser::SingleDashWordOptionMode
type QCommandLineParser__SingleDashWordOptionMode int64

const (
	QCommandLineParser__ParseAsCompactedShortOptions QCommandLineParser__SingleDashWordOptionMode = QCommandLineParser__SingleDashWordOptionMode(0)
	QCommandLineParser__ParseAsLongOptions           QCommandLineParser__SingleDashWordOptionMode = QCommandLineParser__SingleDashWordOptionMode(1)
)

//go:generate stringer -type=QCommandLineParser__OptionsAfterPositionalArgumentsMode
//QCommandLineParser::OptionsAfterPositionalArgumentsMode
type QCommandLineParser__OptionsAfterPositionalArgumentsMode int64

const (
	QCommandLineParser__ParseAsOptions             QCommandLineParser__OptionsAfterPositionalArgumentsMode = QCommandLineParser__OptionsAfterPositionalArgumentsMode(0)
	QCommandLineParser__ParseAsPositionalArguments QCommandLineParser__OptionsAfterPositionalArgumentsMode = QCommandLineParser__OptionsAfterPositionalArgumentsMode(1)
)

func NewQCommandLineParser() *QCommandLineParser {
	tmpValue := NewQCommandLineParserFromPointer(C.QCommandLineParser_NewQCommandLineParser())
	runtime.SetFinalizer(tmpValue, (*QCommandLineParser).DestroyQCommandLineParser)
	return tmpValue
}

func (ptr *QCommandLineParser) AddHelpOption() *QCommandLineOption {
	if ptr.Pointer() != nil {
		tmpValue := NewQCommandLineOptionFromPointer(C.QCommandLineParser_AddHelpOption(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QCommandLineOption).DestroyQCommandLineOption)
		return tmpValue
	}
	return nil
}

func (ptr *QCommandLineParser) AddOption(option QCommandLineOption_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCommandLineParser_AddOption(ptr.Pointer(), PointerFromQCommandLineOption(option))) != 0
	}
	return false
}

func (ptr *QCommandLineParser) AddOptions(options []*QCommandLineOption) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCommandLineParser_AddOptions(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQCommandLineParserFromPointer(NewQCommandLineParserFromPointer(nil).__addOptions_options_newList())
			for _, v := range options {
				tmpList.__addOptions_options_setList(v)
			}
			return tmpList.Pointer()
		}())) != 0
	}
	return false
}

func (ptr *QCommandLineParser) AddPositionalArgument(name string, description string, syntax string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		var descriptionC *C.char
		if description != "" {
			descriptionC = C.CString(description)
			defer C.free(unsafe.Pointer(descriptionC))
		}
		var syntaxC *C.char
		if syntax != "" {
			syntaxC = C.CString(syntax)
			defer C.free(unsafe.Pointer(syntaxC))
		}
		C.QCommandLineParser_AddPositionalArgument(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.struct_QtCore_PackedString{data: descriptionC, len: C.longlong(len(description))}, C.struct_QtCore_PackedString{data: syntaxC, len: C.longlong(len(syntax))})
	}
}

func (ptr *QCommandLineParser) AddVersionOption() *QCommandLineOption {
	if ptr.Pointer() != nil {
		tmpValue := NewQCommandLineOptionFromPointer(C.QCommandLineParser_AddVersionOption(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QCommandLineOption).DestroyQCommandLineOption)
		return tmpValue
	}
	return nil
}

func (ptr *QCommandLineParser) ApplicationDescription() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCommandLineParser_ApplicationDescription(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineParser) ClearPositionalArguments() {
	if ptr.Pointer() != nil {
		C.QCommandLineParser_ClearPositionalArguments(ptr.Pointer())
	}
}

func (ptr *QCommandLineParser) ErrorText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCommandLineParser_ErrorText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineParser) HelpText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCommandLineParser_HelpText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineParser) IsSet(name string) bool {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int8(C.QCommandLineParser_IsSet(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})) != 0
	}
	return false
}

func (ptr *QCommandLineParser) IsSet2(option QCommandLineOption_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCommandLineParser_IsSet2(ptr.Pointer(), PointerFromQCommandLineOption(option))) != 0
	}
	return false
}

func (ptr *QCommandLineParser) OptionNames() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QCommandLineParser_OptionNames(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) Parse(arguments []string) bool {
	if ptr.Pointer() != nil {
		argumentsC := C.CString(strings.Join(arguments, "¡¦!"))
		defer C.free(unsafe.Pointer(argumentsC))
		return int8(C.QCommandLineParser_Parse(ptr.Pointer(), C.struct_QtCore_PackedString{data: argumentsC, len: C.longlong(len(strings.Join(arguments, "¡¦!")))})) != 0
	}
	return false
}

func (ptr *QCommandLineParser) PositionalArguments() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QCommandLineParser_PositionalArguments(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) Process(arguments []string) {
	if ptr.Pointer() != nil {
		argumentsC := C.CString(strings.Join(arguments, "¡¦!"))
		defer C.free(unsafe.Pointer(argumentsC))
		C.QCommandLineParser_Process(ptr.Pointer(), C.struct_QtCore_PackedString{data: argumentsC, len: C.longlong(len(strings.Join(arguments, "¡¦!")))})
	}
}

func (ptr *QCommandLineParser) Process2(app QCoreApplication_ITF) {
	if ptr.Pointer() != nil {
		C.QCommandLineParser_Process2(ptr.Pointer(), PointerFromQCoreApplication(app))
	}
}

func (ptr *QCommandLineParser) SetApplicationDescription(description string) {
	if ptr.Pointer() != nil {
		var descriptionC *C.char
		if description != "" {
			descriptionC = C.CString(description)
			defer C.free(unsafe.Pointer(descriptionC))
		}
		C.QCommandLineParser_SetApplicationDescription(ptr.Pointer(), C.struct_QtCore_PackedString{data: descriptionC, len: C.longlong(len(description))})
	}
}

func (ptr *QCommandLineParser) SetOptionsAfterPositionalArgumentsMode(parsingMode QCommandLineParser__OptionsAfterPositionalArgumentsMode) {
	if ptr.Pointer() != nil {
		C.QCommandLineParser_SetOptionsAfterPositionalArgumentsMode(ptr.Pointer(), C.longlong(parsingMode))
	}
}

func (ptr *QCommandLineParser) SetSingleDashWordOptionMode(singleDashWordOptionMode QCommandLineParser__SingleDashWordOptionMode) {
	if ptr.Pointer() != nil {
		C.QCommandLineParser_SetSingleDashWordOptionMode(ptr.Pointer(), C.longlong(singleDashWordOptionMode))
	}
}

func (ptr *QCommandLineParser) ShowHelp(exitCode int) {
	if ptr.Pointer() != nil {
		C.QCommandLineParser_ShowHelp(ptr.Pointer(), C.int(int32(exitCode)))
	}
}

func (ptr *QCommandLineParser) ShowVersion() {
	if ptr.Pointer() != nil {
		C.QCommandLineParser_ShowVersion(ptr.Pointer())
	}
}

func (ptr *QCommandLineParser) UnknownOptionNames() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QCommandLineParser_UnknownOptionNames(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) Value(optionName string) string {
	if ptr.Pointer() != nil {
		var optionNameC *C.char
		if optionName != "" {
			optionNameC = C.CString(optionName)
			defer C.free(unsafe.Pointer(optionNameC))
		}
		return cGoUnpackString(C.QCommandLineParser_Value(ptr.Pointer(), C.struct_QtCore_PackedString{data: optionNameC, len: C.longlong(len(optionName))}))
	}
	return ""
}

func (ptr *QCommandLineParser) Value2(option QCommandLineOption_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCommandLineParser_Value2(ptr.Pointer(), PointerFromQCommandLineOption(option)))
	}
	return ""
}

func (ptr *QCommandLineParser) Values(optionName string) []string {
	if ptr.Pointer() != nil {
		var optionNameC *C.char
		if optionName != "" {
			optionNameC = C.CString(optionName)
			defer C.free(unsafe.Pointer(optionNameC))
		}
		return unpackStringList(cGoUnpackString(C.QCommandLineParser_Values(ptr.Pointer(), C.struct_QtCore_PackedString{data: optionNameC, len: C.longlong(len(optionName))})))
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) Values2(option QCommandLineOption_ITF) []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QCommandLineParser_Values2(ptr.Pointer(), PointerFromQCommandLineOption(option))))
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) DestroyQCommandLineParser() {
	if ptr.Pointer() != nil {
		C.QCommandLineParser_DestroyQCommandLineParser(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCommandLineParser) __addOptions_options_atList(i int) *QCommandLineOption {
	if ptr.Pointer() != nil {
		tmpValue := NewQCommandLineOptionFromPointer(C.QCommandLineParser___addOptions_options_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QCommandLineOption).DestroyQCommandLineOption)
		return tmpValue
	}
	return nil
}

func (ptr *QCommandLineParser) __addOptions_options_setList(i QCommandLineOption_ITF) {
	if ptr.Pointer() != nil {
		C.QCommandLineParser___addOptions_options_setList(ptr.Pointer(), PointerFromQCommandLineOption(i))
	}
}

func (ptr *QCommandLineParser) __addOptions_options_newList() unsafe.Pointer {
	return C.QCommandLineParser___addOptions_options_newList(ptr.Pointer())
}

type QConcatenateTablesProxyModel struct {
	QAbstractItemModel
}

type QConcatenateTablesProxyModel_ITF interface {
	QAbstractItemModel_ITF
	QConcatenateTablesProxyModel_PTR() *QConcatenateTablesProxyModel
}

func (ptr *QConcatenateTablesProxyModel) QConcatenateTablesProxyModel_PTR() *QConcatenateTablesProxyModel {
	return ptr
}

func (ptr *QConcatenateTablesProxyModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemModel_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQConcatenateTablesProxyModel(ptr QConcatenateTablesProxyModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QConcatenateTablesProxyModel_PTR().Pointer()
	}
	return nil
}

func NewQConcatenateTablesProxyModelFromPointer(ptr unsafe.Pointer) (n *QConcatenateTablesProxyModel) {
	n = new(QConcatenateTablesProxyModel)
	n.SetPointer(ptr)
	return
}
func NewQConcatenateTablesProxyModel(parent QObject_ITF) *QConcatenateTablesProxyModel {
	tmpValue := NewQConcatenateTablesProxyModelFromPointer(C.QConcatenateTablesProxyModel_NewQConcatenateTablesProxyModel(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QConcatenateTablesProxyModel) AddSourceModel(sourceModel QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QConcatenateTablesProxyModel_AddSourceModel(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
	}
}

//export callbackQConcatenateTablesProxyModel_ColumnCount
func callbackQConcatenateTablesProxyModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQConcatenateTablesProxyModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QConcatenateTablesProxyModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QConcatenateTablesProxyModel) DisconnectColumnCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnCount")
	}
}

func (ptr *QConcatenateTablesProxyModel) ColumnCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QConcatenateTablesProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QConcatenateTablesProxyModel) ColumnCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QConcatenateTablesProxyModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQConcatenateTablesProxyModel_Data
func callbackQConcatenateTablesProxyModel_Data(ptr unsafe.Pointer, index unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return PointerFromQVariant((*(*func(*QModelIndex, int) *QVariant)(signal))(NewQModelIndexFromPointer(index), int(int32(role))))
	}

	return PointerFromQVariant(NewQConcatenateTablesProxyModelFromPointer(ptr).DataDefault(NewQModelIndexFromPointer(index), int(int32(role))))
}

func (ptr *QConcatenateTablesProxyModel) ConnectData(f func(index *QModelIndex, role int) *QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "data"); signal != nil {
			f := func(index *QModelIndex, role int) *QVariant {
				(*(*func(*QModelIndex, int) *QVariant)(signal))(index, role)
				return f(index, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QConcatenateTablesProxyModel) DisconnectData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "data")
	}
}

func (ptr *QConcatenateTablesProxyModel) Data(index QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QConcatenateTablesProxyModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QConcatenateTablesProxyModel) DataDefault(index QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QConcatenateTablesProxyModel_DataDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQConcatenateTablesProxyModel_Index
func callbackQConcatenateTablesProxyModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return PointerFromQModelIndex((*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
	}

	return PointerFromQModelIndex(NewQConcatenateTablesProxyModelFromPointer(ptr).IndexDefault(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
}

func (ptr *QConcatenateTablesProxyModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "index"); signal != nil {
			f := func(row int, column int, parent *QModelIndex) *QModelIndex {
				(*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(row, column, parent)
				return f(row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QConcatenateTablesProxyModel) DisconnectIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "index")
	}
}

func (ptr *QConcatenateTablesProxyModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QConcatenateTablesProxyModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QConcatenateTablesProxyModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QConcatenateTablesProxyModel_IndexDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QConcatenateTablesProxyModel) MapFromSource(sourceIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QConcatenateTablesProxyModel_MapFromSource(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QConcatenateTablesProxyModel) MapToSource(proxyIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QConcatenateTablesProxyModel_MapToSource(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQConcatenateTablesProxyModel_Parent
func callbackQConcatenateTablesProxyModel_Parent(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(index)))
	}

	return PointerFromQModelIndex(NewQConcatenateTablesProxyModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(index)))
}

func (ptr *QConcatenateTablesProxyModel) ConnectParent(f func(index *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "parent"); signal != nil {
			f := func(index *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QConcatenateTablesProxyModel) DisconnectParent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "parent")
	}
}

func (ptr *QConcatenateTablesProxyModel) Parent(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QConcatenateTablesProxyModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QConcatenateTablesProxyModel) ParentDefault(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QConcatenateTablesProxyModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QConcatenateTablesProxyModel) RemoveSourceModel(sourceModel QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QConcatenateTablesProxyModel_RemoveSourceModel(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
	}
}

//export callbackQConcatenateTablesProxyModel_RowCount
func callbackQConcatenateTablesProxyModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQConcatenateTablesProxyModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QConcatenateTablesProxyModel) ConnectRowCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QConcatenateTablesProxyModel) DisconnectRowCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowCount")
	}
}

func (ptr *QConcatenateTablesProxyModel) RowCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QConcatenateTablesProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QConcatenateTablesProxyModel) RowCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QConcatenateTablesProxyModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQConcatenateTablesProxyModel_DestroyQConcatenateTablesProxyModel
func callbackQConcatenateTablesProxyModel_DestroyQConcatenateTablesProxyModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QConcatenateTablesProxyModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQConcatenateTablesProxyModelFromPointer(ptr).DestroyQConcatenateTablesProxyModelDefault()
	}
}

func (ptr *QConcatenateTablesProxyModel) ConnectDestroyQConcatenateTablesProxyModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QConcatenateTablesProxyModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QConcatenateTablesProxyModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QConcatenateTablesProxyModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QConcatenateTablesProxyModel) DisconnectDestroyQConcatenateTablesProxyModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QConcatenateTablesProxyModel")
	}
}

func (ptr *QConcatenateTablesProxyModel) DestroyQConcatenateTablesProxyModel() {
	if ptr.Pointer() != nil {
		C.QConcatenateTablesProxyModel_DestroyQConcatenateTablesProxyModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QConcatenateTablesProxyModel) DestroyQConcatenateTablesProxyModelDefault() {
	if ptr.Pointer() != nil {
		C.QConcatenateTablesProxyModel_DestroyQConcatenateTablesProxyModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QContiguousCache struct {
	ptr unsafe.Pointer
}

type QContiguousCache_ITF interface {
	QContiguousCache_PTR() *QContiguousCache
}

func (ptr *QContiguousCache) QContiguousCache_PTR() *QContiguousCache {
	return ptr
}

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

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

func PointerFromQContiguousCache(ptr QContiguousCache_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QContiguousCache_PTR().Pointer()
	}
	return nil
}

func NewQContiguousCacheFromPointer(ptr unsafe.Pointer) (n *QContiguousCache) {
	n = new(QContiguousCache)
	n.SetPointer(ptr)
	return
}

type QContiguousCacheData struct {
	ptr unsafe.Pointer
}

type QContiguousCacheData_ITF interface {
	QContiguousCacheData_PTR() *QContiguousCacheData
}

func (ptr *QContiguousCacheData) QContiguousCacheData_PTR() *QContiguousCacheData {
	return ptr
}

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

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

func PointerFromQContiguousCacheData(ptr QContiguousCacheData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QContiguousCacheData_PTR().Pointer()
	}
	return nil
}

func NewQContiguousCacheDataFromPointer(ptr unsafe.Pointer) (n *QContiguousCacheData) {
	n = new(QContiguousCacheData)
	n.SetPointer(ptr)
	return
}

func (ptr *QContiguousCacheData) DestroyQContiguousCacheData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QContiguousCacheTypedData struct {
	ptr unsafe.Pointer
}

type QContiguousCacheTypedData_ITF interface {
	QContiguousCacheTypedData_PTR() *QContiguousCacheTypedData
}

func (ptr *QContiguousCacheTypedData) QContiguousCacheTypedData_PTR() *QContiguousCacheTypedData {
	return ptr
}

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

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

func PointerFromQContiguousCacheTypedData(ptr QContiguousCacheTypedData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QContiguousCacheTypedData_PTR().Pointer()
	}
	return nil
}

func NewQContiguousCacheTypedDataFromPointer(ptr unsafe.Pointer) (n *QContiguousCacheTypedData) {
	n = new(QContiguousCacheTypedData)
	n.SetPointer(ptr)
	return
}

func (ptr *QContiguousCacheTypedData) DestroyQContiguousCacheTypedData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QCoreApplication struct {
	QObject
}

type QCoreApplication_ITF interface {
	QObject_ITF
	QCoreApplication_PTR() *QCoreApplication
}

func (ptr *QCoreApplication) QCoreApplication_PTR() *QCoreApplication {
	return ptr
}

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

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

func PointerFromQCoreApplication(ptr QCoreApplication_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCoreApplication_PTR().Pointer()
	}
	return nil
}

func NewQCoreApplicationFromPointer(ptr unsafe.Pointer) (n *QCoreApplication) {
	n = new(QCoreApplication)
	n.SetPointer(ptr)
	return
}
func NewQCoreApplication(argc int, argv []string) *QCoreApplication {
	argvC := C.CString(strings.Join(argv, "|"))
	defer C.free(unsafe.Pointer(argvC))
	tmpValue := NewQCoreApplicationFromPointer(C.QCoreApplication_NewQCoreApplication(C.int(int32(argc)), argvC))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQCoreApplication_AboutToQuit
func callbackQCoreApplication_AboutToQuit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "aboutToQuit"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QCoreApplication) ConnectAboutToQuit(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "aboutToQuit") {
			C.QCoreApplication_ConnectAboutToQuit(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "aboutToQuit")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "aboutToQuit"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "aboutToQuit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "aboutToQuit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCoreApplication) DisconnectAboutToQuit() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_DisconnectAboutToQuit(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "aboutToQuit")
	}
}

func QCoreApplication_AddLibraryPath(path string) {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	C.QCoreApplication_QCoreApplication_AddLibraryPath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
}

func (ptr *QCoreApplication) AddLibraryPath(path string) {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	C.QCoreApplication_QCoreApplication_AddLibraryPath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
}

func QCoreApplication_ApplicationDirPath() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_ApplicationDirPath())
}

func (ptr *QCoreApplication) ApplicationDirPath() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_ApplicationDirPath())
}

func QCoreApplication_ApplicationFilePath() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_ApplicationFilePath())
}

func (ptr *QCoreApplication) ApplicationFilePath() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_ApplicationFilePath())
}

func QCoreApplication_ApplicationName() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_ApplicationName())
}

func (ptr *QCoreApplication) ApplicationName() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_ApplicationName())
}

//export callbackQCoreApplication_ApplicationNameChanged
func callbackQCoreApplication_ApplicationNameChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "applicationNameChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QCoreApplication) ConnectApplicationNameChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "applicationNameChanged") {
			C.QCoreApplication_ConnectApplicationNameChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "applicationNameChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "applicationNameChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "applicationNameChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "applicationNameChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCoreApplication) DisconnectApplicationNameChanged() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_DisconnectApplicationNameChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "applicationNameChanged")
	}
}

func (ptr *QCoreApplication) ApplicationNameChanged() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_ApplicationNameChanged(ptr.Pointer())
	}
}

func QCoreApplication_ApplicationPid() int64 {
	return int64(C.QCoreApplication_QCoreApplication_ApplicationPid())
}

func (ptr *QCoreApplication) ApplicationPid() int64 {
	return int64(C.QCoreApplication_QCoreApplication_ApplicationPid())
}

func QCoreApplication_ApplicationVersion() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_ApplicationVersion())
}

func (ptr *QCoreApplication) ApplicationVersion() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_ApplicationVersion())
}

//export callbackQCoreApplication_ApplicationVersionChanged
func callbackQCoreApplication_ApplicationVersionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "applicationVersionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QCoreApplication) ConnectApplicationVersionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "applicationVersionChanged") {
			C.QCoreApplication_ConnectApplicationVersionChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "applicationVersionChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "applicationVersionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "applicationVersionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "applicationVersionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCoreApplication) DisconnectApplicationVersionChanged() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_DisconnectApplicationVersionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "applicationVersionChanged")
	}
}

func (ptr *QCoreApplication) ApplicationVersionChanged() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_ApplicationVersionChanged(ptr.Pointer())
	}
}

func QCoreApplication_Arguments() []string {
	return unpackStringList(cGoUnpackString(C.QCoreApplication_QCoreApplication_Arguments()))
}

func (ptr *QCoreApplication) Arguments() []string {
	return unpackStringList(cGoUnpackString(C.QCoreApplication_QCoreApplication_Arguments()))
}

func QCoreApplication_ClosingDown() bool {
	return int8(C.QCoreApplication_QCoreApplication_ClosingDown()) != 0
}

func (ptr *QCoreApplication) ClosingDown() bool {
	return int8(C.QCoreApplication_QCoreApplication_ClosingDown()) != 0
}

func QCoreApplication_EventDispatcher() *QAbstractEventDispatcher {
	tmpValue := NewQAbstractEventDispatcherFromPointer(C.QCoreApplication_QCoreApplication_EventDispatcher())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QCoreApplication) EventDispatcher() *QAbstractEventDispatcher {
	tmpValue := NewQAbstractEventDispatcherFromPointer(C.QCoreApplication_QCoreApplication_EventDispatcher())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QCoreApplication_Exec() int {
	return int(int32(C.QCoreApplication_QCoreApplication_Exec()))
}

func (ptr *QCoreApplication) Exec() int {
	return int(int32(C.QCoreApplication_QCoreApplication_Exec()))
}

func QCoreApplication_Exit(returnCode int) {
	C.QCoreApplication_QCoreApplication_Exit(C.int(int32(returnCode)))
}

func (ptr *QCoreApplication) Exit(returnCode int) {
	C.QCoreApplication_QCoreApplication_Exit(C.int(int32(returnCode)))
}

func (ptr *QCoreApplication) InstallNativeEventFilter(filterObj QAbstractNativeEventFilter_ITF) {
	if ptr.Pointer() != nil {
		C.QCoreApplication_InstallNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filterObj))
	}
}

func QCoreApplication_InstallTranslator(translationFile QTranslator_ITF) bool {
	return int8(C.QCoreApplication_QCoreApplication_InstallTranslator(PointerFromQTranslator(translationFile))) != 0
}

func (ptr *QCoreApplication) InstallTranslator(translationFile QTranslator_ITF) bool {
	return int8(C.QCoreApplication_QCoreApplication_InstallTranslator(PointerFromQTranslator(translationFile))) != 0
}

func QCoreApplication_Instance() *QCoreApplication {
	tmpValue := NewQCoreApplicationFromPointer(C.QCoreApplication_QCoreApplication_Instance())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QCoreApplication) Instance() *QCoreApplication {
	tmpValue := NewQCoreApplicationFromPointer(C.QCoreApplication_QCoreApplication_Instance())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QCoreApplication_IsQuitLockEnabled() bool {
	return int8(C.QCoreApplication_QCoreApplication_IsQuitLockEnabled()) != 0
}

func (ptr *QCoreApplication) IsQuitLockEnabled() bool {
	return int8(C.QCoreApplication_QCoreApplication_IsQuitLockEnabled()) != 0
}

func QCoreApplication_IsSetuidAllowed() bool {
	return int8(C.QCoreApplication_QCoreApplication_IsSetuidAllowed()) != 0
}

func (ptr *QCoreApplication) IsSetuidAllowed() bool {
	return int8(C.QCoreApplication_QCoreApplication_IsSetuidAllowed()) != 0
}

func QCoreApplication_LibraryPaths() []string {
	return unpackStringList(cGoUnpackString(C.QCoreApplication_QCoreApplication_LibraryPaths()))
}

func (ptr *QCoreApplication) LibraryPaths() []string {
	return unpackStringList(cGoUnpackString(C.QCoreApplication_QCoreApplication_LibraryPaths()))
}

func QCoreApplication_OrganizationDomain() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_OrganizationDomain())
}

func (ptr *QCoreApplication) OrganizationDomain() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_OrganizationDomain())
}

//export callbackQCoreApplication_OrganizationDomainChanged
func callbackQCoreApplication_OrganizationDomainChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "organizationDomainChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QCoreApplication) ConnectOrganizationDomainChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "organizationDomainChanged") {
			C.QCoreApplication_ConnectOrganizationDomainChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "organizationDomainChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "organizationDomainChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "organizationDomainChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "organizationDomainChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCoreApplication) DisconnectOrganizationDomainChanged() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_DisconnectOrganizationDomainChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "organizationDomainChanged")
	}
}

func (ptr *QCoreApplication) OrganizationDomainChanged() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_OrganizationDomainChanged(ptr.Pointer())
	}
}

func QCoreApplication_OrganizationName() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_OrganizationName())
}

func (ptr *QCoreApplication) OrganizationName() string {
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_OrganizationName())
}

//export callbackQCoreApplication_OrganizationNameChanged
func callbackQCoreApplication_OrganizationNameChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "organizationNameChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QCoreApplication) ConnectOrganizationNameChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "organizationNameChanged") {
			C.QCoreApplication_ConnectOrganizationNameChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "organizationNameChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "organizationNameChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "organizationNameChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "organizationNameChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCoreApplication) DisconnectOrganizationNameChanged() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_DisconnectOrganizationNameChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "organizationNameChanged")
	}
}

func (ptr *QCoreApplication) OrganizationNameChanged() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_OrganizationNameChanged(ptr.Pointer())
	}
}

func QCoreApplication_PostEvent(receiver QObject_ITF, event QEvent_ITF, priority int) {
	C.QCoreApplication_QCoreApplication_PostEvent(PointerFromQObject(receiver), PointerFromQEvent(event), C.int(int32(priority)))
}

func (ptr *QCoreApplication) PostEvent(receiver QObject_ITF, event QEvent_ITF, priority int) {
	C.QCoreApplication_QCoreApplication_PostEvent(PointerFromQObject(receiver), PointerFromQEvent(event), C.int(int32(priority)))
}

func QCoreApplication_ProcessEvents(flags QEventLoop__ProcessEventsFlag) {
	C.QCoreApplication_QCoreApplication_ProcessEvents(C.longlong(flags))
}

func (ptr *QCoreApplication) ProcessEvents(flags QEventLoop__ProcessEventsFlag) {
	C.QCoreApplication_QCoreApplication_ProcessEvents(C.longlong(flags))
}

func QCoreApplication_ProcessEvents2(flags QEventLoop__ProcessEventsFlag, ms int) {
	C.QCoreApplication_QCoreApplication_ProcessEvents2(C.longlong(flags), C.int(int32(ms)))
}

func (ptr *QCoreApplication) ProcessEvents2(flags QEventLoop__ProcessEventsFlag, ms int) {
	C.QCoreApplication_QCoreApplication_ProcessEvents2(C.longlong(flags), C.int(int32(ms)))
}

//export callbackQCoreApplication_Quit
func callbackQCoreApplication_Quit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "quit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCoreApplicationFromPointer(ptr).QuitDefault()
	}
}

func (ptr *QCoreApplication) ConnectQuit(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "quit"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "quit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "quit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCoreApplication) DisconnectQuit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "quit")
	}
}

func (ptr *QCoreApplication) Quit() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_Quit(ptr.Pointer())
	}
}

func (ptr *QCoreApplication) QuitDefault() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_QuitDefault(ptr.Pointer())
	}
}

func QCoreApplication_RemoveLibraryPath(path string) {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	C.QCoreApplication_QCoreApplication_RemoveLibraryPath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
}

func (ptr *QCoreApplication) RemoveLibraryPath(path string) {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	C.QCoreApplication_QCoreApplication_RemoveLibraryPath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
}

func (ptr *QCoreApplication) RemoveNativeEventFilter(filterObject QAbstractNativeEventFilter_ITF) {
	if ptr.Pointer() != nil {
		C.QCoreApplication_RemoveNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filterObject))
	}
}

func QCoreApplication_RemovePostedEvents(receiver QObject_ITF, eventType int) {
	C.QCoreApplication_QCoreApplication_RemovePostedEvents(PointerFromQObject(receiver), C.int(int32(eventType)))
}

func (ptr *QCoreApplication) RemovePostedEvents(receiver QObject_ITF, eventType int) {
	C.QCoreApplication_QCoreApplication_RemovePostedEvents(PointerFromQObject(receiver), C.int(int32(eventType)))
}

func QCoreApplication_RemoveTranslator(translationFile QTranslator_ITF) bool {
	return int8(C.QCoreApplication_QCoreApplication_RemoveTranslator(PointerFromQTranslator(translationFile))) != 0
}

func (ptr *QCoreApplication) RemoveTranslator(translationFile QTranslator_ITF) bool {
	return int8(C.QCoreApplication_QCoreApplication_RemoveTranslator(PointerFromQTranslator(translationFile))) != 0
}

func QCoreApplication_SendEvent(receiver QObject_ITF, event QEvent_ITF) bool {
	return int8(C.QCoreApplication_QCoreApplication_SendEvent(PointerFromQObject(receiver), PointerFromQEvent(event))) != 0
}

func (ptr *QCoreApplication) SendEvent(receiver QObject_ITF, event QEvent_ITF) bool {
	return int8(C.QCoreApplication_QCoreApplication_SendEvent(PointerFromQObject(receiver), PointerFromQEvent(event))) != 0
}

func QCoreApplication_SendPostedEvents(receiver QObject_ITF, event_type int) {
	C.QCoreApplication_QCoreApplication_SendPostedEvents(PointerFromQObject(receiver), C.int(int32(event_type)))
}

func (ptr *QCoreApplication) SendPostedEvents(receiver QObject_ITF, event_type int) {
	C.QCoreApplication_QCoreApplication_SendPostedEvents(PointerFromQObject(receiver), C.int(int32(event_type)))
}

func QCoreApplication_SetApplicationName(application string) {
	var applicationC *C.char
	if application != "" {
		applicationC = C.CString(application)
		defer C.free(unsafe.Pointer(applicationC))
	}
	C.QCoreApplication_QCoreApplication_SetApplicationName(C.struct_QtCore_PackedString{data: applicationC, len: C.longlong(len(application))})
}

func (ptr *QCoreApplication) SetApplicationName(application string) {
	var applicationC *C.char
	if application != "" {
		applicationC = C.CString(application)
		defer C.free(unsafe.Pointer(applicationC))
	}
	C.QCoreApplication_QCoreApplication_SetApplicationName(C.struct_QtCore_PackedString{data: applicationC, len: C.longlong(len(application))})
}

func QCoreApplication_SetApplicationVersion(version string) {
	var versionC *C.char
	if version != "" {
		versionC = C.CString(version)
		defer C.free(unsafe.Pointer(versionC))
	}
	C.QCoreApplication_QCoreApplication_SetApplicationVersion(C.struct_QtCore_PackedString{data: versionC, len: C.longlong(len(version))})
}

func (ptr *QCoreApplication) SetApplicationVersion(version string) {
	var versionC *C.char
	if version != "" {
		versionC = C.CString(version)
		defer C.free(unsafe.Pointer(versionC))
	}
	C.QCoreApplication_QCoreApplication_SetApplicationVersion(C.struct_QtCore_PackedString{data: versionC, len: C.longlong(len(version))})
}

func QCoreApplication_SetAttribute(attribute Qt__ApplicationAttribute, on bool) {
	C.QCoreApplication_QCoreApplication_SetAttribute(C.longlong(attribute), C.char(int8(qt.GoBoolToInt(on))))
}

func (ptr *QCoreApplication) SetAttribute(attribute Qt__ApplicationAttribute, on bool) {
	C.QCoreApplication_QCoreApplication_SetAttribute(C.longlong(attribute), C.char(int8(qt.GoBoolToInt(on))))
}

func QCoreApplication_SetEventDispatcher(eventDispatcher QAbstractEventDispatcher_ITF) {
	C.QCoreApplication_QCoreApplication_SetEventDispatcher(PointerFromQAbstractEventDispatcher(eventDispatcher))
}

func (ptr *QCoreApplication) SetEventDispatcher(eventDispatcher QAbstractEventDispatcher_ITF) {
	C.QCoreApplication_QCoreApplication_SetEventDispatcher(PointerFromQAbstractEventDispatcher(eventDispatcher))
}

func QCoreApplication_SetLibraryPaths(paths []string) {
	pathsC := C.CString(strings.Join(paths, "¡¦!"))
	defer C.free(unsafe.Pointer(pathsC))
	C.QCoreApplication_QCoreApplication_SetLibraryPaths(C.struct_QtCore_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "¡¦!")))})
}

func (ptr *QCoreApplication) SetLibraryPaths(paths []string) {
	pathsC := C.CString(strings.Join(paths, "¡¦!"))
	defer C.free(unsafe.Pointer(pathsC))
	C.QCoreApplication_QCoreApplication_SetLibraryPaths(C.struct_QtCore_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "¡¦!")))})
}

func QCoreApplication_SetOrganizationDomain(orgDomain string) {
	var orgDomainC *C.char
	if orgDomain != "" {
		orgDomainC = C.CString(orgDomain)
		defer C.free(unsafe.Pointer(orgDomainC))
	}
	C.QCoreApplication_QCoreApplication_SetOrganizationDomain(C.struct_QtCore_PackedString{data: orgDomainC, len: C.longlong(len(orgDomain))})
}

func (ptr *QCoreApplication) SetOrganizationDomain(orgDomain string) {
	var orgDomainC *C.char
	if orgDomain != "" {
		orgDomainC = C.CString(orgDomain)
		defer C.free(unsafe.Pointer(orgDomainC))
	}
	C.QCoreApplication_QCoreApplication_SetOrganizationDomain(C.struct_QtCore_PackedString{data: orgDomainC, len: C.longlong(len(orgDomain))})
}

func QCoreApplication_SetOrganizationName(orgName string) {
	var orgNameC *C.char
	if orgName != "" {
		orgNameC = C.CString(orgName)
		defer C.free(unsafe.Pointer(orgNameC))
	}
	C.QCoreApplication_QCoreApplication_SetOrganizationName(C.struct_QtCore_PackedString{data: orgNameC, len: C.longlong(len(orgName))})
}

func (ptr *QCoreApplication) SetOrganizationName(orgName string) {
	var orgNameC *C.char
	if orgName != "" {
		orgNameC = C.CString(orgName)
		defer C.free(unsafe.Pointer(orgNameC))
	}
	C.QCoreApplication_QCoreApplication_SetOrganizationName(C.struct_QtCore_PackedString{data: orgNameC, len: C.longlong(len(orgName))})
}

func QCoreApplication_SetQuitLockEnabled(enabled bool) {
	C.QCoreApplication_QCoreApplication_SetQuitLockEnabled(C.char(int8(qt.GoBoolToInt(enabled))))
}

func (ptr *QCoreApplication) SetQuitLockEnabled(enabled bool) {
	C.QCoreApplication_QCoreApplication_SetQuitLockEnabled(C.char(int8(qt.GoBoolToInt(enabled))))
}

func QCoreApplication_SetSetuidAllowed(allow bool) {
	C.QCoreApplication_QCoreApplication_SetSetuidAllowed(C.char(int8(qt.GoBoolToInt(allow))))
}

func (ptr *QCoreApplication) SetSetuidAllowed(allow bool) {
	C.QCoreApplication_QCoreApplication_SetSetuidAllowed(C.char(int8(qt.GoBoolToInt(allow))))
}

func QCoreApplication_StartingUp() bool {
	return int8(C.QCoreApplication_QCoreApplication_StartingUp()) != 0
}

func (ptr *QCoreApplication) StartingUp() bool {
	return int8(C.QCoreApplication_QCoreApplication_StartingUp()) != 0
}

func QCoreApplication_TestAttribute(attribute Qt__ApplicationAttribute) bool {
	return int8(C.QCoreApplication_QCoreApplication_TestAttribute(C.longlong(attribute))) != 0
}

func (ptr *QCoreApplication) TestAttribute(attribute Qt__ApplicationAttribute) bool {
	return int8(C.QCoreApplication_QCoreApplication_TestAttribute(C.longlong(attribute))) != 0
}

func QCoreApplication_Translate(context string, sourceText string, disambiguation string, n int) string {
	var contextC *C.char
	if context != "" {
		contextC = C.CString(context)
		defer C.free(unsafe.Pointer(contextC))
	}
	var sourceTextC *C.char
	if sourceText != "" {
		sourceTextC = C.CString(sourceText)
		defer C.free(unsafe.Pointer(sourceTextC))
	}
	var disambiguationC *C.char
	if disambiguation != "" {
		disambiguationC = C.CString(disambiguation)
		defer C.free(unsafe.Pointer(disambiguationC))
	}
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_Translate(contextC, sourceTextC, disambiguationC, C.int(int32(n))))
}

func (ptr *QCoreApplication) Translate(context string, sourceText string, disambiguation string, n int) string {
	var contextC *C.char
	if context != "" {
		contextC = C.CString(context)
		defer C.free(unsafe.Pointer(contextC))
	}
	var sourceTextC *C.char
	if sourceText != "" {
		sourceTextC = C.CString(sourceText)
		defer C.free(unsafe.Pointer(sourceTextC))
	}
	var disambiguationC *C.char
	if disambiguation != "" {
		disambiguationC = C.CString(disambiguation)
		defer C.free(unsafe.Pointer(disambiguationC))
	}
	return cGoUnpackString(C.QCoreApplication_QCoreApplication_Translate(contextC, sourceTextC, disambiguationC, C.int(int32(n))))
}

//export callbackQCoreApplication_DestroyQCoreApplication
func callbackQCoreApplication_DestroyQCoreApplication(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QCoreApplication"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCoreApplicationFromPointer(ptr).DestroyQCoreApplicationDefault()
	}
}

func (ptr *QCoreApplication) ConnectDestroyQCoreApplication(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QCoreApplication"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QCoreApplication", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QCoreApplication", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCoreApplication) DisconnectDestroyQCoreApplication() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QCoreApplication")
	}
}

func (ptr *QCoreApplication) DestroyQCoreApplication() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_DestroyQCoreApplication(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCoreApplication) DestroyQCoreApplicationDefault() {
	if ptr.Pointer() != nil {
		C.QCoreApplication_DestroyQCoreApplicationDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QCryptographicHash struct {
	ptr unsafe.Pointer
}

type QCryptographicHash_ITF interface {
	QCryptographicHash_PTR() *QCryptographicHash
}

func (ptr *QCryptographicHash) QCryptographicHash_PTR() *QCryptographicHash {
	return ptr
}

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

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

func PointerFromQCryptographicHash(ptr QCryptographicHash_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCryptographicHash_PTR().Pointer()
	}
	return nil
}

func NewQCryptographicHashFromPointer(ptr unsafe.Pointer) (n *QCryptographicHash) {
	n = new(QCryptographicHash)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QCryptographicHash__Algorithm
//QCryptographicHash::Algorithm
type QCryptographicHash__Algorithm int64

const (
	QCryptographicHash__Md4          QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(0)
	QCryptographicHash__Md5          QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(1)
	QCryptographicHash__Sha1         QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(2)
	QCryptographicHash__Sha224       QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(3)
	QCryptographicHash__Sha256       QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(4)
	QCryptographicHash__Sha384       QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(5)
	QCryptographicHash__Sha512       QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(6)
	QCryptographicHash__Keccak_224   QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(7)
	QCryptographicHash__Keccak_256   QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(8)
	QCryptographicHash__Keccak_384   QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(9)
	QCryptographicHash__Keccak_512   QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(10)
	QCryptographicHash__RealSha3_224 QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(11)
	QCryptographicHash__RealSha3_256 QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(12)
	QCryptographicHash__RealSha3_384 QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(13)
	QCryptographicHash__RealSha3_512 QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(14)
	QCryptographicHash__Sha3_224     QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(QCryptographicHash__RealSha3_224)
	QCryptographicHash__Sha3_256     QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(QCryptographicHash__RealSha3_256)
	QCryptographicHash__Sha3_384     QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(QCryptographicHash__RealSha3_384)
	QCryptographicHash__Sha3_512     QCryptographicHash__Algorithm = QCryptographicHash__Algorithm(QCryptographicHash__RealSha3_512)
)

func NewQCryptographicHash(method QCryptographicHash__Algorithm) *QCryptographicHash {
	tmpValue := NewQCryptographicHashFromPointer(C.QCryptographicHash_NewQCryptographicHash(C.longlong(method)))
	runtime.SetFinalizer(tmpValue, (*QCryptographicHash).DestroyQCryptographicHash)
	return tmpValue
}

func (ptr *QCryptographicHash) AddData(data []byte, length int) {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		C.QCryptographicHash_AddData(ptr.Pointer(), dataC, C.int(int32(length)))
	}
}

func (ptr *QCryptographicHash) AddData2(data QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QCryptographicHash_AddData2(ptr.Pointer(), PointerFromQByteArray(data))
	}
}

func (ptr *QCryptographicHash) AddData3(device QIODevice_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCryptographicHash_AddData3(ptr.Pointer(), PointerFromQIODevice(device))) != 0
	}
	return false
}

func QCryptographicHash_Hash(data QByteArray_ITF, method QCryptographicHash__Algorithm) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QCryptographicHash_QCryptographicHash_Hash(PointerFromQByteArray(data), C.longlong(method)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QCryptographicHash) Hash(data QByteArray_ITF, method QCryptographicHash__Algorithm) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QCryptographicHash_QCryptographicHash_Hash(PointerFromQByteArray(data), C.longlong(method)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QCryptographicHash_HashLength(method QCryptographicHash__Algorithm) int {
	return int(int32(C.QCryptographicHash_QCryptographicHash_HashLength(C.longlong(method))))
}

func (ptr *QCryptographicHash) HashLength(method QCryptographicHash__Algorithm) int {
	return int(int32(C.QCryptographicHash_QCryptographicHash_HashLength(C.longlong(method))))
}

func (ptr *QCryptographicHash) Reset() {
	if ptr.Pointer() != nil {
		C.QCryptographicHash_Reset(ptr.Pointer())
	}
}

func (ptr *QCryptographicHash) Result() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QCryptographicHash_Result(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QCryptographicHash) DestroyQCryptographicHash() {
	if ptr.Pointer() != nil {
		C.QCryptographicHash_DestroyQCryptographicHash(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QDataStream struct {
	ptr unsafe.Pointer
}

type QDataStream_ITF interface {
	QDataStream_PTR() *QDataStream
}

func (ptr *QDataStream) QDataStream_PTR() *QDataStream {
	return ptr
}

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

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

func PointerFromQDataStream(ptr QDataStream_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDataStream_PTR().Pointer()
	}
	return nil
}

func NewQDataStreamFromPointer(ptr unsafe.Pointer) (n *QDataStream) {
	n = new(QDataStream)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDataStream__Version
//QDataStream::Version
type QDataStream__Version int64

const (
	QDataStream__Qt_1_0                    QDataStream__Version = QDataStream__Version(1)
	QDataStream__Qt_2_0                    QDataStream__Version = QDataStream__Version(2)
	QDataStream__Qt_2_1                    QDataStream__Version = QDataStream__Version(3)
	QDataStream__Qt_3_0                    QDataStream__Version = QDataStream__Version(4)
	QDataStream__Qt_3_1                    QDataStream__Version = QDataStream__Version(5)
	QDataStream__Qt_3_3                    QDataStream__Version = QDataStream__Version(6)
	QDataStream__Qt_4_0                    QDataStream__Version = QDataStream__Version(7)
	QDataStream__Qt_4_1                    QDataStream__Version = QDataStream__Version(QDataStream__Qt_4_0)
	QDataStream__Qt_4_2                    QDataStream__Version = QDataStream__Version(8)
	QDataStream__Qt_4_3                    QDataStream__Version = QDataStream__Version(9)
	QDataStream__Qt_4_4                    QDataStream__Version = QDataStream__Version(10)
	QDataStream__Qt_4_5                    QDataStream__Version = QDataStream__Version(11)
	QDataStream__Qt_4_6                    QDataStream__Version = QDataStream__Version(12)
	QDataStream__Qt_4_7                    QDataStream__Version = QDataStream__Version(QDataStream__Qt_4_6)
	QDataStream__Qt_4_8                    QDataStream__Version = QDataStream__Version(QDataStream__Qt_4_7)
	QDataStream__Qt_4_9                    QDataStream__Version = QDataStream__Version(QDataStream__Qt_4_8)
	QDataStream__Qt_5_0                    QDataStream__Version = QDataStream__Version(13)
	QDataStream__Qt_5_1                    QDataStream__Version = QDataStream__Version(14)
	QDataStream__Qt_5_2                    QDataStream__Version = QDataStream__Version(15)
	QDataStream__Qt_5_3                    QDataStream__Version = QDataStream__Version(QDataStream__Qt_5_2)
	QDataStream__Qt_5_4                    QDataStream__Version = QDataStream__Version(16)
	QDataStream__Qt_5_5                    QDataStream__Version = QDataStream__Version(QDataStream__Qt_5_4)
	QDataStream__Qt_5_6                    QDataStream__Version = QDataStream__Version(17)
	QDataStream__Qt_5_7                    QDataStream__Version = QDataStream__Version(QDataStream__Qt_5_6)
	QDataStream__Qt_5_8                    QDataStream__Version = QDataStream__Version(QDataStream__Qt_5_7)
	QDataStream__Qt_5_9                    QDataStream__Version = QDataStream__Version(QDataStream__Qt_5_8)
	QDataStream__Qt_5_10                   QDataStream__Version = QDataStream__Version(QDataStream__Qt_5_9)
	QDataStream__Qt_5_11                   QDataStream__Version = QDataStream__Version(QDataStream__Qt_5_10)
	QDataStream__Qt_5_12                   QDataStream__Version = QDataStream__Version(18)
	QDataStream__Qt_5_13                   QDataStream__Version = QDataStream__Version(19)
	QDataStream__Qt_DefaultCompiledVersion QDataStream__Version = QDataStream__Version(QDataStream__Qt_5_13)
)

//go:generate stringer -type=QDataStream__ByteOrder
//QDataStream::ByteOrder
type QDataStream__ByteOrder int64

const (
	QDataStream__BigEndian    QDataStream__ByteOrder = QDataStream__ByteOrder(QSysInfo__BigEndian)
	QDataStream__LittleEndian QDataStream__ByteOrder = QDataStream__ByteOrder(QSysInfo__LittleEndian)
)

//go:generate stringer -type=QDataStream__Status
//QDataStream::Status
type QDataStream__Status int64

const (
	QDataStream__Ok              QDataStream__Status = QDataStream__Status(0)
	QDataStream__ReadPastEnd     QDataStream__Status = QDataStream__Status(1)
	QDataStream__ReadCorruptData QDataStream__Status = QDataStream__Status(2)
	QDataStream__WriteFailed     QDataStream__Status = QDataStream__Status(3)
)

//go:generate stringer -type=QDataStream__FloatingPointPrecision
//QDataStream::FloatingPointPrecision
type QDataStream__FloatingPointPrecision int64

const (
	QDataStream__SinglePrecision QDataStream__FloatingPointPrecision = QDataStream__FloatingPointPrecision(0)
	QDataStream__DoublePrecision QDataStream__FloatingPointPrecision = QDataStream__FloatingPointPrecision(1)
)

func NewQDataStream() *QDataStream {
	tmpValue := NewQDataStreamFromPointer(C.QDataStream_NewQDataStream())
	runtime.SetFinalizer(tmpValue, (*QDataStream).DestroyQDataStream)
	return tmpValue
}

func NewQDataStream2(d QIODevice_ITF) *QDataStream {
	tmpValue := NewQDataStreamFromPointer(C.QDataStream_NewQDataStream2(PointerFromQIODevice(d)))
	runtime.SetFinalizer(tmpValue, (*QDataStream).DestroyQDataStream)
	return tmpValue
}

func NewQDataStream3(a QByteArray_ITF, mode QIODevice__OpenModeFlag) *QDataStream {
	tmpValue := NewQDataStreamFromPointer(C.QDataStream_NewQDataStream3(PointerFromQByteArray(a), C.longlong(mode)))
	runtime.SetFinalizer(tmpValue, (*QDataStream).DestroyQDataStream)
	return tmpValue
}

func NewQDataStream4(a QByteArray_ITF) *QDataStream {
	tmpValue := NewQDataStreamFromPointer(C.QDataStream_NewQDataStream4(PointerFromQByteArray(a)))
	runtime.SetFinalizer(tmpValue, (*QDataStream).DestroyQDataStream)
	return tmpValue
}

func (ptr *QDataStream) AbortTransaction() {
	if ptr.Pointer() != nil {
		C.QDataStream_AbortTransaction(ptr.Pointer())
	}
}

func (ptr *QDataStream) AtEnd() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDataStream_AtEnd(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDataStream) ByteOrder() QDataStream__ByteOrder {
	if ptr.Pointer() != nil {
		return QDataStream__ByteOrder(C.QDataStream_ByteOrder(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDataStream) CommitTransaction() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDataStream_CommitTransaction(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDataStream) Device() *QIODevice {
	if ptr.Pointer() != nil {
		tmpValue := NewQIODeviceFromPointer(C.QDataStream_Device(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDataStream) FloatingPointPrecision() QDataStream__FloatingPointPrecision {
	if ptr.Pointer() != nil {
		return QDataStream__FloatingPointPrecision(C.QDataStream_FloatingPointPrecision(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDataStream) ReadRawData(s []byte, l int) int {
	if ptr.Pointer() != nil {
		var sC *C.char
		if len(s) != 0 {
			sC = (*C.char)(unsafe.Pointer(&s[0]))
		}
		return int(int32(C.QDataStream_ReadRawData(ptr.Pointer(), sC, C.int(int32(l)))))
	}
	return 0
}

func (ptr *QDataStream) ResetStatus() {
	if ptr.Pointer() != nil {
		C.QDataStream_ResetStatus(ptr.Pointer())
	}
}

func (ptr *QDataStream) RollbackTransaction() {
	if ptr.Pointer() != nil {
		C.QDataStream_RollbackTransaction(ptr.Pointer())
	}
}

func (ptr *QDataStream) SetByteOrder(bo QDataStream__ByteOrder) {
	if ptr.Pointer() != nil {
		C.QDataStream_SetByteOrder(ptr.Pointer(), C.longlong(bo))
	}
}

func (ptr *QDataStream) SetDevice(d QIODevice_ITF) {
	if ptr.Pointer() != nil {
		C.QDataStream_SetDevice(ptr.Pointer(), PointerFromQIODevice(d))
	}
}

func (ptr *QDataStream) SetFloatingPointPrecision(precision QDataStream__FloatingPointPrecision) {
	if ptr.Pointer() != nil {
		C.QDataStream_SetFloatingPointPrecision(ptr.Pointer(), C.longlong(precision))
	}
}

func (ptr *QDataStream) SetStatus(status QDataStream__Status) {
	if ptr.Pointer() != nil {
		C.QDataStream_SetStatus(ptr.Pointer(), C.longlong(status))
	}
}

func (ptr *QDataStream) SetVersion(v int) {
	if ptr.Pointer() != nil {
		C.QDataStream_SetVersion(ptr.Pointer(), C.int(int32(v)))
	}
}

func (ptr *QDataStream) SkipRawData(l int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDataStream_SkipRawData(ptr.Pointer(), C.int(int32(l)))))
	}
	return 0
}

func (ptr *QDataStream) StartTransaction() {
	if ptr.Pointer() != nil {
		C.QDataStream_StartTransaction(ptr.Pointer())
	}
}

func (ptr *QDataStream) Status() QDataStream__Status {
	if ptr.Pointer() != nil {
		return QDataStream__Status(C.QDataStream_Status(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDataStream) Version() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDataStream_Version(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDataStream) WriteRawData(s []byte, l int) int {
	if ptr.Pointer() != nil {
		var sC *C.char
		if len(s) != 0 {
			sC = (*C.char)(unsafe.Pointer(&s[0]))
		}
		return int(int32(C.QDataStream_WriteRawData(ptr.Pointer(), sC, C.int(int32(l)))))
	}
	return 0
}

func (ptr *QDataStream) DestroyQDataStream() {
	if ptr.Pointer() != nil {
		C.QDataStream_DestroyQDataStream(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QDate struct {
	ptr unsafe.Pointer
}

type QDate_ITF interface {
	QDate_PTR() *QDate
}

func (ptr *QDate) QDate_PTR() *QDate {
	return ptr
}

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

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

func PointerFromQDate(ptr QDate_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDate_PTR().Pointer()
	}
	return nil
}

func NewQDateFromPointer(ptr unsafe.Pointer) (n *QDate) {
	n = new(QDate)
	n.SetPointer(ptr)
	return
}

func (ptr *QDate) DestroyQDate() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QDate__MonthNameType
//QDate::MonthNameType
type QDate__MonthNameType int64

const (
	QDate__DateFormat       QDate__MonthNameType = QDate__MonthNameType(0)
	QDate__StandaloneFormat QDate__MonthNameType = QDate__MonthNameType(1)
)

func NewQDate2() *QDate {
	tmpValue := NewQDateFromPointer(C.QDate_NewQDate2())
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func NewQDate3(y int, m int, d int) *QDate {
	tmpValue := NewQDateFromPointer(C.QDate_NewQDate3(C.int(int32(y)), C.int(int32(m)), C.int(int32(d))))
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func (ptr *QDate) AddDays(ndays int64) *QDate {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateFromPointer(C.QDate_AddDays(ptr.Pointer(), C.longlong(ndays)))
		runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QDate) AddMonths(nmonths int) *QDate {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateFromPointer(C.QDate_AddMonths(ptr.Pointer(), C.int(int32(nmonths))))
		runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QDate) AddYears(nyears int) *QDate {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateFromPointer(C.QDate_AddYears(ptr.Pointer(), C.int(int32(nyears))))
		runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func QDate_CurrentDate() *QDate {
	tmpValue := NewQDateFromPointer(C.QDate_QDate_CurrentDate())
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func (ptr *QDate) CurrentDate() *QDate {
	tmpValue := NewQDateFromPointer(C.QDate_QDate_CurrentDate())
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func (ptr *QDate) Day() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDate_Day(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDate) DayOfWeek() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDate_DayOfWeek(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDate) DayOfYear() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDate_DayOfYear(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDate) DaysInMonth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDate_DaysInMonth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDate) DaysInYear() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDate_DaysInYear(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDate) DaysTo(d QDate_ITF) int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDate_DaysTo(ptr.Pointer(), PointerFromQDate(d)))
	}
	return 0
}

func QDate_FromJulianDay(jd int64) *QDate {
	tmpValue := NewQDateFromPointer(C.QDate_QDate_FromJulianDay(C.longlong(jd)))
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func (ptr *QDate) FromJulianDay(jd int64) *QDate {
	tmpValue := NewQDateFromPointer(C.QDate_QDate_FromJulianDay(C.longlong(jd)))
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func QDate_FromString(stri string, format Qt__DateFormat) *QDate {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQDateFromPointer(C.QDate_QDate_FromString(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(format)))
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func (ptr *QDate) FromString(stri string, format Qt__DateFormat) *QDate {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQDateFromPointer(C.QDate_QDate_FromString(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(format)))
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func QDate_FromString2(stri string, format string) *QDate {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	var formatC *C.char
	if format != "" {
		formatC = C.CString(format)
		defer C.free(unsafe.Pointer(formatC))
	}
	tmpValue := NewQDateFromPointer(C.QDate_QDate_FromString2(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func (ptr *QDate) FromString2(stri string, format string) *QDate {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	var formatC *C.char
	if format != "" {
		formatC = C.CString(format)
		defer C.free(unsafe.Pointer(formatC))
	}
	tmpValue := NewQDateFromPointer(C.QDate_QDate_FromString2(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
	return tmpValue
}

func (ptr *QDate) GetDate(year int, month int, day int) {
	if ptr.Pointer() != nil {
		C.QDate_GetDate(ptr.Pointer(), C.int(int32(year)), C.int(int32(month)), C.int(int32(day)))
	}
}

func QDate_IsLeapYear(year int) bool {
	return int8(C.QDate_QDate_IsLeapYear(C.int(int32(year)))) != 0
}

func (ptr *QDate) IsLeapYear(year int) bool {
	return int8(C.QDate_QDate_IsLeapYear(C.int(int32(year)))) != 0
}

func (ptr *QDate) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDate_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDate) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDate_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func QDate_IsValid2(year int, month int, day int) bool {
	return int8(C.QDate_QDate_IsValid2(C.int(int32(year)), C.int(int32(month)), C.int(int32(day)))) != 0
}

func (ptr *QDate) IsValid2(year int, month int, day int) bool {
	return int8(C.QDate_QDate_IsValid2(C.int(int32(year)), C.int(int32(month)), C.int(int32(day)))) != 0
}

func (ptr *QDate) Month() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDate_Month(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDate) SetDate(year int, month int, day int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDate_SetDate(ptr.Pointer(), C.int(int32(year)), C.int(int32(month)), C.int(int32(day)))) != 0
	}
	return false
}

func (ptr *QDate) ToJulianDay() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDate_ToJulianDay(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDate) ToString(format string) string {
	if ptr.Pointer() != nil {
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		return cGoUnpackString(C.QDate_ToString(ptr.Pointer(), C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	}
	return ""
}

func (ptr *QDate) ToString2(format Qt__DateFormat) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDate_ToString2(ptr.Pointer(), C.longlong(format)))
	}
	return ""
}

func (ptr *QDate) ToString3(format QStringView_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDate_ToString3(ptr.Pointer(), PointerFromQStringView(format)))
	}
	return ""
}

func (ptr *QDate) WeekNumber(yearNumber int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDate_WeekNumber(ptr.Pointer(), C.int(int32(yearNumber)))))
	}
	return 0
}

func (ptr *QDate) Year() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDate_Year(ptr.Pointer())))
	}
	return 0
}

type QDateTime struct {
	ptr unsafe.Pointer
}

type QDateTime_ITF interface {
	QDateTime_PTR() *QDateTime
}

func (ptr *QDateTime) QDateTime_PTR() *QDateTime {
	return ptr
}

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

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

func PointerFromQDateTime(ptr QDateTime_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDateTime_PTR().Pointer()
	}
	return nil
}

func NewQDateTimeFromPointer(ptr unsafe.Pointer) (n *QDateTime) {
	n = new(QDateTime)
	n.SetPointer(ptr)
	return
}
func NewQDateTime() *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime())
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func NewQDateTime2(date QDate_ITF) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime2(PointerFromQDate(date)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func NewQDateTime3(date QDate_ITF, ti QTime_ITF, spec Qt__TimeSpec) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime3(PointerFromQDate(date), PointerFromQTime(ti), C.longlong(spec)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func NewQDateTime4(date QDate_ITF, ti QTime_ITF, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime4(PointerFromQDate(date), PointerFromQTime(ti), C.longlong(spec), C.int(int32(offsetSeconds))))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func NewQDateTime5(date QDate_ITF, ti QTime_ITF, timeZone QTimeZone_ITF) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime5(PointerFromQDate(date), PointerFromQTime(ti), PointerFromQTimeZone(timeZone)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func NewQDateTime6(other QDateTime_ITF) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime6(PointerFromQDateTime(other)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func NewQDateTime7(other QDateTime_ITF) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_NewQDateTime7(PointerFromQDateTime(other)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) AddDays(ndays int64) *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_AddDays(ptr.Pointer(), C.longlong(ndays)))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) AddMSecs(msecs int64) *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_AddMSecs(ptr.Pointer(), C.longlong(msecs)))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) AddMonths(nmonths int) *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_AddMonths(ptr.Pointer(), C.int(int32(nmonths))))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) AddSecs(s int64) *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_AddSecs(ptr.Pointer(), C.longlong(s)))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) AddYears(nyears int) *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_AddYears(ptr.Pointer(), C.int(int32(nyears))))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func QDateTime_CurrentDateTime() *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTime())
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) CurrentDateTime() *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTime())
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func QDateTime_CurrentDateTimeUtc() *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTimeUtc())
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) CurrentDateTimeUtc() *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTimeUtc())
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func QDateTime_CurrentMSecsSinceEpoch() int64 {
	return int64(C.QDateTime_QDateTime_CurrentMSecsSinceEpoch())
}

func (ptr *QDateTime) CurrentMSecsSinceEpoch() int64 {
	return int64(C.QDateTime_QDateTime_CurrentMSecsSinceEpoch())
}

func QDateTime_CurrentSecsSinceEpoch() int64 {
	return int64(C.QDateTime_QDateTime_CurrentSecsSinceEpoch())
}

func (ptr *QDateTime) CurrentSecsSinceEpoch() int64 {
	return int64(C.QDateTime_QDateTime_CurrentSecsSinceEpoch())
}

func (ptr *QDateTime) Date() *QDate {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateFromPointer(C.QDateTime_Date(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) DaysTo(other QDateTime_ITF) int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDateTime_DaysTo(ptr.Pointer(), PointerFromQDateTime(other)))
	}
	return 0
}

func QDateTime_FromMSecsSinceEpoch(msecs int64) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch(C.longlong(msecs)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) FromMSecsSinceEpoch(msecs int64) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch(C.longlong(msecs)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func QDateTime_FromMSecsSinceEpoch2(msecs int64, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch2(C.longlong(msecs), C.longlong(spec), C.int(int32(offsetSeconds))))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) FromMSecsSinceEpoch2(msecs int64, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch2(C.longlong(msecs), C.longlong(spec), C.int(int32(offsetSeconds))))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func QDateTime_FromMSecsSinceEpoch3(msecs int64, timeZone QTimeZone_ITF) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch3(C.longlong(msecs), PointerFromQTimeZone(timeZone)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) FromMSecsSinceEpoch3(msecs int64, timeZone QTimeZone_ITF) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch3(C.longlong(msecs), PointerFromQTimeZone(timeZone)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func QDateTime_FromSecsSinceEpoch(secs int64, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromSecsSinceEpoch(C.longlong(secs), C.longlong(spec), C.int(int32(offsetSeconds))))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) FromSecsSinceEpoch(secs int64, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromSecsSinceEpoch(C.longlong(secs), C.longlong(spec), C.int(int32(offsetSeconds))))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func QDateTime_FromSecsSinceEpoch2(secs int64, timeZone QTimeZone_ITF) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromSecsSinceEpoch2(C.longlong(secs), PointerFromQTimeZone(timeZone)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) FromSecsSinceEpoch2(secs int64, timeZone QTimeZone_ITF) *QDateTime {
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromSecsSinceEpoch2(C.longlong(secs), PointerFromQTimeZone(timeZone)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func QDateTime_FromString(stri string, format Qt__DateFormat) *QDateTime {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(format)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) FromString(stri string, format Qt__DateFormat) *QDateTime {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(format)))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func QDateTime_FromString2(stri string, format string) *QDateTime {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	var formatC *C.char
	if format != "" {
		formatC = C.CString(format)
		defer C.free(unsafe.Pointer(formatC))
	}
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString2(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) FromString2(stri string, format string) *QDateTime {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	var formatC *C.char
	if format != "" {
		formatC = C.CString(format)
		defer C.free(unsafe.Pointer(formatC))
	}
	tmpValue := NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString2(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
	return tmpValue
}

func (ptr *QDateTime) IsDaylightTime() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDateTime_IsDaylightTime(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDateTime) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDateTime_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDateTime) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDateTime_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDateTime) MsecsTo(other QDateTime_ITF) int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDateTime_MsecsTo(ptr.Pointer(), PointerFromQDateTime(other)))
	}
	return 0
}

func (ptr *QDateTime) OffsetFromUtc() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDateTime_OffsetFromUtc(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDateTime) SecsTo(other QDateTime_ITF) int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDateTime_SecsTo(ptr.Pointer(), PointerFromQDateTime(other)))
	}
	return 0
}

func (ptr *QDateTime) SetDate(date QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTime_SetDate(ptr.Pointer(), PointerFromQDate(date))
	}
}

func (ptr *QDateTime) SetMSecsSinceEpoch(msecs int64) {
	if ptr.Pointer() != nil {
		C.QDateTime_SetMSecsSinceEpoch(ptr.Pointer(), C.longlong(msecs))
	}
}

func (ptr *QDateTime) SetOffsetFromUtc(offsetSeconds int) {
	if ptr.Pointer() != nil {
		C.QDateTime_SetOffsetFromUtc(ptr.Pointer(), C.int(int32(offsetSeconds)))
	}
}

func (ptr *QDateTime) SetSecsSinceEpoch(secs int64) {
	if ptr.Pointer() != nil {
		C.QDateTime_SetSecsSinceEpoch(ptr.Pointer(), C.longlong(secs))
	}
}

func (ptr *QDateTime) SetTime(ti QTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTime_SetTime(ptr.Pointer(), PointerFromQTime(ti))
	}
}

func (ptr *QDateTime) SetTimeSpec(spec Qt__TimeSpec) {
	if ptr.Pointer() != nil {
		C.QDateTime_SetTimeSpec(ptr.Pointer(), C.longlong(spec))
	}
}

func (ptr *QDateTime) SetTimeZone(toZone QTimeZone_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTime_SetTimeZone(ptr.Pointer(), PointerFromQTimeZone(toZone))
	}
}

func (ptr *QDateTime) Swap(other QDateTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTime_Swap(ptr.Pointer(), PointerFromQDateTime(other))
	}
}

func (ptr *QDateTime) Time() *QTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQTimeFromPointer(C.QDateTime_Time(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) TimeSpec() Qt__TimeSpec {
	if ptr.Pointer() != nil {
		return Qt__TimeSpec(C.QDateTime_TimeSpec(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDateTime) TimeZone() *QTimeZone {
	if ptr.Pointer() != nil {
		tmpValue := NewQTimeZoneFromPointer(C.QDateTime_TimeZone(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) TimeZoneAbbreviation() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDateTime_TimeZoneAbbreviation(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDateTime) ToLocalTime() *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_ToLocalTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) ToMSecsSinceEpoch() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDateTime_ToMSecsSinceEpoch(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDateTime) ToOffsetFromUtc(offsetSeconds int) *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_ToOffsetFromUtc(ptr.Pointer(), C.int(int32(offsetSeconds))))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) ToSecsSinceEpoch() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDateTime_ToSecsSinceEpoch(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDateTime) ToString(format string) string {
	if ptr.Pointer() != nil {
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		return cGoUnpackString(C.QDateTime_ToString(ptr.Pointer(), C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	}
	return ""
}

func (ptr *QDateTime) ToString2(format Qt__DateFormat) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDateTime_ToString2(ptr.Pointer(), C.longlong(format)))
	}
	return ""
}

func (ptr *QDateTime) ToString3(format QStringView_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDateTime_ToString3(ptr.Pointer(), PointerFromQStringView(format)))
	}
	return ""
}

func (ptr *QDateTime) ToTimeSpec(spec Qt__TimeSpec) *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_ToTimeSpec(ptr.Pointer(), C.longlong(spec)))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) ToTimeZone(timeZone QTimeZone_ITF) *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_ToTimeZone(ptr.Pointer(), PointerFromQTimeZone(timeZone)))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) ToUTC() *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QDateTime_ToUTC(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTime) DestroyQDateTime() {
	if ptr.Pointer() != nil {
		C.QDateTime_DestroyQDateTime(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QDeadlineTimer struct {
	ptr unsafe.Pointer
}

type QDeadlineTimer_ITF interface {
	QDeadlineTimer_PTR() *QDeadlineTimer
}

func (ptr *QDeadlineTimer) QDeadlineTimer_PTR() *QDeadlineTimer {
	return ptr
}

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

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

func PointerFromQDeadlineTimer(ptr QDeadlineTimer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDeadlineTimer_PTR().Pointer()
	}
	return nil
}

func NewQDeadlineTimerFromPointer(ptr unsafe.Pointer) (n *QDeadlineTimer) {
	n = new(QDeadlineTimer)
	n.SetPointer(ptr)
	return
}

func (ptr *QDeadlineTimer) DestroyQDeadlineTimer() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QDeadlineTimer__ForeverConstant
//QDeadlineTimer::ForeverConstant
type QDeadlineTimer__ForeverConstant int64

const (
	QDeadlineTimer__Forever QDeadlineTimer__ForeverConstant = QDeadlineTimer__ForeverConstant(0)
)

func NewQDeadlineTimer(timerType Qt__TimerType) *QDeadlineTimer {
	tmpValue := NewQDeadlineTimerFromPointer(C.QDeadlineTimer_NewQDeadlineTimer(C.longlong(timerType)))
	runtime.SetFinalizer(tmpValue, (*QDeadlineTimer).DestroyQDeadlineTimer)
	return tmpValue
}

func NewQDeadlineTimer2(vqd QDeadlineTimer__ForeverConstant, timerType Qt__TimerType) *QDeadlineTimer {
	tmpValue := NewQDeadlineTimerFromPointer(C.QDeadlineTimer_NewQDeadlineTimer2(C.longlong(vqd), C.longlong(timerType)))
	runtime.SetFinalizer(tmpValue, (*QDeadlineTimer).DestroyQDeadlineTimer)
	return tmpValue
}

func NewQDeadlineTimer3(msecs int64, ty Qt__TimerType) *QDeadlineTimer {
	tmpValue := NewQDeadlineTimerFromPointer(C.QDeadlineTimer_NewQDeadlineTimer3(C.longlong(msecs), C.longlong(ty)))
	runtime.SetFinalizer(tmpValue, (*QDeadlineTimer).DestroyQDeadlineTimer)
	return tmpValue
}

func (ptr *QDeadlineTimer) Deadline() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDeadlineTimer_Deadline(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDeadlineTimer) DeadlineNSecs() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDeadlineTimer_DeadlineNSecs(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDeadlineTimer) HasExpired() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDeadlineTimer_HasExpired(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDeadlineTimer) IsForever() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDeadlineTimer_IsForever(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDeadlineTimer) RemainingTime() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDeadlineTimer_RemainingTime(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDeadlineTimer) RemainingTimeNSecs() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QDeadlineTimer_RemainingTimeNSecs(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDeadlineTimer) SetDeadline(msecs int64, timerType Qt__TimerType) {
	if ptr.Pointer() != nil {
		C.QDeadlineTimer_SetDeadline(ptr.Pointer(), C.longlong(msecs), C.longlong(timerType))
	}
}

func (ptr *QDeadlineTimer) SetPreciseDeadline(secs int64, nsecs int64, timerType Qt__TimerType) {
	if ptr.Pointer() != nil {
		C.QDeadlineTimer_SetPreciseDeadline(ptr.Pointer(), C.longlong(secs), C.longlong(nsecs), C.longlong(timerType))
	}
}

func (ptr *QDeadlineTimer) SetPreciseRemainingTime(secs int64, nsecs int64, timerType Qt__TimerType) {
	if ptr.Pointer() != nil {
		C.QDeadlineTimer_SetPreciseRemainingTime(ptr.Pointer(), C.longlong(secs), C.longlong(nsecs), C.longlong(timerType))
	}
}

func (ptr *QDeadlineTimer) SetRemainingTime(msecs int64, timerType Qt__TimerType) {
	if ptr.Pointer() != nil {
		C.QDeadlineTimer_SetRemainingTime(ptr.Pointer(), C.longlong(msecs), C.longlong(timerType))
	}
}

func (ptr *QDeadlineTimer) SetTimerType(timerType Qt__TimerType) {
	if ptr.Pointer() != nil {
		C.QDeadlineTimer_SetTimerType(ptr.Pointer(), C.longlong(timerType))
	}
}

func (ptr *QDeadlineTimer) Swap(other QDeadlineTimer_ITF) {
	if ptr.Pointer() != nil {
		C.QDeadlineTimer_Swap(ptr.Pointer(), PointerFromQDeadlineTimer(other))
	}
}

func (ptr *QDeadlineTimer) TimerType() Qt__TimerType {
	if ptr.Pointer() != nil {
		return Qt__TimerType(C.QDeadlineTimer_TimerType(ptr.Pointer()))
	}
	return 0
}

type QDebug struct {
	ptr unsafe.Pointer
}

type QDebug_ITF interface {
	QDebug_PTR() *QDebug
}

func (ptr *QDebug) QDebug_PTR() *QDebug {
	return ptr
}

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

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

func PointerFromQDebug(ptr QDebug_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDebug_PTR().Pointer()
	}
	return nil
}

func NewQDebugFromPointer(ptr unsafe.Pointer) (n *QDebug) {
	n = new(QDebug)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDebug__VerbosityLevel
//QDebug::VerbosityLevel
type QDebug__VerbosityLevel int64

const (
	QDebug__MinimumVerbosity QDebug__VerbosityLevel = QDebug__VerbosityLevel(0)
	QDebug__DefaultVerbosity QDebug__VerbosityLevel = QDebug__VerbosityLevel(2)
	QDebug__MaximumVerbosity QDebug__VerbosityLevel = QDebug__VerbosityLevel(7)
)

func NewQDebug(device QIODevice_ITF) *QDebug {
	tmpValue := NewQDebugFromPointer(C.QDebug_NewQDebug(PointerFromQIODevice(device)))
	runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
	return tmpValue
}

func NewQDebug2(stri string) *QDebug {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQDebugFromPointer(C.QDebug_NewQDebug2(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}))
	runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
	return tmpValue
}

func NewQDebug4(o QDebug_ITF) *QDebug {
	tmpValue := NewQDebugFromPointer(C.QDebug_NewQDebug4(PointerFromQDebug(o)))
	runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
	return tmpValue
}

func (ptr *QDebug) AutoInsertSpaces() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDebug_AutoInsertSpaces(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDebug) MaybeQuote(c string) *QDebug {
	if ptr.Pointer() != nil {
		var cC *C.char
		if c != "" {
			cC = C.CString(c)
			defer C.free(unsafe.Pointer(cC))
		}
		tmpValue := NewQDebugFromPointer(C.QDebug_MaybeQuote(ptr.Pointer(), cC))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QDebug) MaybeSpace() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QDebug_MaybeSpace(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QDebug) Noquote() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QDebug_Noquote(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QDebug) Nospace() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QDebug_Nospace(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QDebug) Quote() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QDebug_Quote(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QDebug) ResetFormat() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QDebug_ResetFormat(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QDebug) SetAutoInsertSpaces(b bool) {
	if ptr.Pointer() != nil {
		C.QDebug_SetAutoInsertSpaces(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QDebug) SetVerbosity(verbosityLevel int) {
	if ptr.Pointer() != nil {
		C.QDebug_SetVerbosity(ptr.Pointer(), C.int(int32(verbosityLevel)))
	}
}

func (ptr *QDebug) Space() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QDebug_Space(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QDebug) Swap(other QDebug_ITF) {
	if ptr.Pointer() != nil {
		C.QDebug_Swap(ptr.Pointer(), PointerFromQDebug(other))
	}
}

func (ptr *QDebug) Verbosity(verbosityLevel int) *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QDebug_Verbosity(ptr.Pointer(), C.int(int32(verbosityLevel))))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QDebug) Verbosity2() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDebug_Verbosity2(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDebug) DestroyQDebug() {
	if ptr.Pointer() != nil {
		C.QDebug_DestroyQDebug(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QDebugStateSaver struct {
	ptr unsafe.Pointer
}

type QDebugStateSaver_ITF interface {
	QDebugStateSaver_PTR() *QDebugStateSaver
}

func (ptr *QDebugStateSaver) QDebugStateSaver_PTR() *QDebugStateSaver {
	return ptr
}

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

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

func PointerFromQDebugStateSaver(ptr QDebugStateSaver_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDebugStateSaver_PTR().Pointer()
	}
	return nil
}

func NewQDebugStateSaverFromPointer(ptr unsafe.Pointer) (n *QDebugStateSaver) {
	n = new(QDebugStateSaver)
	n.SetPointer(ptr)
	return
}
func NewQDebugStateSaver(dbg QDebug_ITF) *QDebugStateSaver {
	tmpValue := NewQDebugStateSaverFromPointer(C.QDebugStateSaver_NewQDebugStateSaver(PointerFromQDebug(dbg)))
	runtime.SetFinalizer(tmpValue, (*QDebugStateSaver).DestroyQDebugStateSaver)
	return tmpValue
}

func (ptr *QDebugStateSaver) DestroyQDebugStateSaver() {
	if ptr.Pointer() != nil {
		C.QDebugStateSaver_DestroyQDebugStateSaver(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QDeferredDeleteEvent struct {
	QEvent
}

type QDeferredDeleteEvent_ITF interface {
	QEvent_ITF
	QDeferredDeleteEvent_PTR() *QDeferredDeleteEvent
}

func (ptr *QDeferredDeleteEvent) QDeferredDeleteEvent_PTR() *QDeferredDeleteEvent {
	return ptr
}

func (ptr *QDeferredDeleteEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QEvent_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQDeferredDeleteEvent(ptr QDeferredDeleteEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDeferredDeleteEvent_PTR().Pointer()
	}
	return nil
}

func NewQDeferredDeleteEventFromPointer(ptr unsafe.Pointer) (n *QDeferredDeleteEvent) {
	n = new(QDeferredDeleteEvent)
	n.SetPointer(ptr)
	return
}

func (ptr *QDeferredDeleteEvent) DestroyQDeferredDeleteEvent() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(ptr.Pointer(), "")
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQDeferredDeleteEvent() *QDeferredDeleteEvent {
	tmpValue := NewQDeferredDeleteEventFromPointer(C.QDeferredDeleteEvent_NewQDeferredDeleteEvent())
	runtime.SetFinalizer(tmpValue, (*QDeferredDeleteEvent).DestroyQDeferredDeleteEvent)
	return tmpValue
}

func (ptr *QDeferredDeleteEvent) LoopLevel() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDeferredDeleteEvent_LoopLevel(ptr.Pointer())))
	}
	return 0
}

type QDir struct {
	ptr unsafe.Pointer
}

type QDir_ITF interface {
	QDir_PTR() *QDir
}

func (ptr *QDir) QDir_PTR() *QDir {
	return ptr
}

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

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

func PointerFromQDir(ptr QDir_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDir_PTR().Pointer()
	}
	return nil
}

func NewQDirFromPointer(ptr unsafe.Pointer) (n *QDir) {
	n = new(QDir)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDir__Filter
//QDir::Filter
type QDir__Filter int64

const (
	QDir__Dirs           QDir__Filter = QDir__Filter(0x001)
	QDir__Files          QDir__Filter = QDir__Filter(0x002)
	QDir__Drives         QDir__Filter = QDir__Filter(0x004)
	QDir__NoSymLinks     QDir__Filter = QDir__Filter(0x008)
	QDir__AllEntries     QDir__Filter = QDir__Filter(QDir__Dirs | QDir__Files | QDir__Drives)
	QDir__TypeMask       QDir__Filter = QDir__Filter(0x00f)
	QDir__Readable       QDir__Filter = QDir__Filter(0x010)
	QDir__Writable       QDir__Filter = QDir__Filter(0x020)
	QDir__Executable     QDir__Filter = QDir__Filter(0x040)
	QDir__PermissionMask QDir__Filter = QDir__Filter(0x070)
	QDir__Modified       QDir__Filter = QDir__Filter(0x080)
	QDir__Hidden         QDir__Filter = QDir__Filter(0x100)
	QDir__System         QDir__Filter = QDir__Filter(0x200)
	QDir__AccessMask     QDir__Filter = QDir__Filter(0x3F0)
	QDir__AllDirs        QDir__Filter = QDir__Filter(0x400)
	QDir__CaseSensitive  QDir__Filter = QDir__Filter(0x800)
	QDir__NoDot          QDir__Filter = QDir__Filter(0x2000)
	QDir__NoDotDot       QDir__Filter = QDir__Filter(0x4000)
	QDir__NoDotAndDotDot QDir__Filter = QDir__Filter(QDir__NoDot | QDir__NoDotDot)
	QDir__NoFilter       QDir__Filter = QDir__Filter(-1)
)

//go:generate stringer -type=QDir__SortFlag
//QDir::SortFlag
type QDir__SortFlag int64

const (
	QDir__Name        QDir__SortFlag = QDir__SortFlag(0x00)
	QDir__Time        QDir__SortFlag = QDir__SortFlag(0x01)
	QDir__Size        QDir__SortFlag = QDir__SortFlag(0x02)
	QDir__Unsorted    QDir__SortFlag = QDir__SortFlag(0x03)
	QDir__SortByMask  QDir__SortFlag = QDir__SortFlag(0x03)
	QDir__DirsFirst   QDir__SortFlag = QDir__SortFlag(0x04)
	QDir__Reversed    QDir__SortFlag = QDir__SortFlag(0x08)
	QDir__IgnoreCase  QDir__SortFlag = QDir__SortFlag(0x10)
	QDir__DirsLast    QDir__SortFlag = QDir__SortFlag(0x20)
	QDir__LocaleAware QDir__SortFlag = QDir__SortFlag(0x40)
	QDir__Type        QDir__SortFlag = QDir__SortFlag(0x80)
	QDir__NoSort      QDir__SortFlag = QDir__SortFlag(-1)
)

func NewQDir(dir QDir_ITF) *QDir {
	tmpValue := NewQDirFromPointer(C.QDir_NewQDir(PointerFromQDir(dir)))
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func NewQDir2(path string) *QDir {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	tmpValue := NewQDirFromPointer(C.QDir_NewQDir2(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))}))
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func NewQDir3(path string, nameFilter string, sort QDir__SortFlag, filters QDir__Filter) *QDir {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	var nameFilterC *C.char
	if nameFilter != "" {
		nameFilterC = C.CString(nameFilter)
		defer C.free(unsafe.Pointer(nameFilterC))
	}
	tmpValue := NewQDirFromPointer(C.QDir_NewQDir3(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))}, C.struct_QtCore_PackedString{data: nameFilterC, len: C.longlong(len(nameFilter))}, C.longlong(sort), C.longlong(filters)))
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func (ptr *QDir) AbsoluteFilePath(fileName string) string {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		return cGoUnpackString(C.QDir_AbsoluteFilePath(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	}
	return ""
}

func (ptr *QDir) AbsolutePath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDir_AbsolutePath(ptr.Pointer()))
	}
	return ""
}

func QDir_AddSearchPath(prefix string, path string) {
	var prefixC *C.char
	if prefix != "" {
		prefixC = C.CString(prefix)
		defer C.free(unsafe.Pointer(prefixC))
	}
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	C.QDir_QDir_AddSearchPath(C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))}, C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
}

func (ptr *QDir) AddSearchPath(prefix string, path string) {
	var prefixC *C.char
	if prefix != "" {
		prefixC = C.CString(prefix)
		defer C.free(unsafe.Pointer(prefixC))
	}
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	C.QDir_QDir_AddSearchPath(C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))}, C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
}

func (ptr *QDir) CanonicalPath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDir_CanonicalPath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDir) Cd(dirName string) bool {
	if ptr.Pointer() != nil {
		var dirNameC *C.char
		if dirName != "" {
			dirNameC = C.CString(dirName)
			defer C.free(unsafe.Pointer(dirNameC))
		}
		return int8(C.QDir_Cd(ptr.Pointer(), C.struct_QtCore_PackedString{data: dirNameC, len: C.longlong(len(dirName))})) != 0
	}
	return false
}

func (ptr *QDir) CdUp() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDir_CdUp(ptr.Pointer())) != 0
	}
	return false
}

func QDir_CleanPath(path string) string {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	return cGoUnpackString(C.QDir_QDir_CleanPath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))}))
}

func (ptr *QDir) CleanPath(path string) string {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	return cGoUnpackString(C.QDir_QDir_CleanPath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))}))
}

func (ptr *QDir) Count() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QDir_Count(ptr.Pointer())))
	}
	return 0
}

func QDir_Current() *QDir {
	tmpValue := NewQDirFromPointer(C.QDir_QDir_Current())
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func (ptr *QDir) Current() *QDir {
	tmpValue := NewQDirFromPointer(C.QDir_QDir_Current())
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func QDir_CurrentPath() string {
	return cGoUnpackString(C.QDir_QDir_CurrentPath())
}

func (ptr *QDir) CurrentPath() string {
	return cGoUnpackString(C.QDir_QDir_CurrentPath())
}

func (ptr *QDir) DirName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDir_DirName(ptr.Pointer()))
	}
	return ""
}

func QDir_Drives() []*QFileInfo {
	return func(l C.struct_QtCore_PackedList) []*QFileInfo {
		out := make([]*QFileInfo, int(l.len))
		tmpList := NewQDirFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__drives_atList(i)
		}
		return out
	}(C.QDir_QDir_Drives())
}

func (ptr *QDir) Drives() []*QFileInfo {
	return func(l C.struct_QtCore_PackedList) []*QFileInfo {
		out := make([]*QFileInfo, int(l.len))
		tmpList := NewQDirFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__drives_atList(i)
		}
		return out
	}(C.QDir_QDir_Drives())
}

func (ptr *QDir) EntryInfoList(nameFilters []string, filters QDir__Filter, sort QDir__SortFlag) []*QFileInfo {
	if ptr.Pointer() != nil {
		nameFiltersC := C.CString(strings.Join(nameFilters, "¡¦!"))
		defer C.free(unsafe.Pointer(nameFiltersC))
		return func(l C.struct_QtCore_PackedList) []*QFileInfo {
			out := make([]*QFileInfo, int(l.len))
			tmpList := NewQDirFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__entryInfoList_atList(i)
			}
			return out
		}(C.QDir_EntryInfoList(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameFiltersC, len: C.longlong(len(strings.Join(nameFilters, "¡¦!")))}, C.longlong(filters), C.longlong(sort)))
	}
	return make([]*QFileInfo, 0)
}

func (ptr *QDir) EntryInfoList2(filters QDir__Filter, sort QDir__SortFlag) []*QFileInfo {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QFileInfo {
			out := make([]*QFileInfo, int(l.len))
			tmpList := NewQDirFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__entryInfoList_atList2(i)
			}
			return out
		}(C.QDir_EntryInfoList2(ptr.Pointer(), C.longlong(filters), C.longlong(sort)))
	}
	return make([]*QFileInfo, 0)
}

func (ptr *QDir) EntryList(nameFilters []string, filters QDir__Filter, sort QDir__SortFlag) []string {
	if ptr.Pointer() != nil {
		nameFiltersC := C.CString(strings.Join(nameFilters, "¡¦!"))
		defer C.free(unsafe.Pointer(nameFiltersC))
		return unpackStringList(cGoUnpackString(C.QDir_EntryList(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameFiltersC, len: C.longlong(len(strings.Join(nameFilters, "¡¦!")))}, C.longlong(filters), C.longlong(sort))))
	}
	return make([]string, 0)
}

func (ptr *QDir) EntryList2(filters QDir__Filter, sort QDir__SortFlag) []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QDir_EntryList2(ptr.Pointer(), C.longlong(filters), C.longlong(sort))))
	}
	return make([]string, 0)
}

func (ptr *QDir) Exists(name string) bool {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int8(C.QDir_Exists(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})) != 0
	}
	return false
}

func (ptr *QDir) Exists2() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDir_Exists2(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDir) FilePath(fileName string) string {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		return cGoUnpackString(C.QDir_FilePath(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	}
	return ""
}

func (ptr *QDir) Filter() QDir__Filter {
	if ptr.Pointer() != nil {
		return QDir__Filter(C.QDir_Filter(ptr.Pointer()))
	}
	return 0
}

func QDir_FromNativeSeparators(pathName string) string {
	var pathNameC *C.char
	if pathName != "" {
		pathNameC = C.CString(pathName)
		defer C.free(unsafe.Pointer(pathNameC))
	}
	return cGoUnpackString(C.QDir_QDir_FromNativeSeparators(C.struct_QtCore_PackedString{data: pathNameC, len: C.longlong(len(pathName))}))
}

func (ptr *QDir) FromNativeSeparators(pathName string) string {
	var pathNameC *C.char
	if pathName != "" {
		pathNameC = C.CString(pathName)
		defer C.free(unsafe.Pointer(pathNameC))
	}
	return cGoUnpackString(C.QDir_QDir_FromNativeSeparators(C.struct_QtCore_PackedString{data: pathNameC, len: C.longlong(len(pathName))}))
}

func QDir_Home() *QDir {
	tmpValue := NewQDirFromPointer(C.QDir_QDir_Home())
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func (ptr *QDir) Home() *QDir {
	tmpValue := NewQDirFromPointer(C.QDir_QDir_Home())
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func QDir_HomePath() string {
	return cGoUnpackString(C.QDir_QDir_HomePath())
}

func (ptr *QDir) HomePath() string {
	return cGoUnpackString(C.QDir_QDir_HomePath())
}

func (ptr *QDir) IsAbsolute() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDir_IsAbsolute(ptr.Pointer())) != 0
	}
	return false
}

func QDir_IsAbsolutePath(path string) bool {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	return int8(C.QDir_QDir_IsAbsolutePath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})) != 0
}

func (ptr *QDir) IsAbsolutePath(path string) bool {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	return int8(C.QDir_QDir_IsAbsolutePath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})) != 0
}

func (ptr *QDir) IsEmpty(filters QDir__Filter) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDir_IsEmpty(ptr.Pointer(), C.longlong(filters))) != 0
	}
	return false
}

func (ptr *QDir) IsReadable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDir_IsReadable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDir) IsRelative() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDir_IsRelative(ptr.Pointer())) != 0
	}
	return false
}

func QDir_IsRelativePath(path string) bool {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	return int8(C.QDir_QDir_IsRelativePath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})) != 0
}

func (ptr *QDir) IsRelativePath(path string) bool {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	return int8(C.QDir_QDir_IsRelativePath(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})) != 0
}

func (ptr *QDir) IsRoot() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDir_IsRoot(ptr.Pointer())) != 0
	}
	return false
}

func QDir_ListSeparator() *QChar {
	tmpValue := NewQCharFromPointer(C.QDir_QDir_ListSeparator())
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func (ptr *QDir) ListSeparator() *QChar {
	tmpValue := NewQCharFromPointer(C.QDir_QDir_ListSeparator())
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func (ptr *QDir) MakeAbsolute() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDir_MakeAbsolute(ptr.Pointer())) != 0
	}
	return false
}

func QDir_Match(filter string, fileName string) bool {
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QDir_QDir_Match(C.struct_QtCore_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func (ptr *QDir) Match(filter string, fileName string) bool {
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QDir_QDir_Match(C.struct_QtCore_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func QDir_Match2(filters []string, fileName string) bool {
	filtersC := C.CString(strings.Join(filters, "¡¦!"))
	defer C.free(unsafe.Pointer(filtersC))
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QDir_QDir_Match2(C.struct_QtCore_PackedString{data: filtersC, len: C.longlong(len(strings.Join(filters, "¡¦!")))}, C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func (ptr *QDir) Match2(filters []string, fileName string) bool {
	filtersC := C.CString(strings.Join(filters, "¡¦!"))
	defer C.free(unsafe.Pointer(filtersC))
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QDir_QDir_Match2(C.struct_QtCore_PackedString{data: filtersC, len: C.longlong(len(strings.Join(filters, "¡¦!")))}, C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func (ptr *QDir) Mkdir(dirName string) bool {
	if ptr.Pointer() != nil {
		var dirNameC *C.char
		if dirName != "" {
			dirNameC = C.CString(dirName)
			defer C.free(unsafe.Pointer(dirNameC))
		}
		return int8(C.QDir_Mkdir(ptr.Pointer(), C.struct_QtCore_PackedString{data: dirNameC, len: C.longlong(len(dirName))})) != 0
	}
	return false
}

func (ptr *QDir) Mkpath(dirPath string) bool {
	if ptr.Pointer() != nil {
		var dirPathC *C.char
		if dirPath != "" {
			dirPathC = C.CString(dirPath)
			defer C.free(unsafe.Pointer(dirPathC))
		}
		return int8(C.QDir_Mkpath(ptr.Pointer(), C.struct_QtCore_PackedString{data: dirPathC, len: C.longlong(len(dirPath))})) != 0
	}
	return false
}

func (ptr *QDir) NameFilters() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QDir_NameFilters(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QDir) Path() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDir_Path(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDir) Refresh() {
	if ptr.Pointer() != nil {
		C.QDir_Refresh(ptr.Pointer())
	}
}

func (ptr *QDir) RelativeFilePath(fileName string) string {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		return cGoUnpackString(C.QDir_RelativeFilePath(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	}
	return ""
}

func (ptr *QDir) Remove(fileName string) bool {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		return int8(C.QDir_Remove(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
	}
	return false
}

func (ptr *QDir) RemoveRecursively() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDir_RemoveRecursively(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDir) Rename(oldName string, newName string) bool {
	if ptr.Pointer() != nil {
		var oldNameC *C.char
		if oldName != "" {
			oldNameC = C.CString(oldName)
			defer C.free(unsafe.Pointer(oldNameC))
		}
		var newNameC *C.char
		if newName != "" {
			newNameC = C.CString(newName)
			defer C.free(unsafe.Pointer(newNameC))
		}
		return int8(C.QDir_Rename(ptr.Pointer(), C.struct_QtCore_PackedString{data: oldNameC, len: C.longlong(len(oldName))}, C.struct_QtCore_PackedString{data: newNameC, len: C.longlong(len(newName))})) != 0
	}
	return false
}

func (ptr *QDir) Rmdir(dirName string) bool {
	if ptr.Pointer() != nil {
		var dirNameC *C.char
		if dirName != "" {
			dirNameC = C.CString(dirName)
			defer C.free(unsafe.Pointer(dirNameC))
		}
		return int8(C.QDir_Rmdir(ptr.Pointer(), C.struct_QtCore_PackedString{data: dirNameC, len: C.longlong(len(dirName))})) != 0
	}
	return false
}

func (ptr *QDir) Rmpath(dirPath string) bool {
	if ptr.Pointer() != nil {
		var dirPathC *C.char
		if dirPath != "" {
			dirPathC = C.CString(dirPath)
			defer C.free(unsafe.Pointer(dirPathC))
		}
		return int8(C.QDir_Rmpath(ptr.Pointer(), C.struct_QtCore_PackedString{data: dirPathC, len: C.longlong(len(dirPath))})) != 0
	}
	return false
}

func QDir_Root() *QDir {
	tmpValue := NewQDirFromPointer(C.QDir_QDir_Root())
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func (ptr *QDir) Root() *QDir {
	tmpValue := NewQDirFromPointer(C.QDir_QDir_Root())
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func QDir_RootPath() string {
	return cGoUnpackString(C.QDir_QDir_RootPath())
}

func (ptr *QDir) RootPath() string {
	return cGoUnpackString(C.QDir_QDir_RootPath())
}

func QDir_SearchPaths(prefix string) []string {
	var prefixC *C.char
	if prefix != "" {
		prefixC = C.CString(prefix)
		defer C.free(unsafe.Pointer(prefixC))
	}
	return unpackStringList(cGoUnpackString(C.QDir_QDir_SearchPaths(C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))})))
}

func (ptr *QDir) SearchPaths(prefix string) []string {
	var prefixC *C.char
	if prefix != "" {
		prefixC = C.CString(prefix)
		defer C.free(unsafe.Pointer(prefixC))
	}
	return unpackStringList(cGoUnpackString(C.QDir_QDir_SearchPaths(C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))})))
}

func QDir_Separator() *QChar {
	tmpValue := NewQCharFromPointer(C.QDir_QDir_Separator())
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func (ptr *QDir) Separator() *QChar {
	tmpValue := NewQCharFromPointer(C.QDir_QDir_Separator())
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func QDir_SetCurrent(path string) bool {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	return int8(C.QDir_QDir_SetCurrent(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})) != 0
}

func (ptr *QDir) SetCurrent(path string) bool {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	return int8(C.QDir_QDir_SetCurrent(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})) != 0
}

func (ptr *QDir) SetFilter(filters QDir__Filter) {
	if ptr.Pointer() != nil {
		C.QDir_SetFilter(ptr.Pointer(), C.longlong(filters))
	}
}

func (ptr *QDir) SetNameFilters(nameFilters []string) {
	if ptr.Pointer() != nil {
		nameFiltersC := C.CString(strings.Join(nameFilters, "¡¦!"))
		defer C.free(unsafe.Pointer(nameFiltersC))
		C.QDir_SetNameFilters(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameFiltersC, len: C.longlong(len(strings.Join(nameFilters, "¡¦!")))})
	}
}

func (ptr *QDir) SetPath(path string) {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		C.QDir_SetPath(ptr.Pointer(), C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
	}
}

func QDir_SetSearchPaths(prefix string, searchPaths []string) {
	var prefixC *C.char
	if prefix != "" {
		prefixC = C.CString(prefix)
		defer C.free(unsafe.Pointer(prefixC))
	}
	searchPathsC := C.CString(strings.Join(searchPaths, "¡¦!"))
	defer C.free(unsafe.Pointer(searchPathsC))
	C.QDir_QDir_SetSearchPaths(C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))}, C.struct_QtCore_PackedString{data: searchPathsC, len: C.longlong(len(strings.Join(searchPaths, "¡¦!")))})
}

func (ptr *QDir) SetSearchPaths(prefix string, searchPaths []string) {
	var prefixC *C.char
	if prefix != "" {
		prefixC = C.CString(prefix)
		defer C.free(unsafe.Pointer(prefixC))
	}
	searchPathsC := C.CString(strings.Join(searchPaths, "¡¦!"))
	defer C.free(unsafe.Pointer(searchPathsC))
	C.QDir_QDir_SetSearchPaths(C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))}, C.struct_QtCore_PackedString{data: searchPathsC, len: C.longlong(len(strings.Join(searchPaths, "¡¦!")))})
}

func (ptr *QDir) SetSorting(sort QDir__SortFlag) {
	if ptr.Pointer() != nil {
		C.QDir_SetSorting(ptr.Pointer(), C.longlong(sort))
	}
}

func (ptr *QDir) Sorting() QDir__SortFlag {
	if ptr.Pointer() != nil {
		return QDir__SortFlag(C.QDir_Sorting(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDir) Swap(other QDir_ITF) {
	if ptr.Pointer() != nil {
		C.QDir_Swap(ptr.Pointer(), PointerFromQDir(other))
	}
}

func QDir_Temp() *QDir {
	tmpValue := NewQDirFromPointer(C.QDir_QDir_Temp())
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func (ptr *QDir) Temp() *QDir {
	tmpValue := NewQDirFromPointer(C.QDir_QDir_Temp())
	runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
	return tmpValue
}

func QDir_TempPath() string {
	return cGoUnpackString(C.QDir_QDir_TempPath())
}

func (ptr *QDir) TempPath() string {
	return cGoUnpackString(C.QDir_QDir_TempPath())
}

func QDir_ToNativeSeparators(pathName string) string {
	var pathNameC *C.char
	if pathName != "" {
		pathNameC = C.CString(pathName)
		defer C.free(unsafe.Pointer(pathNameC))
	}
	return cGoUnpackString(C.QDir_QDir_ToNativeSeparators(C.struct_QtCore_PackedString{data: pathNameC, len: C.longlong(len(pathName))}))
}

func (ptr *QDir) ToNativeSeparators(pathName string) string {
	var pathNameC *C.char
	if pathName != "" {
		pathNameC = C.CString(pathName)
		defer C.free(unsafe.Pointer(pathNameC))
	}
	return cGoUnpackString(C.QDir_QDir_ToNativeSeparators(C.struct_QtCore_PackedString{data: pathNameC, len: C.longlong(len(pathName))}))
}

func (ptr *QDir) DestroyQDir() {
	if ptr.Pointer() != nil {
		C.QDir_DestroyQDir(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDir) __drives_atList(i int) *QFileInfo {
	if ptr.Pointer() != nil {
		tmpValue := NewQFileInfoFromPointer(C.QDir___drives_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QFileInfo).DestroyQFileInfo)
		return tmpValue
	}
	return nil
}

func (ptr *QDir) __drives_setList(i QFileInfo_ITF) {
	if ptr.Pointer() != nil {
		C.QDir___drives_setList(ptr.Pointer(), PointerFromQFileInfo(i))
	}
}

func (ptr *QDir) __drives_newList() unsafe.Pointer {
	return C.QDir___drives_newList(ptr.Pointer())
}

func (ptr *QDir) __entryInfoList_atList(i int) *QFileInfo {
	if ptr.Pointer() != nil {
		tmpValue := NewQFileInfoFromPointer(C.QDir___entryInfoList_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QFileInfo).DestroyQFileInfo)
		return tmpValue
	}
	return nil
}

func (ptr *QDir) __entryInfoList_setList(i QFileInfo_ITF) {
	if ptr.Pointer() != nil {
		C.QDir___entryInfoList_setList(ptr.Pointer(), PointerFromQFileInfo(i))
	}
}

func (ptr *QDir) __entryInfoList_newList() unsafe.Pointer {
	return C.QDir___entryInfoList_newList(ptr.Pointer())
}

func (ptr *QDir) __entryInfoList_atList2(i int) *QFileInfo {
	if ptr.Pointer() != nil {
		tmpValue := NewQFileInfoFromPointer(C.QDir___entryInfoList_atList2(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QFileInfo).DestroyQFileInfo)
		return tmpValue
	}
	return nil
}

func (ptr *QDir) __entryInfoList_setList2(i QFileInfo_ITF) {
	if ptr.Pointer() != nil {
		C.QDir___entryInfoList_setList2(ptr.Pointer(), PointerFromQFileInfo(i))
	}
}

func (ptr *QDir) __entryInfoList_newList2() unsafe.Pointer {
	return C.QDir___entryInfoList_newList2(ptr.Pointer())
}

type QDirIterator struct {
	ptr unsafe.Pointer
}

type QDirIterator_ITF interface {
	QDirIterator_PTR() *QDirIterator
}

func (ptr *QDirIterator) QDirIterator_PTR() *QDirIterator {
	return ptr
}

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

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

func PointerFromQDirIterator(ptr QDirIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDirIterator_PTR().Pointer()
	}
	return nil
}

func NewQDirIteratorFromPointer(ptr unsafe.Pointer) (n *QDirIterator) {
	n = new(QDirIterator)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDirIterator__IteratorFlag
//QDirIterator::IteratorFlag
type QDirIterator__IteratorFlag int64

const (
	QDirIterator__NoIteratorFlags QDirIterator__IteratorFlag = QDirIterator__IteratorFlag(0x0)
	QDirIterator__FollowSymlinks  QDirIterator__IteratorFlag = QDirIterator__IteratorFlag(0x1)
	QDirIterator__Subdirectories  QDirIterator__IteratorFlag = QDirIterator__IteratorFlag(0x2)
)

type QDynamicPropertyChangeEvent struct {
	QEvent
}

type QDynamicPropertyChangeEvent_ITF interface {
	QEvent_ITF
	QDynamicPropertyChangeEvent_PTR() *QDynamicPropertyChangeEvent
}

func (ptr *QDynamicPropertyChangeEvent) QDynamicPropertyChangeEvent_PTR() *QDynamicPropertyChangeEvent {
	return ptr
}

func (ptr *QDynamicPropertyChangeEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QEvent_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQDynamicPropertyChangeEvent(ptr QDynamicPropertyChangeEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDynamicPropertyChangeEvent_PTR().Pointer()
	}
	return nil
}

func NewQDynamicPropertyChangeEventFromPointer(ptr unsafe.Pointer) (n *QDynamicPropertyChangeEvent) {
	n = new(QDynamicPropertyChangeEvent)
	n.SetPointer(ptr)
	return
}

func (ptr *QDynamicPropertyChangeEvent) DestroyQDynamicPropertyChangeEvent() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(ptr.Pointer(), "")
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQDynamicPropertyChangeEvent(name QByteArray_ITF) *QDynamicPropertyChangeEvent {
	tmpValue := NewQDynamicPropertyChangeEventFromPointer(C.QDynamicPropertyChangeEvent_NewQDynamicPropertyChangeEvent(PointerFromQByteArray(name)))
	runtime.SetFinalizer(tmpValue, (*QDynamicPropertyChangeEvent).DestroyQDynamicPropertyChangeEvent)
	return tmpValue
}

func (ptr *QDynamicPropertyChangeEvent) PropertyName() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QDynamicPropertyChangeEvent_PropertyName(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

type QEasingCurve struct {
	ptr unsafe.Pointer
}

type QEasingCurve_ITF interface {
	QEasingCurve_PTR() *QEasingCurve
}

func (ptr *QEasingCurve) QEasingCurve_PTR() *QEasingCurve {
	return ptr
}

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

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

func PointerFromQEasingCurve(ptr QEasingCurve_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEasingCurve_PTR().Pointer()
	}
	return nil
}

func NewQEasingCurveFromPointer(ptr unsafe.Pointer) (n *QEasingCurve) {
	n = new(QEasingCurve)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QEasingCurve__Type
//QEasingCurve::Type
type QEasingCurve__Type int64

const (
	QEasingCurve__Linear       QEasingCurve__Type = QEasingCurve__Type(0)
	QEasingCurve__InQuad       QEasingCurve__Type = QEasingCurve__Type(1)
	QEasingCurve__OutQuad      QEasingCurve__Type = QEasingCurve__Type(2)
	QEasingCurve__InOutQuad    QEasingCurve__Type = QEasingCurve__Type(3)
	QEasingCurve__OutInQuad    QEasingCurve__Type = QEasingCurve__Type(4)
	QEasingCurve__InCubic      QEasingCurve__Type = QEasingCurve__Type(5)
	QEasingCurve__OutCubic     QEasingCurve__Type = QEasingCurve__Type(6)
	QEasingCurve__InOutCubic   QEasingCurve__Type = QEasingCurve__Type(7)
	QEasingCurve__OutInCubic   QEasingCurve__Type = QEasingCurve__Type(8)
	QEasingCurve__InQuart      QEasingCurve__Type = QEasingCurve__Type(9)
	QEasingCurve__OutQuart     QEasingCurve__Type = QEasingCurve__Type(10)
	QEasingCurve__InOutQuart   QEasingCurve__Type = QEasingCurve__Type(11)
	QEasingCurve__OutInQuart   QEasingCurve__Type = QEasingCurve__Type(12)
	QEasingCurve__InQuint      QEasingCurve__Type = QEasingCurve__Type(13)
	QEasingCurve__OutQuint     QEasingCurve__Type = QEasingCurve__Type(14)
	QEasingCurve__InOutQuint   QEasingCurve__Type = QEasingCurve__Type(15)
	QEasingCurve__OutInQuint   QEasingCurve__Type = QEasingCurve__Type(16)
	QEasingCurve__InSine       QEasingCurve__Type = QEasingCurve__Type(17)
	QEasingCurve__OutSine      QEasingCurve__Type = QEasingCurve__Type(18)
	QEasingCurve__InOutSine    QEasingCurve__Type = QEasingCurve__Type(19)
	QEasingCurve__OutInSine    QEasingCurve__Type = QEasingCurve__Type(20)
	QEasingCurve__InExpo       QEasingCurve__Type = QEasingCurve__Type(21)
	QEasingCurve__OutExpo      QEasingCurve__Type = QEasingCurve__Type(22)
	QEasingCurve__InOutExpo    QEasingCurve__Type = QEasingCurve__Type(23)
	QEasingCurve__OutInExpo    QEasingCurve__Type = QEasingCurve__Type(24)
	QEasingCurve__InCirc       QEasingCurve__Type = QEasingCurve__Type(25)
	QEasingCurve__OutCirc      QEasingCurve__Type = QEasingCurve__Type(26)
	QEasingCurve__InOutCirc    QEasingCurve__Type = QEasingCurve__Type(27)
	QEasingCurve__OutInCirc    QEasingCurve__Type = QEasingCurve__Type(28)
	QEasingCurve__InElastic    QEasingCurve__Type = QEasingCurve__Type(29)
	QEasingCurve__OutElastic   QEasingCurve__Type = QEasingCurve__Type(30)
	QEasingCurve__InOutElastic QEasingCurve__Type = QEasingCurve__Type(31)
	QEasingCurve__OutInElastic QEasingCurve__Type = QEasingCurve__Type(32)
	QEasingCurve__InBack       QEasingCurve__Type = QEasingCurve__Type(33)
	QEasingCurve__OutBack      QEasingCurve__Type = QEasingCurve__Type(34)
	QEasingCurve__InOutBack    QEasingCurve__Type = QEasingCurve__Type(35)
	QEasingCurve__OutInBack    QEasingCurve__Type = QEasingCurve__Type(36)
	QEasingCurve__InBounce     QEasingCurve__Type = QEasingCurve__Type(37)
	QEasingCurve__OutBounce    QEasingCurve__Type = QEasingCurve__Type(38)
	QEasingCurve__InOutBounce  QEasingCurve__Type = QEasingCurve__Type(39)
	QEasingCurve__OutInBounce  QEasingCurve__Type = QEasingCurve__Type(40)
	QEasingCurve__InCurve      QEasingCurve__Type = QEasingCurve__Type(41)
	QEasingCurve__OutCurve     QEasingCurve__Type = QEasingCurve__Type(42)
	QEasingCurve__SineCurve    QEasingCurve__Type = QEasingCurve__Type(43)
	QEasingCurve__CosineCurve  QEasingCurve__Type = QEasingCurve__Type(44)
	QEasingCurve__BezierSpline QEasingCurve__Type = QEasingCurve__Type(45)
	QEasingCurve__TCBSpline    QEasingCurve__Type = QEasingCurve__Type(46)
	QEasingCurve__Custom       QEasingCurve__Type = QEasingCurve__Type(47)
	QEasingCurve__NCurveTypes  QEasingCurve__Type = QEasingCurve__Type(48)
)

func NewQEasingCurve(ty QEasingCurve__Type) *QEasingCurve {
	tmpValue := NewQEasingCurveFromPointer(C.QEasingCurve_NewQEasingCurve(C.longlong(ty)))
	runtime.SetFinalizer(tmpValue, (*QEasingCurve).DestroyQEasingCurve)
	return tmpValue
}

func NewQEasingCurve2(other QEasingCurve_ITF) *QEasingCurve {
	tmpValue := NewQEasingCurveFromPointer(C.QEasingCurve_NewQEasingCurve2(PointerFromQEasingCurve(other)))
	runtime.SetFinalizer(tmpValue, (*QEasingCurve).DestroyQEasingCurve)
	return tmpValue
}

func NewQEasingCurve3(other QEasingCurve_ITF) *QEasingCurve {
	tmpValue := NewQEasingCurveFromPointer(C.QEasingCurve_NewQEasingCurve3(PointerFromQEasingCurve(other)))
	runtime.SetFinalizer(tmpValue, (*QEasingCurve).DestroyQEasingCurve)
	return tmpValue
}

func (ptr *QEasingCurve) AddCubicBezierSegment(c1 QPointF_ITF, c2 QPointF_ITF, endPoint QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QEasingCurve_AddCubicBezierSegment(ptr.Pointer(), PointerFromQPointF(c1), PointerFromQPointF(c2), PointerFromQPointF(endPoint))
	}
}

func (ptr *QEasingCurve) AddTCBSegment(nextPoint QPointF_ITF, t float64, c float64, b float64) {
	if ptr.Pointer() != nil {
		C.QEasingCurve_AddTCBSegment(ptr.Pointer(), PointerFromQPointF(nextPoint), C.double(t), C.double(c), C.double(b))
	}
}

func (ptr *QEasingCurve) Amplitude() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QEasingCurve_Amplitude(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEasingCurve) Overshoot() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QEasingCurve_Overshoot(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEasingCurve) Period() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QEasingCurve_Period(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEasingCurve) SetAmplitude(amplitude float64) {
	if ptr.Pointer() != nil {
		C.QEasingCurve_SetAmplitude(ptr.Pointer(), C.double(amplitude))
	}
}

func (ptr *QEasingCurve) SetOvershoot(overshoot float64) {
	if ptr.Pointer() != nil {
		C.QEasingCurve_SetOvershoot(ptr.Pointer(), C.double(overshoot))
	}
}

func (ptr *QEasingCurve) SetPeriod(period float64) {
	if ptr.Pointer() != nil {
		C.QEasingCurve_SetPeriod(ptr.Pointer(), C.double(period))
	}
}

func (ptr *QEasingCurve) SetType(ty QEasingCurve__Type) {
	if ptr.Pointer() != nil {
		C.QEasingCurve_SetType(ptr.Pointer(), C.longlong(ty))
	}
}

func (ptr *QEasingCurve) Swap(other QEasingCurve_ITF) {
	if ptr.Pointer() != nil {
		C.QEasingCurve_Swap(ptr.Pointer(), PointerFromQEasingCurve(other))
	}
}

func (ptr *QEasingCurve) ToCubicSpline() []*QPointF {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QPointF {
			out := make([]*QPointF, int(l.len))
			tmpList := NewQEasingCurveFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__toCubicSpline_atList(i)
			}
			return out
		}(C.QEasingCurve_ToCubicSpline(ptr.Pointer()))
	}
	return make([]*QPointF, 0)
}

func (ptr *QEasingCurve) Type() QEasingCurve__Type {
	if ptr.Pointer() != nil {
		return QEasingCurve__Type(C.QEasingCurve_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEasingCurve) ValueForProgress(progress float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QEasingCurve_ValueForProgress(ptr.Pointer(), C.double(progress)))
	}
	return 0
}

func (ptr *QEasingCurve) DestroyQEasingCurve() {
	if ptr.Pointer() != nil {
		C.QEasingCurve_DestroyQEasingCurve(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QEasingCurve) __cubicBezierSpline_atList(i int) *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QEasingCurve___cubicBezierSpline_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QEasingCurve) __cubicBezierSpline_setList(i QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QEasingCurve___cubicBezierSpline_setList(ptr.Pointer(), PointerFromQPointF(i))
	}
}

func (ptr *QEasingCurve) __cubicBezierSpline_newList() unsafe.Pointer {
	return C.QEasingCurve___cubicBezierSpline_newList(ptr.Pointer())
}

func (ptr *QEasingCurve) __toCubicSpline_atList(i int) *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QEasingCurve___toCubicSpline_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QEasingCurve) __toCubicSpline_setList(i QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QEasingCurve___toCubicSpline_setList(ptr.Pointer(), PointerFromQPointF(i))
	}
}

func (ptr *QEasingCurve) __toCubicSpline_newList() unsafe.Pointer {
	return C.QEasingCurve___toCubicSpline_newList(ptr.Pointer())
}

type QElapsedTimer struct {
	ptr unsafe.Pointer
}

type QElapsedTimer_ITF interface {
	QElapsedTimer_PTR() *QElapsedTimer
}

func (ptr *QElapsedTimer) QElapsedTimer_PTR() *QElapsedTimer {
	return ptr
}

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

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

func PointerFromQElapsedTimer(ptr QElapsedTimer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QElapsedTimer_PTR().Pointer()
	}
	return nil
}

func NewQElapsedTimerFromPointer(ptr unsafe.Pointer) (n *QElapsedTimer) {
	n = new(QElapsedTimer)
	n.SetPointer(ptr)
	return
}

func (ptr *QElapsedTimer) DestroyQElapsedTimer() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QElapsedTimer__ClockType
//QElapsedTimer::ClockType
type QElapsedTimer__ClockType int64

const (
	QElapsedTimer__SystemTime         QElapsedTimer__ClockType = QElapsedTimer__ClockType(0)
	QElapsedTimer__MonotonicClock     QElapsedTimer__ClockType = QElapsedTimer__ClockType(1)
	QElapsedTimer__TickCounter        QElapsedTimer__ClockType = QElapsedTimer__ClockType(2)
	QElapsedTimer__MachAbsoluteTime   QElapsedTimer__ClockType = QElapsedTimer__ClockType(3)
	QElapsedTimer__PerformanceCounter QElapsedTimer__ClockType = QElapsedTimer__ClockType(4)
)

func NewQElapsedTimer() *QElapsedTimer {
	tmpValue := NewQElapsedTimerFromPointer(C.QElapsedTimer_NewQElapsedTimer())
	runtime.SetFinalizer(tmpValue, (*QElapsedTimer).DestroyQElapsedTimer)
	return tmpValue
}

func QElapsedTimer_ClockType() QElapsedTimer__ClockType {
	return QElapsedTimer__ClockType(C.QElapsedTimer_QElapsedTimer_ClockType())
}

func (ptr *QElapsedTimer) ClockType() QElapsedTimer__ClockType {
	return QElapsedTimer__ClockType(C.QElapsedTimer_QElapsedTimer_ClockType())
}

func (ptr *QElapsedTimer) Elapsed() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_Elapsed(ptr.Pointer()))
	}
	return 0
}

func (ptr *QElapsedTimer) HasExpired(timeout int64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QElapsedTimer_HasExpired(ptr.Pointer(), C.longlong(timeout))) != 0
	}
	return false
}

func (ptr *QElapsedTimer) Invalidate() {
	if ptr.Pointer() != nil {
		C.QElapsedTimer_Invalidate(ptr.Pointer())
	}
}

func QElapsedTimer_IsMonotonic() bool {
	return int8(C.QElapsedTimer_QElapsedTimer_IsMonotonic()) != 0
}

func (ptr *QElapsedTimer) IsMonotonic() bool {
	return int8(C.QElapsedTimer_QElapsedTimer_IsMonotonic()) != 0
}

func (ptr *QElapsedTimer) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QElapsedTimer_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QElapsedTimer) MsecsSinceReference() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_MsecsSinceReference(ptr.Pointer()))
	}
	return 0
}

func (ptr *QElapsedTimer) MsecsTo(other QElapsedTimer_ITF) int64 {
	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_MsecsTo(ptr.Pointer(), PointerFromQElapsedTimer(other)))
	}
	return 0
}

func (ptr *QElapsedTimer) NsecsElapsed() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_NsecsElapsed(ptr.Pointer()))
	}
	return 0
}

func (ptr *QElapsedTimer) Restart() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_Restart(ptr.Pointer()))
	}
	return 0
}

func (ptr *QElapsedTimer) SecsTo(other QElapsedTimer_ITF) int64 {
	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_SecsTo(ptr.Pointer(), PointerFromQElapsedTimer(other)))
	}
	return 0
}

func (ptr *QElapsedTimer) Start() {
	if ptr.Pointer() != nil {
		C.QElapsedTimer_Start(ptr.Pointer())
	}
}

type QEnableSharedFromThis struct {
	ptr unsafe.Pointer
}

type QEnableSharedFromThis_ITF interface {
	QEnableSharedFromThis_PTR() *QEnableSharedFromThis
}

func (ptr *QEnableSharedFromThis) QEnableSharedFromThis_PTR() *QEnableSharedFromThis {
	return ptr
}

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

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

func PointerFromQEnableSharedFromThis(ptr QEnableSharedFromThis_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEnableSharedFromThis_PTR().Pointer()
	}
	return nil
}

func NewQEnableSharedFromThisFromPointer(ptr unsafe.Pointer) (n *QEnableSharedFromThis) {
	n = new(QEnableSharedFromThis)
	n.SetPointer(ptr)
	return
}

func (ptr *QEnableSharedFromThis) DestroyQEnableSharedFromThis() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QEvent struct {
	ptr unsafe.Pointer
}

type QEvent_ITF interface {
	QEvent_PTR() *QEvent
}

func (ptr *QEvent) QEvent_PTR() *QEvent {
	return ptr
}

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

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

func PointerFromQEvent(ptr QEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEvent_PTR().Pointer()
	}
	return nil
}

func NewQEventFromPointer(ptr unsafe.Pointer) (n *QEvent) {
	n = new(QEvent)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QEvent__Type
//QEvent::Type
type QEvent__Type int64

const (
	QEvent__None                             QEvent__Type = QEvent__Type(0)
	QEvent__Timer                            QEvent__Type = QEvent__Type(1)
	QEvent__MouseButtonPress                 QEvent__Type = QEvent__Type(2)
	QEvent__MouseButtonRelease               QEvent__Type = QEvent__Type(3)
	QEvent__MouseButtonDblClick              QEvent__Type = QEvent__Type(4)
	QEvent__MouseMove                        QEvent__Type = QEvent__Type(5)
	QEvent__KeyPress                         QEvent__Type = QEvent__Type(6)
	QEvent__KeyRelease                       QEvent__Type = QEvent__Type(7)
	QEvent__FocusIn                          QEvent__Type = QEvent__Type(8)
	QEvent__FocusOut                         QEvent__Type = QEvent__Type(9)
	QEvent__FocusAboutToChange               QEvent__Type = QEvent__Type(23)
	QEvent__Enter                            QEvent__Type = QEvent__Type(10)
	QEvent__Leave                            QEvent__Type = QEvent__Type(11)
	QEvent__Paint                            QEvent__Type = QEvent__Type(12)
	QEvent__Move                             QEvent__Type = QEvent__Type(13)
	QEvent__Resize                           QEvent__Type = QEvent__Type(14)
	QEvent__Create                           QEvent__Type = QEvent__Type(15)
	QEvent__Destroy                          QEvent__Type = QEvent__Type(16)
	QEvent__Show                             QEvent__Type = QEvent__Type(17)
	QEvent__Hide                             QEvent__Type = QEvent__Type(18)
	QEvent__Close                            QEvent__Type = QEvent__Type(19)
	QEvent__Quit                             QEvent__Type = QEvent__Type(20)
	QEvent__ParentChange                     QEvent__Type = QEvent__Type(21)
	QEvent__ParentAboutToChange              QEvent__Type = QEvent__Type(131)
	QEvent__ThreadChange                     QEvent__Type = QEvent__Type(22)
	QEvent__WindowActivate                   QEvent__Type = QEvent__Type(24)
	QEvent__WindowDeactivate                 QEvent__Type = QEvent__Type(25)
	QEvent__ShowToParent                     QEvent__Type = QEvent__Type(26)
	QEvent__HideToParent                     QEvent__Type = QEvent__Type(27)
	QEvent__Wheel                            QEvent__Type = QEvent__Type(31)
	QEvent__WindowTitleChange                QEvent__Type = QEvent__Type(33)
	QEvent__WindowIconChange                 QEvent__Type = QEvent__Type(34)
	QEvent__ApplicationWindowIconChange      QEvent__Type = QEvent__Type(35)
	QEvent__ApplicationFontChange            QEvent__Type = QEvent__Type(36)
	QEvent__ApplicationLayoutDirectionChange QEvent__Type = QEvent__Type(37)
	QEvent__ApplicationPaletteChange         QEvent__Type = QEvent__Type(38)
	QEvent__PaletteChange                    QEvent__Type = QEvent__Type(39)
	QEvent__Clipboard                        QEvent__Type = QEvent__Type(40)
	QEvent__Speech                           QEvent__Type = QEvent__Type(42)
	QEvent__MetaCall                         QEvent__Type = QEvent__Type(43)
	QEvent__SockAct                          QEvent__Type = QEvent__Type(50)
	QEvent__WinEventAct                      QEvent__Type = QEvent__Type(132)
	QEvent__DeferredDelete                   QEvent__Type = QEvent__Type(52)
	QEvent__DragEnter                        QEvent__Type = QEvent__Type(60)
	QEvent__DragMove                         QEvent__Type = QEvent__Type(61)
	QEvent__DragLeave                        QEvent__Type = QEvent__Type(62)
	QEvent__Drop                             QEvent__Type = QEvent__Type(63)
	QEvent__DragResponse                     QEvent__Type = QEvent__Type(64)
	QEvent__ChildAdded                       QEvent__Type = QEvent__Type(68)
	QEvent__ChildPolished                    QEvent__Type = QEvent__Type(69)
	QEvent__ChildRemoved                     QEvent__Type = QEvent__Type(71)
	QEvent__ShowWindowRequest                QEvent__Type = QEvent__Type(73)
	QEvent__PolishRequest                    QEvent__Type = QEvent__Type(74)
	QEvent__Polish                           QEvent__Type = QEvent__Type(75)
	QEvent__LayoutRequest                    QEvent__Type = QEvent__Type(76)
	QEvent__UpdateRequest                    QEvent__Type = QEvent__Type(77)
	QEvent__UpdateLater                      QEvent__Type = QEvent__Type(78)
	QEvent__EmbeddingControl                 QEvent__Type = QEvent__Type(79)
	QEvent__ActivateControl                  QEvent__Type = QEvent__Type(80)
	QEvent__DeactivateControl                QEvent__Type = QEvent__Type(81)
	QEvent__ContextMenu                      QEvent__Type = QEvent__Type(82)
	QEvent__InputMethod                      QEvent__Type = QEvent__Type(83)
	QEvent__TabletMove                       QEvent__Type = QEvent__Type(87)
	QEvent__LocaleChange                     QEvent__Type = QEvent__Type(88)
	QEvent__LanguageChange                   QEvent__Type = QEvent__Type(89)
	QEvent__LayoutDirectionChange            QEvent__Type = QEvent__Type(90)
	QEvent__Style                            QEvent__Type = QEvent__Type(91)
	QEvent__TabletPress                      QEvent__Type = QEvent__Type(92)
	QEvent__TabletRelease                    QEvent__Type = QEvent__Type(93)
	QEvent__OkRequest                        QEvent__Type = QEvent__Type(94)
	QEvent__HelpRequest                      QEvent__Type = QEvent__Type(95)
	QEvent__IconDrag                         QEvent__Type = QEvent__Type(96)
	QEvent__FontChange                       QEvent__Type = QEvent__Type(97)
	QEvent__EnabledChange                    QEvent__Type = QEvent__Type(98)
	QEvent__ActivationChange                 QEvent__Type = QEvent__Type(99)
	QEvent__StyleChange                      QEvent__Type = QEvent__Type(100)
	QEvent__IconTextChange                   QEvent__Type = QEvent__Type(101)
	QEvent__ModifiedChange                   QEvent__Type = QEvent__Type(102)
	QEvent__MouseTrackingChange              QEvent__Type = QEvent__Type(109)
	QEvent__WindowBlocked                    QEvent__Type = QEvent__Type(103)
	QEvent__WindowUnblocked                  QEvent__Type = QEvent__Type(104)
	QEvent__WindowStateChange                QEvent__Type = QEvent__Type(105)
	QEvent__ReadOnlyChange                   QEvent__Type = QEvent__Type(106)
	QEvent__ToolTip                          QEvent__Type = QEvent__Type(110)
	QEvent__WhatsThis                        QEvent__Type = QEvent__Type(111)
	QEvent__StatusTip                        QEvent__Type = QEvent__Type(112)
	QEvent__ActionChanged                    QEvent__Type = QEvent__Type(113)
	QEvent__ActionAdded                      QEvent__Type = QEvent__Type(114)
	QEvent__ActionRemoved                    QEvent__Type = QEvent__Type(115)
	QEvent__FileOpen                         QEvent__Type = QEvent__Type(116)
	QEvent__Shortcut                         QEvent__Type = QEvent__Type(117)
	QEvent__ShortcutOverride                 QEvent__Type = QEvent__Type(51)
	QEvent__WhatsThisClicked                 QEvent__Type = QEvent__Type(118)
	QEvent__ToolBarChange                    QEvent__Type = QEvent__Type(120)
	QEvent__ApplicationActivate              QEvent__Type = QEvent__Type(121)
	QEvent__ApplicationActivated             QEvent__Type = QEvent__Type(QEvent__ApplicationActivate)
	QEvent__ApplicationDeactivate            QEvent__Type = QEvent__Type(122)
	QEvent__ApplicationDeactivated           QEvent__Type = QEvent__Type(QEvent__ApplicationDeactivate)
	QEvent__QueryWhatsThis                   QEvent__Type = QEvent__Type(123)
	QEvent__EnterWhatsThisMode               QEvent__Type = QEvent__Type(124)
	QEvent__LeaveWhatsThisMode               QEvent__Type = QEvent__Type(125)
	QEvent__ZOrderChange                     QEvent__Type = QEvent__Type(126)
	QEvent__HoverEnter                       QEvent__Type = QEvent__Type(127)
	QEvent__HoverLeave                       QEvent__Type = QEvent__Type(128)
	QEvent__HoverMove                        QEvent__Type = QEvent__Type(129)
	QEvent__EnterEditFocus                   QEvent__Type = QEvent__Type(150)
	QEvent__LeaveEditFocus                   QEvent__Type = QEvent__Type(151)
	QEvent__AcceptDropsChange                QEvent__Type = QEvent__Type(152)
	QEvent__ZeroTimerEvent                   QEvent__Type = QEvent__Type(154)
	QEvent__GraphicsSceneMouseMove           QEvent__Type = QEvent__Type(155)
	QEvent__GraphicsSceneMousePress          QEvent__Type = QEvent__Type(156)
	QEvent__GraphicsSceneMouseRelease        QEvent__Type = QEvent__Type(157)
	QEvent__GraphicsSceneMouseDoubleClick    QEvent__Type = QEvent__Type(158)
	QEvent__GraphicsSceneContextMenu         QEvent__Type = QEvent__Type(159)
	QEvent__GraphicsSceneHoverEnter          QEvent__Type = QEvent__Type(160)
	QEvent__GraphicsSceneHoverMove           QEvent__Type = QEvent__Type(161)
	QEvent__GraphicsSceneHoverLeave          QEvent__Type = QEvent__Type(162)
	QEvent__GraphicsSceneHelp                QEvent__Type = QEvent__Type(163)
	QEvent__GraphicsSceneDragEnter           QEvent__Type = QEvent__Type(164)
	QEvent__GraphicsSceneDragMove            QEvent__Type = QEvent__Type(165)
	QEvent__GraphicsSceneDragLeave           QEvent__Type = QEvent__Type(166)
	QEvent__GraphicsSceneDrop                QEvent__Type = QEvent__Type(167)
	QEvent__GraphicsSceneWheel               QEvent__Type = QEvent__Type(168)
	QEvent__KeyboardLayoutChange             QEvent__Type = QEvent__Type(169)
	QEvent__DynamicPropertyChange            QEvent__Type = QEvent__Type(170)
	QEvent__TabletEnterProximity             QEvent__Type = QEvent__Type(171)
	QEvent__TabletLeaveProximity             QEvent__Type = QEvent__Type(172)
	QEvent__NonClientAreaMouseMove           QEvent__Type = QEvent__Type(173)
	QEvent__NonClientAreaMouseButtonPress    QEvent__Type = QEvent__Type(174)
	QEvent__NonClientAreaMouseButtonRelease  QEvent__Type = QEvent__Type(175)
	QEvent__NonClientAreaMouseButtonDblClick QEvent__Type = QEvent__Type(176)
	QEvent__MacSizeChange                    QEvent__Type = QEvent__Type(177)
	QEvent__ContentsRectChange               QEvent__Type = QEvent__Type(178)
	QEvent__MacGLWindowChange                QEvent__Type = QEvent__Type(179)
	QEvent__FutureCallOut                    QEvent__Type = QEvent__Type(180)
	QEvent__GraphicsSceneResize              QEvent__Type = QEvent__Type(181)
	QEvent__GraphicsSceneMove                QEvent__Type = QEvent__Type(182)
	QEvent__CursorChange                     QEvent__Type = QEvent__Type(183)
	QEvent__ToolTipChange                    QEvent__Type = QEvent__Type(184)
	QEvent__NetworkReplyUpdated              QEvent__Type = QEvent__Type(185)
	QEvent__GrabMouse                        QEvent__Type = QEvent__Type(186)
	QEvent__UngrabMouse                      QEvent__Type = QEvent__Type(187)
	QEvent__GrabKeyboard                     QEvent__Type = QEvent__Type(188)
	QEvent__UngrabKeyboard                   QEvent__Type = QEvent__Type(189)
	QEvent__MacGLClearDrawable               QEvent__Type = QEvent__Type(191)
	QEvent__StateMachineSignal               QEvent__Type = QEvent__Type(192)
	QEvent__StateMachineWrapped              QEvent__Type = QEvent__Type(193)
	QEvent__TouchBegin                       QEvent__Type = QEvent__Type(194)
	QEvent__TouchUpdate                      QEvent__Type = QEvent__Type(195)
	QEvent__TouchEnd                         QEvent__Type = QEvent__Type(196)
	QEvent__NativeGesture                    QEvent__Type = QEvent__Type(197)
	QEvent__RequestSoftwareInputPanel        QEvent__Type = QEvent__Type(199)
	QEvent__CloseSoftwareInputPanel          QEvent__Type = QEvent__Type(200)
	QEvent__WinIdChange                      QEvent__Type = QEvent__Type(203)
	QEvent__Gesture                          QEvent__Type = QEvent__Type(198)
	QEvent__GestureOverride                  QEvent__Type = QEvent__Type(202)
	QEvent__ScrollPrepare                    QEvent__Type = QEvent__Type(204)
	QEvent__Scroll                           QEvent__Type = QEvent__Type(205)
	QEvent__Expose                           QEvent__Type = QEvent__Type(206)
	QEvent__InputMethodQuery                 QEvent__Type = QEvent__Type(207)
	QEvent__OrientationChange                QEvent__Type = QEvent__Type(208)
	QEvent__TouchCancel                      QEvent__Type = QEvent__Type(209)
	QEvent__ThemeChange                      QEvent__Type = QEvent__Type(210)
	QEvent__SockClose                        QEvent__Type = QEvent__Type(211)
	QEvent__PlatformPanel                    QEvent__Type = QEvent__Type(212)
	QEvent__StyleAnimationUpdate             QEvent__Type = QEvent__Type(213)
	QEvent__ApplicationStateChange           QEvent__Type = QEvent__Type(214)
	QEvent__WindowChangeInternal             QEvent__Type = QEvent__Type(215)
	QEvent__ScreenChangeInternal             QEvent__Type = QEvent__Type(216)
	QEvent__PlatformSurface                  QEvent__Type = QEvent__Type(217)
	QEvent__Pointer                          QEvent__Type = QEvent__Type(218)
	QEvent__TabletTrackingChange             QEvent__Type = QEvent__Type(219)
	QEvent__User                             QEvent__Type = QEvent__Type(1000)
	QEvent__MaxUser                          QEvent__Type = QEvent__Type(65535)
)

func NewQEvent(ty QEvent__Type) *QEvent {
	tmpValue := NewQEventFromPointer(C.QEvent_NewQEvent(C.longlong(ty)))
	runtime.SetFinalizer(tmpValue, (*QEvent).DestroyQEvent)
	return tmpValue
}

func (ptr *QEvent) Accept() {
	if ptr.Pointer() != nil {
		C.QEvent_Accept(ptr.Pointer())
	}
}

func (ptr *QEvent) Ignore() {
	if ptr.Pointer() != nil {
		C.QEvent_Ignore(ptr.Pointer())
	}
}

func (ptr *QEvent) IsAccepted() bool {
	if ptr.Pointer() != nil {
		return int8(C.QEvent_IsAccepted(ptr.Pointer())) != 0
	}
	return false
}

func QEvent_RegisterEventType(hint int) int {
	return int(int32(C.QEvent_QEvent_RegisterEventType(C.int(int32(hint)))))
}

func (ptr *QEvent) RegisterEventType(hint int) int {
	return int(int32(C.QEvent_QEvent_RegisterEventType(C.int(int32(hint)))))
}

func (ptr *QEvent) SetAccepted(accepted bool) {
	if ptr.Pointer() != nil {
		C.QEvent_SetAccepted(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(accepted))))
	}
}

func (ptr *QEvent) Spontaneous() bool {
	if ptr.Pointer() != nil {
		return int8(C.QEvent_Spontaneous(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QEvent) Type() QEvent__Type {
	if ptr.Pointer() != nil {
		return QEvent__Type(C.QEvent_Type(ptr.Pointer()))
	}
	return 0
}

//export callbackQEvent_DestroyQEvent
func callbackQEvent_DestroyQEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQEventFromPointer(ptr).DestroyQEventDefault()
	}
}

func (ptr *QEvent) ConnectDestroyQEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QEvent) DisconnectDestroyQEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QEvent")
	}
}

func (ptr *QEvent) DestroyQEvent() {
	if ptr.Pointer() != nil {
		C.QEvent_DestroyQEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QEvent) DestroyQEventDefault() {
	if ptr.Pointer() != nil {
		C.QEvent_DestroyQEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QEventLoop struct {
	QObject
}

type QEventLoop_ITF interface {
	QObject_ITF
	QEventLoop_PTR() *QEventLoop
}

func (ptr *QEventLoop) QEventLoop_PTR() *QEventLoop {
	return ptr
}

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

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

func PointerFromQEventLoop(ptr QEventLoop_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEventLoop_PTR().Pointer()
	}
	return nil
}

func NewQEventLoopFromPointer(ptr unsafe.Pointer) (n *QEventLoop) {
	n = new(QEventLoop)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QEventLoop__ProcessEventsFlag
//QEventLoop::ProcessEventsFlag
type QEventLoop__ProcessEventsFlag int64

const (
	QEventLoop__AllEvents              QEventLoop__ProcessEventsFlag = QEventLoop__ProcessEventsFlag(0x00)
	QEventLoop__ExcludeUserInputEvents QEventLoop__ProcessEventsFlag = QEventLoop__ProcessEventsFlag(0x01)
	QEventLoop__ExcludeSocketNotifiers QEventLoop__ProcessEventsFlag = QEventLoop__ProcessEventsFlag(0x02)
	QEventLoop__WaitForMoreEvents      QEventLoop__ProcessEventsFlag = QEventLoop__ProcessEventsFlag(0x04)
	QEventLoop__X11ExcludeTimers       QEventLoop__ProcessEventsFlag = QEventLoop__ProcessEventsFlag(0x08)
	QEventLoop__EventLoopExec          QEventLoop__ProcessEventsFlag = QEventLoop__ProcessEventsFlag(0x20)
	QEventLoop__DialogExec             QEventLoop__ProcessEventsFlag = QEventLoop__ProcessEventsFlag(0x40)
)

func NewQEventLoop(parent QObject_ITF) *QEventLoop {
	tmpValue := NewQEventLoopFromPointer(C.QEventLoop_NewQEventLoop(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QEventLoop) Exec(flags QEventLoop__ProcessEventsFlag) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QEventLoop_Exec(ptr.Pointer(), C.longlong(flags))))
	}
	return 0
}

func (ptr *QEventLoop) Exit(returnCode int) {
	if ptr.Pointer() != nil {
		C.QEventLoop_Exit(ptr.Pointer(), C.int(int32(returnCode)))
	}
}

func (ptr *QEventLoop) IsRunning() bool {
	if ptr.Pointer() != nil {
		return int8(C.QEventLoop_IsRunning(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QEventLoop) ProcessEvents(flags QEventLoop__ProcessEventsFlag) bool {
	if ptr.Pointer() != nil {
		return int8(C.QEventLoop_ProcessEvents(ptr.Pointer(), C.longlong(flags))) != 0
	}
	return false
}

func (ptr *QEventLoop) ProcessEvents2(flags QEventLoop__ProcessEventsFlag, maxTime int) {
	if ptr.Pointer() != nil {
		C.QEventLoop_ProcessEvents2(ptr.Pointer(), C.longlong(flags), C.int(int32(maxTime)))
	}
}

//export callbackQEventLoop_Quit
func callbackQEventLoop_Quit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "quit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQEventLoopFromPointer(ptr).QuitDefault()
	}
}

func (ptr *QEventLoop) ConnectQuit(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "quit"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "quit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "quit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QEventLoop) DisconnectQuit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "quit")
	}
}

func (ptr *QEventLoop) Quit() {
	if ptr.Pointer() != nil {
		C.QEventLoop_Quit(ptr.Pointer())
	}
}

func (ptr *QEventLoop) QuitDefault() {
	if ptr.Pointer() != nil {
		C.QEventLoop_QuitDefault(ptr.Pointer())
	}
}

func (ptr *QEventLoop) WakeUp() {
	if ptr.Pointer() != nil {
		C.QEventLoop_WakeUp(ptr.Pointer())
	}
}

//export callbackQEventLoop_DestroyQEventLoop
func callbackQEventLoop_DestroyQEventLoop(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QEventLoop"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQEventLoopFromPointer(ptr).DestroyQEventLoopDefault()
	}
}

func (ptr *QEventLoop) ConnectDestroyQEventLoop(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QEventLoop"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QEventLoop", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QEventLoop", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QEventLoop) DisconnectDestroyQEventLoop() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QEventLoop")
	}
}

func (ptr *QEventLoop) DestroyQEventLoop() {
	if ptr.Pointer() != nil {
		C.QEventLoop_DestroyQEventLoop(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QEventLoop) DestroyQEventLoopDefault() {
	if ptr.Pointer() != nil {
		C.QEventLoop_DestroyQEventLoopDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QEventLoopLocker struct {
	ptr unsafe.Pointer
}

type QEventLoopLocker_ITF interface {
	QEventLoopLocker_PTR() *QEventLoopLocker
}

func (ptr *QEventLoopLocker) QEventLoopLocker_PTR() *QEventLoopLocker {
	return ptr
}

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

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

func PointerFromQEventLoopLocker(ptr QEventLoopLocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEventLoopLocker_PTR().Pointer()
	}
	return nil
}

func NewQEventLoopLockerFromPointer(ptr unsafe.Pointer) (n *QEventLoopLocker) {
	n = new(QEventLoopLocker)
	n.SetPointer(ptr)
	return
}
func NewQEventLoopLocker() *QEventLoopLocker {
	tmpValue := NewQEventLoopLockerFromPointer(C.QEventLoopLocker_NewQEventLoopLocker())
	runtime.SetFinalizer(tmpValue, (*QEventLoopLocker).DestroyQEventLoopLocker)
	return tmpValue
}

func NewQEventLoopLocker2(loop QEventLoop_ITF) *QEventLoopLocker {
	tmpValue := NewQEventLoopLockerFromPointer(C.QEventLoopLocker_NewQEventLoopLocker2(PointerFromQEventLoop(loop)))
	runtime.SetFinalizer(tmpValue, (*QEventLoopLocker).DestroyQEventLoopLocker)
	return tmpValue
}

func NewQEventLoopLocker3(thread QThread_ITF) *QEventLoopLocker {
	tmpValue := NewQEventLoopLockerFromPointer(C.QEventLoopLocker_NewQEventLoopLocker3(PointerFromQThread(thread)))
	runtime.SetFinalizer(tmpValue, (*QEventLoopLocker).DestroyQEventLoopLocker)
	return tmpValue
}

func (ptr *QEventLoopLocker) DestroyQEventLoopLocker() {
	if ptr.Pointer() != nil {
		C.QEventLoopLocker_DestroyQEventLoopLocker(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QEventTransition struct {
	QAbstractTransition
}

type QEventTransition_ITF interface {
	QAbstractTransition_ITF
	QEventTransition_PTR() *QEventTransition
}

func (ptr *QEventTransition) QEventTransition_PTR() *QEventTransition {
	return ptr
}

func (ptr *QEventTransition) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractTransition_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQEventTransition(ptr QEventTransition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEventTransition_PTR().Pointer()
	}
	return nil
}

func NewQEventTransitionFromPointer(ptr unsafe.Pointer) (n *QEventTransition) {
	n = new(QEventTransition)
	n.SetPointer(ptr)
	return
}
func NewQEventTransition(sourceState QState_ITF) *QEventTransition {
	tmpValue := NewQEventTransitionFromPointer(C.QEventTransition_NewQEventTransition(PointerFromQState(sourceState)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQEventTransition2(object QObject_ITF, ty QEvent__Type, sourceState QState_ITF) *QEventTransition {
	tmpValue := NewQEventTransitionFromPointer(C.QEventTransition_NewQEventTransition2(PointerFromQObject(object), C.longlong(ty), PointerFromQState(sourceState)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QEventTransition) EventSource() *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QEventTransition_EventSource(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

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

	return C.char(int8(qt.GoBoolToInt(NewQEventTransitionFromPointer(ptr).EventTestDefault(NewQEventFromPointer(event)))))
}

func (ptr *QEventTransition) ConnectEventTest(f func(event *QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "eventTest"); signal != nil {
			f := func(event *QEvent) bool {
				(*(*func(*QEvent) bool)(signal))(event)
				return f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "eventTest", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "eventTest", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QEventTransition) DisconnectEventTest() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "eventTest")
	}
}

func (ptr *QEventTransition) EventTest(event QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QEventTransition_EventTest(ptr.Pointer(), PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QEventTransition) EventTestDefault(event QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QEventTransition_EventTestDefault(ptr.Pointer(), PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QEventTransition) EventType() QEvent__Type {
	if ptr.Pointer() != nil {
		return QEvent__Type(C.QEventTransition_EventType(ptr.Pointer()))
	}
	return 0
}

//export callbackQEventTransition_OnTransition
func callbackQEventTransition_OnTransition(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onTransition"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	} else {
		NewQEventTransitionFromPointer(ptr).OnTransitionDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QEventTransition) ConnectOnTransition(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onTransition"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onTransition", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onTransition", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QEventTransition) DisconnectOnTransition() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onTransition")
	}
}

func (ptr *QEventTransition) OnTransition(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QEventTransition_OnTransition(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QEventTransition) OnTransitionDefault(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QEventTransition_OnTransitionDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QEventTransition) SetEventSource(object QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QEventTransition_SetEventSource(ptr.Pointer(), PointerFromQObject(object))
	}
}

func (ptr *QEventTransition) SetEventType(ty QEvent__Type) {
	if ptr.Pointer() != nil {
		C.QEventTransition_SetEventType(ptr.Pointer(), C.longlong(ty))
	}
}

//export callbackQEventTransition_DestroyQEventTransition
func callbackQEventTransition_DestroyQEventTransition(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QEventTransition"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQEventTransitionFromPointer(ptr).DestroyQEventTransitionDefault()
	}
}

func (ptr *QEventTransition) ConnectDestroyQEventTransition(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QEventTransition"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QEventTransition", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QEventTransition", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QEventTransition) DisconnectDestroyQEventTransition() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QEventTransition")
	}
}

func (ptr *QEventTransition) DestroyQEventTransition() {
	if ptr.Pointer() != nil {
		C.QEventTransition_DestroyQEventTransition(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QEventTransition) DestroyQEventTransitionDefault() {
	if ptr.Pointer() != nil {
		C.QEventTransition_DestroyQEventTransitionDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QException struct {
	ptr unsafe.Pointer
}

type QException_ITF interface {
	QException_PTR() *QException
}

func (ptr *QException) QException_PTR() *QException {
	return ptr
}

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

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

func PointerFromQException(ptr QException_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QException_PTR().Pointer()
	}
	return nil
}

func NewQExceptionFromPointer(ptr unsafe.Pointer) (n *QException) {
	n = new(QException)
	n.SetPointer(ptr)
	return
}

func (ptr *QException) DestroyQException() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(ptr.Pointer(), "")
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QExplicitlySharedDataPointer struct {
	ptr unsafe.Pointer
}

type QExplicitlySharedDataPointer_ITF interface {
	QExplicitlySharedDataPointer_PTR() *QExplicitlySharedDataPointer
}

func (ptr *QExplicitlySharedDataPointer) QExplicitlySharedDataPointer_PTR() *QExplicitlySharedDataPointer {
	return ptr
}

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

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

func PointerFromQExplicitlySharedDataPointer(ptr QExplicitlySharedDataPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QExplicitlySharedDataPointer_PTR().Pointer()
	}
	return nil
}

func NewQExplicitlySharedDataPointerFromPointer(ptr unsafe.Pointer) (n *QExplicitlySharedDataPointer) {
	n = new(QExplicitlySharedDataPointer)
	n.SetPointer(ptr)
	return
}

type QFactoryInterface struct {
	ptr unsafe.Pointer
}

type QFactoryInterface_ITF interface {
	QFactoryInterface_PTR() *QFactoryInterface
}

func (ptr *QFactoryInterface) QFactoryInterface_PTR() *QFactoryInterface {
	return ptr
}

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

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

func PointerFromQFactoryInterface(ptr QFactoryInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFactoryInterface_PTR().Pointer()
	}
	return nil
}

func NewQFactoryInterfaceFromPointer(ptr unsafe.Pointer) (n *QFactoryInterface) {
	n = new(QFactoryInterface)
	n.SetPointer(ptr)
	return
}

func (ptr *QFactoryInterface) DestroyQFactoryInterface() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFile struct {
	QFileDevice
}

type QFile_ITF interface {
	QFileDevice_ITF
	QFile_PTR() *QFile
}

func (ptr *QFile) QFile_PTR() *QFile {
	return ptr
}

func (ptr *QFile) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileDevice_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQFile(ptr QFile_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFile_PTR().Pointer()
	}
	return nil
}

func NewQFileFromPointer(ptr unsafe.Pointer) (n *QFile) {
	n = new(QFile)
	n.SetPointer(ptr)
	return
}
func NewQFile() *QFile {
	tmpValue := NewQFileFromPointer(C.QFile_NewQFile())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQFile2(name string) *QFile {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	tmpValue := NewQFileFromPointer(C.QFile_NewQFile2(C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQFile3(parent QObject_ITF) *QFile {
	tmpValue := NewQFileFromPointer(C.QFile_NewQFile3(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQFile4(name string, parent QObject_ITF) *QFile {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	tmpValue := NewQFileFromPointer(C.QFile_NewQFile4(C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QFile) Copy(newName string) bool {
	if ptr.Pointer() != nil {
		var newNameC *C.char
		if newName != "" {
			newNameC = C.CString(newName)
			defer C.free(unsafe.Pointer(newNameC))
		}
		return int8(C.QFile_Copy(ptr.Pointer(), C.struct_QtCore_PackedString{data: newNameC, len: C.longlong(len(newName))})) != 0
	}
	return false
}

func QFile_Copy2(fileName string, newName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	var newNameC *C.char
	if newName != "" {
		newNameC = C.CString(newName)
		defer C.free(unsafe.Pointer(newNameC))
	}
	return int8(C.QFile_QFile_Copy2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.struct_QtCore_PackedString{data: newNameC, len: C.longlong(len(newName))})) != 0
}

func (ptr *QFile) Copy2(fileName string, newName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	var newNameC *C.char
	if newName != "" {
		newNameC = C.CString(newName)
		defer C.free(unsafe.Pointer(newNameC))
	}
	return int8(C.QFile_QFile_Copy2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.struct_QtCore_PackedString{data: newNameC, len: C.longlong(len(newName))})) != 0
}

func QFile_DecodeName(localFileName QByteArray_ITF) string {
	return cGoUnpackString(C.QFile_QFile_DecodeName(PointerFromQByteArray(localFileName)))
}

func (ptr *QFile) DecodeName(localFileName QByteArray_ITF) string {
	return cGoUnpackString(C.QFile_QFile_DecodeName(PointerFromQByteArray(localFileName)))
}

func QFile_DecodeName2(localFileName string) string {
	var localFileNameC *C.char
	if localFileName != "" {
		localFileNameC = C.CString(localFileName)
		defer C.free(unsafe.Pointer(localFileNameC))
	}
	return cGoUnpackString(C.QFile_QFile_DecodeName2(localFileNameC))
}

func (ptr *QFile) DecodeName2(localFileName string) string {
	var localFileNameC *C.char
	if localFileName != "" {
		localFileNameC = C.CString(localFileName)
		defer C.free(unsafe.Pointer(localFileNameC))
	}
	return cGoUnpackString(C.QFile_QFile_DecodeName2(localFileNameC))
}

func QFile_EncodeName(fileName string) *QByteArray {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QFile_QFile_EncodeName(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QFile) EncodeName(fileName string) *QByteArray {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QFile_QFile_EncodeName(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QFile_Exists(fileName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QFile_QFile_Exists(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func (ptr *QFile) Exists(fileName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QFile_QFile_Exists(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func (ptr *QFile) Exists2() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFile_Exists2(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFile) Link(linkName string) bool {
	if ptr.Pointer() != nil {
		var linkNameC *C.char
		if linkName != "" {
			linkNameC = C.CString(linkName)
			defer C.free(unsafe.Pointer(linkNameC))
		}
		return int8(C.QFile_Link(ptr.Pointer(), C.struct_QtCore_PackedString{data: linkNameC, len: C.longlong(len(linkName))})) != 0
	}
	return false
}

func QFile_Link2(fileName string, linkName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	var linkNameC *C.char
	if linkName != "" {
		linkNameC = C.CString(linkName)
		defer C.free(unsafe.Pointer(linkNameC))
	}
	return int8(C.QFile_QFile_Link2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.struct_QtCore_PackedString{data: linkNameC, len: C.longlong(len(linkName))})) != 0
}

func (ptr *QFile) Link2(fileName string, linkName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	var linkNameC *C.char
	if linkName != "" {
		linkNameC = C.CString(linkName)
		defer C.free(unsafe.Pointer(linkNameC))
	}
	return int8(C.QFile_QFile_Link2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.struct_QtCore_PackedString{data: linkNameC, len: C.longlong(len(linkName))})) != 0
}

func (ptr *QFile) Open3(fd int, mode QIODevice__OpenModeFlag, handleFlags QFileDevice__FileHandleFlag) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFile_Open3(ptr.Pointer(), C.int(int32(fd)), C.longlong(mode), C.longlong(handleFlags))) != 0
	}
	return false
}

func QFile_Permissions2(fileName string) QFileDevice__Permission {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return QFileDevice__Permission(C.QFile_QFile_Permissions2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
}

func (ptr *QFile) Permissions2(fileName string) QFileDevice__Permission {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return QFileDevice__Permission(C.QFile_QFile_Permissions2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
}

func (ptr *QFile) Remove() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFile_Remove(ptr.Pointer())) != 0
	}
	return false
}

func QFile_Remove2(fileName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QFile_QFile_Remove2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func (ptr *QFile) Remove2(fileName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QFile_QFile_Remove2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func (ptr *QFile) Rename(newName string) bool {
	if ptr.Pointer() != nil {
		var newNameC *C.char
		if newName != "" {
			newNameC = C.CString(newName)
			defer C.free(unsafe.Pointer(newNameC))
		}
		return int8(C.QFile_Rename(ptr.Pointer(), C.struct_QtCore_PackedString{data: newNameC, len: C.longlong(len(newName))})) != 0
	}
	return false
}

func QFile_Rename2(oldName string, newName string) bool {
	var oldNameC *C.char
	if oldName != "" {
		oldNameC = C.CString(oldName)
		defer C.free(unsafe.Pointer(oldNameC))
	}
	var newNameC *C.char
	if newName != "" {
		newNameC = C.CString(newName)
		defer C.free(unsafe.Pointer(newNameC))
	}
	return int8(C.QFile_QFile_Rename2(C.struct_QtCore_PackedString{data: oldNameC, len: C.longlong(len(oldName))}, C.struct_QtCore_PackedString{data: newNameC, len: C.longlong(len(newName))})) != 0
}

func (ptr *QFile) Rename2(oldName string, newName string) bool {
	var oldNameC *C.char
	if oldName != "" {
		oldNameC = C.CString(oldName)
		defer C.free(unsafe.Pointer(oldNameC))
	}
	var newNameC *C.char
	if newName != "" {
		newNameC = C.CString(newName)
		defer C.free(unsafe.Pointer(newNameC))
	}
	return int8(C.QFile_QFile_Rename2(C.struct_QtCore_PackedString{data: oldNameC, len: C.longlong(len(oldName))}, C.struct_QtCore_PackedString{data: newNameC, len: C.longlong(len(newName))})) != 0
}

func QFile_Resize2(fileName string, sz int64) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QFile_QFile_Resize2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(sz))) != 0
}

func (ptr *QFile) Resize2(fileName string, sz int64) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QFile_QFile_Resize2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(sz))) != 0
}

func (ptr *QFile) SetFileName(name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QFile_SetFileName(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

func QFile_SetPermissions2(fileName string, permissions QFileDevice__Permission) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QFile_QFile_SetPermissions2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(permissions))) != 0
}

func (ptr *QFile) SetPermissions2(fileName string, permissions QFileDevice__Permission) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QFile_QFile_SetPermissions2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(permissions))) != 0
}

func QFile_SymLinkTarget(fileName string) string {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return cGoUnpackString(C.QFile_QFile_SymLinkTarget(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
}

func (ptr *QFile) SymLinkTarget(fileName string) string {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return cGoUnpackString(C.QFile_QFile_SymLinkTarget(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
}

func (ptr *QFile) SymLinkTarget2() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFile_SymLinkTarget2(ptr.Pointer()))
	}
	return ""
}

//export callbackQFile_DestroyQFile
func callbackQFile_DestroyQFile(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFile"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileFromPointer(ptr).DestroyQFileDefault()
	}
}

func (ptr *QFile) ConnectDestroyQFile(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFile"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFile", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFile", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFile) DisconnectDestroyQFile() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFile")
	}
}

func (ptr *QFile) DestroyQFile() {
	if ptr.Pointer() != nil {
		C.QFile_DestroyQFile(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFile) DestroyQFileDefault() {
	if ptr.Pointer() != nil {
		C.QFile_DestroyQFileDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFileDevice struct {
	QIODevice
}

type QFileDevice_ITF interface {
	QIODevice_ITF
	QFileDevice_PTR() *QFileDevice
}

func (ptr *QFileDevice) QFileDevice_PTR() *QFileDevice {
	return ptr
}

func (ptr *QFileDevice) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QIODevice_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQFileDevice(ptr QFileDevice_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileDevice_PTR().Pointer()
	}
	return nil
}

func NewQFileDeviceFromPointer(ptr unsafe.Pointer) (n *QFileDevice) {
	n = new(QFileDevice)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QFileDevice__FileError
//QFileDevice::FileError
type QFileDevice__FileError int64

const (
	QFileDevice__NoError          QFileDevice__FileError = QFileDevice__FileError(0)
	QFileDevice__ReadError        QFileDevice__FileError = QFileDevice__FileError(1)
	QFileDevice__WriteError       QFileDevice__FileError = QFileDevice__FileError(2)
	QFileDevice__FatalError       QFileDevice__FileError = QFileDevice__FileError(3)
	QFileDevice__ResourceError    QFileDevice__FileError = QFileDevice__FileError(4)
	QFileDevice__OpenError        QFileDevice__FileError = QFileDevice__FileError(5)
	QFileDevice__AbortError       QFileDevice__FileError = QFileDevice__FileError(6)
	QFileDevice__TimeOutError     QFileDevice__FileError = QFileDevice__FileError(7)
	QFileDevice__UnspecifiedError QFileDevice__FileError = QFileDevice__FileError(8)
	QFileDevice__RemoveError      QFileDevice__FileError = QFileDevice__FileError(9)
	QFileDevice__RenameError      QFileDevice__FileError = QFileDevice__FileError(10)
	QFileDevice__PositionError    QFileDevice__FileError = QFileDevice__FileError(11)
	QFileDevice__ResizeError      QFileDevice__FileError = QFileDevice__FileError(12)
	QFileDevice__PermissionsError QFileDevice__FileError = QFileDevice__FileError(13)
	QFileDevice__CopyError        QFileDevice__FileError = QFileDevice__FileError(14)
)

//go:generate stringer -type=QFileDevice__FileTime
//QFileDevice::FileTime
type QFileDevice__FileTime int64

const (
	QFileDevice__FileAccessTime         QFileDevice__FileTime = QFileDevice__FileTime(0)
	QFileDevice__FileBirthTime          QFileDevice__FileTime = QFileDevice__FileTime(1)
	QFileDevice__FileMetadataChangeTime QFileDevice__FileTime = QFileDevice__FileTime(2)
	QFileDevice__FileModificationTime   QFileDevice__FileTime = QFileDevice__FileTime(3)
)

//go:generate stringer -type=QFileDevice__Permission
//QFileDevice::Permission
type QFileDevice__Permission int64

const (
	QFileDevice__ReadOwner  QFileDevice__Permission = QFileDevice__Permission(0x4000)
	QFileDevice__WriteOwner QFileDevice__Permission = QFileDevice__Permission(0x2000)
	QFileDevice__ExeOwner   QFileDevice__Permission = QFileDevice__Permission(0x1000)
	QFileDevice__ReadUser   QFileDevice__Permission = QFileDevice__Permission(0x0400)
	QFileDevice__WriteUser  QFileDevice__Permission = QFileDevice__Permission(0x0200)
	QFileDevice__ExeUser    QFileDevice__Permission = QFileDevice__Permission(0x0100)
	QFileDevice__ReadGroup  QFileDevice__Permission = QFileDevice__Permission(0x0040)
	QFileDevice__WriteGroup QFileDevice__Permission = QFileDevice__Permission(0x0020)
	QFileDevice__ExeGroup   QFileDevice__Permission = QFileDevice__Permission(0x0010)
	QFileDevice__ReadOther  QFileDevice__Permission = QFileDevice__Permission(0x0004)
	QFileDevice__WriteOther QFileDevice__Permission = QFileDevice__Permission(0x0002)
	QFileDevice__ExeOther   QFileDevice__Permission = QFileDevice__Permission(0x0001)
)

//go:generate stringer -type=QFileDevice__FileHandleFlag
//QFileDevice::FileHandleFlag
type QFileDevice__FileHandleFlag int64

const (
	QFileDevice__AutoCloseHandle QFileDevice__FileHandleFlag = QFileDevice__FileHandleFlag(0x0001)
	QFileDevice__DontCloseHandle QFileDevice__FileHandleFlag = QFileDevice__FileHandleFlag(0)
)

//go:generate stringer -type=QFileDevice__MemoryMapFlags
//QFileDevice::MemoryMapFlags
type QFileDevice__MemoryMapFlags int64

const (
	QFileDevice__NoOptions        QFileDevice__MemoryMapFlags = QFileDevice__MemoryMapFlags(0)
	QFileDevice__MapPrivateOption QFileDevice__MemoryMapFlags = QFileDevice__MemoryMapFlags(0x0001)
)

func (ptr *QFileDevice) Error() QFileDevice__FileError {
	if ptr.Pointer() != nil {
		return QFileDevice__FileError(C.QFileDevice_Error(ptr.Pointer()))
	}
	return 0
}

//export callbackQFileDevice_FileName
func callbackQFileDevice_FileName(ptr unsafe.Pointer) C.struct_QtCore_PackedString {
	if signal := qt.GetSignal(ptr, "fileName"); signal != nil {
		tempVal := (*(*func() string)(signal))()
		return C.struct_QtCore_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQFileDeviceFromPointer(ptr).FileNameDefault()
	return C.struct_QtCore_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QFileDevice) ConnectFileName(f func() string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "fileName"); signal != nil {
			f := func() string {
				(*(*func() string)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "fileName", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "fileName", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDevice) DisconnectFileName() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "fileName")
	}
}

func (ptr *QFileDevice) FileName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileDevice_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileDevice) FileNameDefault() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileDevice_FileNameDefault(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileDevice) FileTime(ti QFileDevice__FileTime) *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QFileDevice_FileTime(ptr.Pointer(), C.longlong(ti)))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QFileDevice) Flush() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDevice_Flush(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileDevice) Handle() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileDevice_Handle(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFileDevice) Map(offset int64, size int64, flags QFileDevice__MemoryMapFlags) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileDevice_Map(ptr.Pointer(), C.longlong(offset), C.longlong(size), C.longlong(flags)))
	}
	return ""
}

//export callbackQFileDevice_Permissions
func callbackQFileDevice_Permissions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "permissions"); signal != nil {
		return C.longlong((*(*func() QFileDevice__Permission)(signal))())
	}

	return C.longlong(NewQFileDeviceFromPointer(ptr).PermissionsDefault())
}

func (ptr *QFileDevice) ConnectPermissions(f func() QFileDevice__Permission) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "permissions"); signal != nil {
			f := func() QFileDevice__Permission {
				(*(*func() QFileDevice__Permission)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "permissions", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "permissions", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDevice) DisconnectPermissions() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "permissions")
	}
}

func (ptr *QFileDevice) Permissions() QFileDevice__Permission {
	if ptr.Pointer() != nil {
		return QFileDevice__Permission(C.QFileDevice_Permissions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDevice) PermissionsDefault() QFileDevice__Permission {
	if ptr.Pointer() != nil {
		return QFileDevice__Permission(C.QFileDevice_PermissionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQFileDevice_ReadData
func callbackQFileDevice_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, l C.longlong) C.longlong {
	if signal := qt.GetSignal(ptr, "readData"); signal != nil {
		retS := cGoUnpackString(data)
		ret := C.longlong((*(*func(*string, int64) int64)(signal))(&retS, int64(l)))
		if ret > 0 {
			C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&retS)).Data), C.size_t(ret))
		}
		return ret
	}
	retS := cGoUnpackString(data)
	ret := C.longlong(NewQFileDeviceFromPointer(ptr).ReadDataDefault(&retS, int64(l)))
	if ret > 0 {
		C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&retS)).Data), C.size_t(ret))
	}
	return ret
}

func (ptr *QFileDevice) ConnectReadData(f func(data *string, l int64) int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "readData"); signal != nil {
			f := func(data *string, l int64) int64 {
				(*(*func(*string, int64) int64)(signal))(data, l)
				return f(data, l)
			}
			qt.ConnectSignal(ptr.Pointer(), "readData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "readData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDevice) DisconnectReadData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "readData")
	}
}

func (ptr *QFileDevice) ReadData(data *string, l int64) int64 {
	if ptr.Pointer() != nil {
		dataC := C.CString(strings.Repeat("0", int(l)))
		defer C.free(unsafe.Pointer(dataC))
		ret := int64(C.QFileDevice_ReadData(ptr.Pointer(), dataC, C.longlong(l)))
		if ret > 0 {
			*data = C.GoStringN(dataC, C.int(ret))
		}
		return ret
	}
	return 0
}

func (ptr *QFileDevice) ReadDataDefault(data *string, l int64) int64 {
	if ptr.Pointer() != nil {
		dataC := C.CString(strings.Repeat("0", int(l)))
		defer C.free(unsafe.Pointer(dataC))
		ret := int64(C.QFileDevice_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(l)))
		if ret > 0 {
			*data = C.GoStringN(dataC, C.int(ret))
		}
		return ret
	}
	return 0
}

//export callbackQFileDevice_Resize
func callbackQFileDevice_Resize(ptr unsafe.Pointer, sz C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "resize"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int64) bool)(signal))(int64(sz)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).ResizeDefault(int64(sz)))))
}

func (ptr *QFileDevice) ConnectResize(f func(sz int64) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resize"); signal != nil {
			f := func(sz int64) bool {
				(*(*func(int64) bool)(signal))(sz)
				return f(sz)
			}
			qt.ConnectSignal(ptr.Pointer(), "resize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDevice) DisconnectResize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resize")
	}
}

func (ptr *QFileDevice) Resize(sz int64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDevice_Resize(ptr.Pointer(), C.longlong(sz))) != 0
	}
	return false
}

func (ptr *QFileDevice) ResizeDefault(sz int64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDevice_ResizeDefault(ptr.Pointer(), C.longlong(sz))) != 0
	}
	return false
}

func (ptr *QFileDevice) SetFileTime(newDate QDateTime_ITF, fileTime QFileDevice__FileTime) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDevice_SetFileTime(ptr.Pointer(), PointerFromQDateTime(newDate), C.longlong(fileTime))) != 0
	}
	return false
}

//export callbackQFileDevice_SetPermissions
func callbackQFileDevice_SetPermissions(ptr unsafe.Pointer, permissions C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "setPermissions"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(QFileDevice__Permission) bool)(signal))(QFileDevice__Permission(permissions)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileDeviceFromPointer(ptr).SetPermissionsDefault(QFileDevice__Permission(permissions)))))
}

func (ptr *QFileDevice) ConnectSetPermissions(f func(permissions QFileDevice__Permission) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setPermissions"); signal != nil {
			f := func(permissions QFileDevice__Permission) bool {
				(*(*func(QFileDevice__Permission) bool)(signal))(permissions)
				return f(permissions)
			}
			qt.ConnectSignal(ptr.Pointer(), "setPermissions", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setPermissions", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDevice) DisconnectSetPermissions() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setPermissions")
	}
}

func (ptr *QFileDevice) SetPermissions(permissions QFileDevice__Permission) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDevice_SetPermissions(ptr.Pointer(), C.longlong(permissions))) != 0
	}
	return false
}

func (ptr *QFileDevice) SetPermissionsDefault(permissions QFileDevice__Permission) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDevice_SetPermissionsDefault(ptr.Pointer(), C.longlong(permissions))) != 0
	}
	return false
}

func (ptr *QFileDevice) Unmap(address string) bool {
	if ptr.Pointer() != nil {
		var addressC *C.char
		if address != "" {
			addressC = C.CString(address)
			defer C.free(unsafe.Pointer(addressC))
		}
		return int8(C.QFileDevice_Unmap(ptr.Pointer(), addressC)) != 0
	}
	return false
}

func (ptr *QFileDevice) UnsetError() {
	if ptr.Pointer() != nil {
		C.QFileDevice_UnsetError(ptr.Pointer())
	}
}

//export callbackQFileDevice_WriteData
func callbackQFileDevice_WriteData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, l C.longlong) C.longlong {
	if signal := qt.GetSignal(ptr, "writeData"); signal != nil {
		return C.longlong((*(*func([]byte, int64) int64)(signal))(cGoUnpackBytes(data), int64(l)))
	}

	return C.longlong(NewQFileDeviceFromPointer(ptr).WriteDataDefault(cGoUnpackBytes(data), int64(l)))
}

func (ptr *QFileDevice) ConnectWriteData(f func(data []byte, l int64) int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "writeData"); signal != nil {
			f := func(data []byte, l int64) int64 {
				(*(*func([]byte, int64) int64)(signal))(data, l)
				return f(data, l)
			}
			qt.ConnectSignal(ptr.Pointer(), "writeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "writeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDevice) DisconnectWriteData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "writeData")
	}
}

func (ptr *QFileDevice) WriteData(data []byte, l int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QFileDevice_WriteData(ptr.Pointer(), dataC, C.longlong(l)))
	}
	return 0
}

func (ptr *QFileDevice) WriteDataDefault(data []byte, l int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QFileDevice_WriteDataDefault(ptr.Pointer(), dataC, C.longlong(l)))
	}
	return 0
}

//export callbackQFileDevice_DestroyQFileDevice
func callbackQFileDevice_DestroyQFileDevice(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFileDevice"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileDeviceFromPointer(ptr).DestroyQFileDeviceDefault()
	}
}

func (ptr *QFileDevice) ConnectDestroyQFileDevice(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFileDevice"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFileDevice", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFileDevice", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDevice) DisconnectDestroyQFileDevice() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFileDevice")
	}
}

func (ptr *QFileDevice) DestroyQFileDevice() {
	if ptr.Pointer() != nil {
		C.QFileDevice_DestroyQFileDevice(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFileDevice) DestroyQFileDeviceDefault() {
	if ptr.Pointer() != nil {
		C.QFileDevice_DestroyQFileDeviceDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFileInfo struct {
	ptr unsafe.Pointer
}

type QFileInfo_ITF interface {
	QFileInfo_PTR() *QFileInfo
}

func (ptr *QFileInfo) QFileInfo_PTR() *QFileInfo {
	return ptr
}

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

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

func PointerFromQFileInfo(ptr QFileInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileInfo_PTR().Pointer()
	}
	return nil
}

func NewQFileInfoFromPointer(ptr unsafe.Pointer) (n *QFileInfo) {
	n = new(QFileInfo)
	n.SetPointer(ptr)
	return
}
func NewQFileInfo2() *QFileInfo {
	tmpValue := NewQFileInfoFromPointer(C.QFileInfo_NewQFileInfo2())
	runtime.SetFinalizer(tmpValue, (*QFileInfo).DestroyQFileInfo)
	return tmpValue
}

func NewQFileInfo3(file string) *QFileInfo {
	var fileC *C.char
	if file != "" {
		fileC = C.CString(file)
		defer C.free(unsafe.Pointer(fileC))
	}
	tmpValue := NewQFileInfoFromPointer(C.QFileInfo_NewQFileInfo3(C.struct_QtCore_PackedString{data: fileC, len: C.longlong(len(file))}))
	runtime.SetFinalizer(tmpValue, (*QFileInfo).DestroyQFileInfo)
	return tmpValue
}

func NewQFileInfo4(file QFile_ITF) *QFileInfo {
	tmpValue := NewQFileInfoFromPointer(C.QFileInfo_NewQFileInfo4(PointerFromQFile(file)))
	runtime.SetFinalizer(tmpValue, (*QFileInfo).DestroyQFileInfo)
	return tmpValue
}

func NewQFileInfo5(dir QDir_ITF, file string) *QFileInfo {
	var fileC *C.char
	if file != "" {
		fileC = C.CString(file)
		defer C.free(unsafe.Pointer(fileC))
	}
	tmpValue := NewQFileInfoFromPointer(C.QFileInfo_NewQFileInfo5(PointerFromQDir(dir), C.struct_QtCore_PackedString{data: fileC, len: C.longlong(len(file))}))
	runtime.SetFinalizer(tmpValue, (*QFileInfo).DestroyQFileInfo)
	return tmpValue
}

func NewQFileInfo6(fileinfo QFileInfo_ITF) *QFileInfo {
	tmpValue := NewQFileInfoFromPointer(C.QFileInfo_NewQFileInfo6(PointerFromQFileInfo(fileinfo)))
	runtime.SetFinalizer(tmpValue, (*QFileInfo).DestroyQFileInfo)
	return tmpValue
}

func (ptr *QFileInfo) AbsoluteDir() *QDir {
	if ptr.Pointer() != nil {
		tmpValue := NewQDirFromPointer(C.QFileInfo_AbsoluteDir(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
		return tmpValue
	}
	return nil
}

func (ptr *QFileInfo) AbsoluteFilePath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_AbsoluteFilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) AbsolutePath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_AbsolutePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) BaseName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_BaseName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) BirthTime() *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QFileInfo_BirthTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QFileInfo) BundleName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_BundleName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Caching() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_Caching(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) CanonicalFilePath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_CanonicalFilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) CanonicalPath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_CanonicalPath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) CompleteBaseName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_CompleteBaseName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) CompleteSuffix() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_CompleteSuffix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Dir() *QDir {
	if ptr.Pointer() != nil {
		tmpValue := NewQDirFromPointer(C.QFileInfo_Dir(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDir).DestroyQDir)
		return tmpValue
	}
	return nil
}

func (ptr *QFileInfo) Exists() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_Exists(ptr.Pointer())) != 0
	}
	return false
}

func QFileInfo_Exists2(file string) bool {
	var fileC *C.char
	if file != "" {
		fileC = C.CString(file)
		defer C.free(unsafe.Pointer(fileC))
	}
	return int8(C.QFileInfo_QFileInfo_Exists2(C.struct_QtCore_PackedString{data: fileC, len: C.longlong(len(file))})) != 0
}

func (ptr *QFileInfo) Exists2(file string) bool {
	var fileC *C.char
	if file != "" {
		fileC = C.CString(file)
		defer C.free(unsafe.Pointer(fileC))
	}
	return int8(C.QFileInfo_QFileInfo_Exists2(C.struct_QtCore_PackedString{data: fileC, len: C.longlong(len(file))})) != 0
}

func (ptr *QFileInfo) FileName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) FilePath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_FilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Group() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_Group(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) GroupId() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QFileInfo_GroupId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFileInfo) IsAbsolute() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsAbsolute(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsBundle() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsBundle(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsDir() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsDir(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsExecutable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsExecutable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsFile() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsFile(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsHidden() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsHidden(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsNativePath() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsNativePath(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsReadable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsReadable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsRelative() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsRelative(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsRoot() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsRoot(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsSymLink() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsSymLink(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) IsWritable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_IsWritable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) LastModified() *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QFileInfo_LastModified(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QFileInfo) LastRead() *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QFileInfo_LastRead(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QFileInfo) MakeAbsolute() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileInfo_MakeAbsolute(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileInfo) MetadataChangeTime() *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QFileInfo_MetadataChangeTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QFileInfo) Owner() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_Owner(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) OwnerId() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QFileInfo_OwnerId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFileInfo) Path() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_Path(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Refresh() {
	if ptr.Pointer() != nil {
		C.QFileInfo_Refresh(ptr.Pointer())
	}
}

func (ptr *QFileInfo) SetCaching(enable bool) {
	if ptr.Pointer() != nil {
		C.QFileInfo_SetCaching(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QFileInfo) SetFile(file string) {
	if ptr.Pointer() != nil {
		var fileC *C.char
		if file != "" {
			fileC = C.CString(file)
			defer C.free(unsafe.Pointer(fileC))
		}
		C.QFileInfo_SetFile(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileC, len: C.longlong(len(file))})
	}
}

func (ptr *QFileInfo) SetFile2(file QFile_ITF) {
	if ptr.Pointer() != nil {
		C.QFileInfo_SetFile2(ptr.Pointer(), PointerFromQFile(file))
	}
}

func (ptr *QFileInfo) SetFile3(dir QDir_ITF, file string) {
	if ptr.Pointer() != nil {
		var fileC *C.char
		if file != "" {
			fileC = C.CString(file)
			defer C.free(unsafe.Pointer(fileC))
		}
		C.QFileInfo_SetFile3(ptr.Pointer(), PointerFromQDir(dir), C.struct_QtCore_PackedString{data: fileC, len: C.longlong(len(file))})
	}
}

func (ptr *QFileInfo) Size() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QFileInfo_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileInfo) Suffix() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_Suffix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Swap(other QFileInfo_ITF) {
	if ptr.Pointer() != nil {
		C.QFileInfo_Swap(ptr.Pointer(), PointerFromQFileInfo(other))
	}
}

func (ptr *QFileInfo) SymLinkTarget() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileInfo_SymLinkTarget(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) DestroyQFileInfo() {
	if ptr.Pointer() != nil {
		C.QFileInfo_DestroyQFileInfo(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFileSelector struct {
	QObject
}

type QFileSelector_ITF interface {
	QObject_ITF
	QFileSelector_PTR() *QFileSelector
}

func (ptr *QFileSelector) QFileSelector_PTR() *QFileSelector {
	return ptr
}

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

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

func PointerFromQFileSelector(ptr QFileSelector_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileSelector_PTR().Pointer()
	}
	return nil
}

func NewQFileSelectorFromPointer(ptr unsafe.Pointer) (n *QFileSelector) {
	n = new(QFileSelector)
	n.SetPointer(ptr)
	return
}
func NewQFileSelector(parent QObject_ITF) *QFileSelector {
	tmpValue := NewQFileSelectorFromPointer(C.QFileSelector_NewQFileSelector(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QFileSelector) AllSelectors() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QFileSelector_AllSelectors(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QFileSelector) ExtraSelectors() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QFileSelector_ExtraSelectors(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QFileSelector) Select(filePath string) string {
	if ptr.Pointer() != nil {
		var filePathC *C.char
		if filePath != "" {
			filePathC = C.CString(filePath)
			defer C.free(unsafe.Pointer(filePathC))
		}
		return cGoUnpackString(C.QFileSelector_Select(ptr.Pointer(), C.struct_QtCore_PackedString{data: filePathC, len: C.longlong(len(filePath))}))
	}
	return ""
}

func (ptr *QFileSelector) Select2(filePath QUrl_ITF) *QUrl {
	if ptr.Pointer() != nil {
		tmpValue := NewQUrlFromPointer(C.QFileSelector_Select2(ptr.Pointer(), PointerFromQUrl(filePath)))
		runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSelector) SetExtraSelectors(list []string) {
	if ptr.Pointer() != nil {
		listC := C.CString(strings.Join(list, "¡¦!"))
		defer C.free(unsafe.Pointer(listC))
		C.QFileSelector_SetExtraSelectors(ptr.Pointer(), C.struct_QtCore_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "¡¦!")))})
	}
}

//export callbackQFileSelector_DestroyQFileSelector
func callbackQFileSelector_DestroyQFileSelector(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFileSelector"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileSelectorFromPointer(ptr).DestroyQFileSelectorDefault()
	}
}

func (ptr *QFileSelector) ConnectDestroyQFileSelector(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFileSelector"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFileSelector", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFileSelector", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSelector) DisconnectDestroyQFileSelector() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFileSelector")
	}
}

func (ptr *QFileSelector) DestroyQFileSelector() {
	if ptr.Pointer() != nil {
		C.QFileSelector_DestroyQFileSelector(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFileSelector) DestroyQFileSelectorDefault() {
	if ptr.Pointer() != nil {
		C.QFileSelector_DestroyQFileSelectorDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFileSystemWatcher struct {
	QObject
}

type QFileSystemWatcher_ITF interface {
	QObject_ITF
	QFileSystemWatcher_PTR() *QFileSystemWatcher
}

func (ptr *QFileSystemWatcher) QFileSystemWatcher_PTR() *QFileSystemWatcher {
	return ptr
}

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

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

func PointerFromQFileSystemWatcher(ptr QFileSystemWatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileSystemWatcher_PTR().Pointer()
	}
	return nil
}

func NewQFileSystemWatcherFromPointer(ptr unsafe.Pointer) (n *QFileSystemWatcher) {
	n = new(QFileSystemWatcher)
	n.SetPointer(ptr)
	return
}
func NewQFileSystemWatcher(parent QObject_ITF) *QFileSystemWatcher {
	tmpValue := NewQFileSystemWatcherFromPointer(C.QFileSystemWatcher_NewQFileSystemWatcher(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQFileSystemWatcher2(paths []string, parent QObject_ITF) *QFileSystemWatcher {
	pathsC := C.CString(strings.Join(paths, "¡¦!"))
	defer C.free(unsafe.Pointer(pathsC))
	tmpValue := NewQFileSystemWatcherFromPointer(C.QFileSystemWatcher_NewQFileSystemWatcher2(C.struct_QtCore_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "¡¦!")))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QFileSystemWatcher) AddPath(path string) bool {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		return int8(C.QFileSystemWatcher_AddPath(ptr.Pointer(), C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})) != 0
	}
	return false
}

func (ptr *QFileSystemWatcher) AddPaths(paths []string) []string {
	if ptr.Pointer() != nil {
		pathsC := C.CString(strings.Join(paths, "¡¦!"))
		defer C.free(unsafe.Pointer(pathsC))
		return unpackStringList(cGoUnpackString(C.QFileSystemWatcher_AddPaths(ptr.Pointer(), C.struct_QtCore_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "¡¦!")))})))
	}
	return make([]string, 0)
}

func (ptr *QFileSystemWatcher) Directories() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QFileSystemWatcher_Directories(ptr.Pointer())))
	}
	return make([]string, 0)
}

//export callbackQFileSystemWatcher_DirectoryChanged
func callbackQFileSystemWatcher_DirectoryChanged(ptr unsafe.Pointer, path C.struct_QtCore_PackedString) {
	if signal := qt.GetSignal(ptr, "directoryChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(path))
	}

}

func (ptr *QFileSystemWatcher) ConnectDirectoryChanged(f func(path string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "directoryChanged") {
			C.QFileSystemWatcher_ConnectDirectoryChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "directoryChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "directoryChanged"); signal != nil {
			f := func(path string) {
				(*(*func(string))(signal))(path)
				f(path)
			}
			qt.ConnectSignal(ptr.Pointer(), "directoryChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "directoryChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemWatcher) DisconnectDirectoryChanged() {
	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_DisconnectDirectoryChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "directoryChanged")
	}
}

//export callbackQFileSystemWatcher_FileChanged
func callbackQFileSystemWatcher_FileChanged(ptr unsafe.Pointer, path C.struct_QtCore_PackedString) {
	if signal := qt.GetSignal(ptr, "fileChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(path))
	}

}

func (ptr *QFileSystemWatcher) ConnectFileChanged(f func(path string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "fileChanged") {
			C.QFileSystemWatcher_ConnectFileChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "fileChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "fileChanged"); signal != nil {
			f := func(path string) {
				(*(*func(string))(signal))(path)
				f(path)
			}
			qt.ConnectSignal(ptr.Pointer(), "fileChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "fileChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemWatcher) DisconnectFileChanged() {
	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_DisconnectFileChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "fileChanged")
	}
}

func (ptr *QFileSystemWatcher) Files() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QFileSystemWatcher_Files(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QFileSystemWatcher) RemovePath(path string) bool {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		return int8(C.QFileSystemWatcher_RemovePath(ptr.Pointer(), C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})) != 0
	}
	return false
}

func (ptr *QFileSystemWatcher) RemovePaths(paths []string) []string {
	if ptr.Pointer() != nil {
		pathsC := C.CString(strings.Join(paths, "¡¦!"))
		defer C.free(unsafe.Pointer(pathsC))
		return unpackStringList(cGoUnpackString(C.QFileSystemWatcher_RemovePaths(ptr.Pointer(), C.struct_QtCore_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "¡¦!")))})))
	}
	return make([]string, 0)
}

//export callbackQFileSystemWatcher_DestroyQFileSystemWatcher
func callbackQFileSystemWatcher_DestroyQFileSystemWatcher(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFileSystemWatcher"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileSystemWatcherFromPointer(ptr).DestroyQFileSystemWatcherDefault()
	}
}

func (ptr *QFileSystemWatcher) ConnectDestroyQFileSystemWatcher(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFileSystemWatcher"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFileSystemWatcher", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFileSystemWatcher", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemWatcher) DisconnectDestroyQFileSystemWatcher() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFileSystemWatcher")
	}
}

func (ptr *QFileSystemWatcher) DestroyQFileSystemWatcher() {
	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_DestroyQFileSystemWatcher(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFileSystemWatcher) DestroyQFileSystemWatcherDefault() {
	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_DestroyQFileSystemWatcherDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFinalState struct {
	QAbstractState
}

type QFinalState_ITF interface {
	QAbstractState_ITF
	QFinalState_PTR() *QFinalState
}

func (ptr *QFinalState) QFinalState_PTR() *QFinalState {
	return ptr
}

func (ptr *QFinalState) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractState_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQFinalState(ptr QFinalState_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFinalState_PTR().Pointer()
	}
	return nil
}

func NewQFinalStateFromPointer(ptr unsafe.Pointer) (n *QFinalState) {
	n = new(QFinalState)
	n.SetPointer(ptr)
	return
}
func NewQFinalState(parent QState_ITF) *QFinalState {
	tmpValue := NewQFinalStateFromPointer(C.QFinalState_NewQFinalState(PointerFromQState(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQFinalState_OnEntry
func callbackQFinalState_OnEntry(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onEntry"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	} else {
		NewQFinalStateFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QFinalState) ConnectOnEntry(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onEntry"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onEntry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onEntry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFinalState) DisconnectOnEntry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onEntry")
	}
}

func (ptr *QFinalState) OnEntry(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QFinalState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFinalState) OnEntryDefault(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QFinalState_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

//export callbackQFinalState_OnExit
func callbackQFinalState_OnExit(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onExit"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	} else {
		NewQFinalStateFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QFinalState) ConnectOnExit(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onExit"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onExit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onExit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFinalState) DisconnectOnExit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onExit")
	}
}

func (ptr *QFinalState) OnExit(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QFinalState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFinalState) OnExitDefault(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QFinalState_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

//export callbackQFinalState_DestroyQFinalState
func callbackQFinalState_DestroyQFinalState(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFinalState"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFinalStateFromPointer(ptr).DestroyQFinalStateDefault()
	}
}

func (ptr *QFinalState) ConnectDestroyQFinalState(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFinalState"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFinalState", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFinalState", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFinalState) DisconnectDestroyQFinalState() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFinalState")
	}
}

func (ptr *QFinalState) DestroyQFinalState() {
	if ptr.Pointer() != nil {
		C.QFinalState_DestroyQFinalState(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFinalState) DestroyQFinalStateDefault() {
	if ptr.Pointer() != nil {
		C.QFinalState_DestroyQFinalStateDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFlag struct {
	ptr unsafe.Pointer
}

type QFlag_ITF interface {
	QFlag_PTR() *QFlag
}

func (ptr *QFlag) QFlag_PTR() *QFlag {
	return ptr
}

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

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

func PointerFromQFlag(ptr QFlag_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFlag_PTR().Pointer()
	}
	return nil
}

func NewQFlagFromPointer(ptr unsafe.Pointer) (n *QFlag) {
	n = new(QFlag)
	n.SetPointer(ptr)
	return
}

func (ptr *QFlag) DestroyQFlag() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQFlag(value int) *QFlag {
	tmpValue := NewQFlagFromPointer(C.QFlag_NewQFlag(C.int(int32(value))))
	runtime.SetFinalizer(tmpValue, (*QFlag).DestroyQFlag)
	return tmpValue
}

func NewQFlag2(value uint) *QFlag {
	tmpValue := NewQFlagFromPointer(C.QFlag_NewQFlag2(C.uint(uint32(value))))
	runtime.SetFinalizer(tmpValue, (*QFlag).DestroyQFlag)
	return tmpValue
}

func NewQFlag3(value int16) *QFlag {
	tmpValue := NewQFlagFromPointer(C.QFlag_NewQFlag3(C.short(value)))
	runtime.SetFinalizer(tmpValue, (*QFlag).DestroyQFlag)
	return tmpValue
}

func NewQFlag4(value uint16) *QFlag {
	tmpValue := NewQFlagFromPointer(C.QFlag_NewQFlag4(C.ushort(value)))
	runtime.SetFinalizer(tmpValue, (*QFlag).DestroyQFlag)
	return tmpValue
}

type QFlags struct {
	ptr unsafe.Pointer
}

type QFlags_ITF interface {
	QFlags_PTR() *QFlags
}

func (ptr *QFlags) QFlags_PTR() *QFlags {
	return ptr
}

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

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

func PointerFromQFlags(ptr QFlags_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFlags_PTR().Pointer()
	}
	return nil
}

func NewQFlagsFromPointer(ptr unsafe.Pointer) (n *QFlags) {
	n = new(QFlags)
	n.SetPointer(ptr)
	return
}

func (ptr *QFlags) DestroyQFlags() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFuture struct {
	ptr unsafe.Pointer
}

type QFuture_ITF interface {
	QFuture_PTR() *QFuture
}

func (ptr *QFuture) QFuture_PTR() *QFuture {
	return ptr
}

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

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

func PointerFromQFuture(ptr QFuture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFuture_PTR().Pointer()
	}
	return nil
}

func NewQFutureFromPointer(ptr unsafe.Pointer) (n *QFuture) {
	n = new(QFuture)
	n.SetPointer(ptr)
	return
}

type QFutureInterface struct {
	QFutureInterfaceBase
}

type QFutureInterface_ITF interface {
	QFutureInterfaceBase_ITF
	QFutureInterface_PTR() *QFutureInterface
}

func (ptr *QFutureInterface) QFutureInterface_PTR() *QFutureInterface {
	return ptr
}

func (ptr *QFutureInterface) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureInterfaceBase_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQFutureInterface(ptr QFutureInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureInterface_PTR().Pointer()
	}
	return nil
}

func NewQFutureInterfaceFromPointer(ptr unsafe.Pointer) (n *QFutureInterface) {
	n = new(QFutureInterface)
	n.SetPointer(ptr)
	return
}

func (ptr *QFutureInterface) DestroyQFutureInterface() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFutureInterface) __reportResults_results_atList(i int) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QFutureInterface___reportResults_results_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFutureInterface) __reportResults_results_setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QFutureInterface___reportResults_results_setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QFutureInterface) __reportResults_results_newList() unsafe.Pointer {
	return C.QFutureInterface___reportResults_results_newList(ptr.Pointer())
}

func (ptr *QFutureInterface) __results_atList(i int) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QFutureInterface___results_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFutureInterface) __results_setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QFutureInterface___results_setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QFutureInterface) __results_newList() unsafe.Pointer {
	return C.QFutureInterface___results_newList(ptr.Pointer())
}

type QFutureInterfaceBase struct {
	ptr unsafe.Pointer
}

type QFutureInterfaceBase_ITF interface {
	QFutureInterfaceBase_PTR() *QFutureInterfaceBase
}

func (ptr *QFutureInterfaceBase) QFutureInterfaceBase_PTR() *QFutureInterfaceBase {
	return ptr
}

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

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

func PointerFromQFutureInterfaceBase(ptr QFutureInterfaceBase_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureInterfaceBase_PTR().Pointer()
	}
	return nil
}

func NewQFutureInterfaceBaseFromPointer(ptr unsafe.Pointer) (n *QFutureInterfaceBase) {
	n = new(QFutureInterfaceBase)
	n.SetPointer(ptr)
	return
}

func (ptr *QFutureInterfaceBase) DestroyQFutureInterfaceBase() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFutureIterator struct {
	ptr unsafe.Pointer
}

type QFutureIterator_ITF interface {
	QFutureIterator_PTR() *QFutureIterator
}

func (ptr *QFutureIterator) QFutureIterator_PTR() *QFutureIterator {
	return ptr
}

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

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

func PointerFromQFutureIterator(ptr QFutureIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureIterator_PTR().Pointer()
	}
	return nil
}

func NewQFutureIteratorFromPointer(ptr unsafe.Pointer) (n *QFutureIterator) {
	n = new(QFutureIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QFutureIterator) DestroyQFutureIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFutureSynchronizer struct {
	ptr unsafe.Pointer
}

type QFutureSynchronizer_ITF interface {
	QFutureSynchronizer_PTR() *QFutureSynchronizer
}

func (ptr *QFutureSynchronizer) QFutureSynchronizer_PTR() *QFutureSynchronizer {
	return ptr
}

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

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

func PointerFromQFutureSynchronizer(ptr QFutureSynchronizer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureSynchronizer_PTR().Pointer()
	}
	return nil
}

func NewQFutureSynchronizerFromPointer(ptr unsafe.Pointer) (n *QFutureSynchronizer) {
	n = new(QFutureSynchronizer)
	n.SetPointer(ptr)
	return
}

type QFutureWatcher struct {
	QObject
}

type QFutureWatcher_ITF interface {
	QObject_ITF
	QFutureWatcher_PTR() *QFutureWatcher
}

func (ptr *QFutureWatcher) QFutureWatcher_PTR() *QFutureWatcher {
	return ptr
}

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

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

func PointerFromQFutureWatcher(ptr QFutureWatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureWatcher_PTR().Pointer()
	}
	return nil
}

func NewQFutureWatcherFromPointer(ptr unsafe.Pointer) (n *QFutureWatcher) {
	n = new(QFutureWatcher)
	n.SetPointer(ptr)
	return
}

type QFutureWatcherBase struct {
	QObject
}

type QFutureWatcherBase_ITF interface {
	QObject_ITF
	QFutureWatcherBase_PTR() *QFutureWatcherBase
}

func (ptr *QFutureWatcherBase) QFutureWatcherBase_PTR() *QFutureWatcherBase {
	return ptr
}

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

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

func PointerFromQFutureWatcherBase(ptr QFutureWatcherBase_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureWatcherBase_PTR().Pointer()
	}
	return nil
}

func NewQFutureWatcherBaseFromPointer(ptr unsafe.Pointer) (n *QFutureWatcherBase) {
	n = new(QFutureWatcherBase)
	n.SetPointer(ptr)
	return
}

type QGenericArgument struct {
	ptr unsafe.Pointer
}

type QGenericArgument_ITF interface {
	QGenericArgument_PTR() *QGenericArgument
}

func (ptr *QGenericArgument) QGenericArgument_PTR() *QGenericArgument {
	return ptr
}

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

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

func PointerFromQGenericArgument(ptr QGenericArgument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericArgument_PTR().Pointer()
	}
	return nil
}

func NewQGenericArgumentFromPointer(ptr unsafe.Pointer) (n *QGenericArgument) {
	n = new(QGenericArgument)
	n.SetPointer(ptr)
	return
}

func (ptr *QGenericArgument) DestroyQGenericArgument() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQGenericArgument(name string, data unsafe.Pointer) *QGenericArgument {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	tmpValue := NewQGenericArgumentFromPointer(C.QGenericArgument_NewQGenericArgument(nameC, data))
	runtime.SetFinalizer(tmpValue, (*QGenericArgument).DestroyQGenericArgument)
	return tmpValue
}

func (ptr *QGenericArgument) Data() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QGenericArgument_Data(ptr.Pointer())
	}
	return nil
}

func (ptr *QGenericArgument) Name() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QGenericArgument_Name(ptr.Pointer()))
	}
	return ""
}

type QGenericAtomicOps struct {
	ptr unsafe.Pointer
}

type QGenericAtomicOps_ITF interface {
	QGenericAtomicOps_PTR() *QGenericAtomicOps
}

func (ptr *QGenericAtomicOps) QGenericAtomicOps_PTR() *QGenericAtomicOps {
	return ptr
}

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

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

func PointerFromQGenericAtomicOps(ptr QGenericAtomicOps_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericAtomicOps_PTR().Pointer()
	}
	return nil
}

func NewQGenericAtomicOpsFromPointer(ptr unsafe.Pointer) (n *QGenericAtomicOps) {
	n = new(QGenericAtomicOps)
	n.SetPointer(ptr)
	return
}

func (ptr *QGenericAtomicOps) DestroyQGenericAtomicOps() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QGenericReturnArgument struct {
	QGenericArgument
}

type QGenericReturnArgument_ITF interface {
	QGenericArgument_ITF
	QGenericReturnArgument_PTR() *QGenericReturnArgument
}

func (ptr *QGenericReturnArgument) QGenericReturnArgument_PTR() *QGenericReturnArgument {
	return ptr
}

func (ptr *QGenericReturnArgument) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericArgument_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQGenericReturnArgument(ptr QGenericReturnArgument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericReturnArgument_PTR().Pointer()
	}
	return nil
}

func NewQGenericReturnArgumentFromPointer(ptr unsafe.Pointer) (n *QGenericReturnArgument) {
	n = new(QGenericReturnArgument)
	n.SetPointer(ptr)
	return
}

func (ptr *QGenericReturnArgument) DestroyQGenericReturnArgument() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQGenericReturnArgument(name string, data unsafe.Pointer) *QGenericReturnArgument {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	tmpValue := NewQGenericReturnArgumentFromPointer(C.QGenericReturnArgument_NewQGenericReturnArgument(nameC, data))
	runtime.SetFinalizer(tmpValue, (*QGenericReturnArgument).DestroyQGenericReturnArgument)
	return tmpValue
}

type QGlobalStatic struct {
	ptr unsafe.Pointer
}

type QGlobalStatic_ITF interface {
	QGlobalStatic_PTR() *QGlobalStatic
}

func (ptr *QGlobalStatic) QGlobalStatic_PTR() *QGlobalStatic {
	return ptr
}

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

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

func PointerFromQGlobalStatic(ptr QGlobalStatic_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGlobalStatic_PTR().Pointer()
	}
	return nil
}

func NewQGlobalStaticFromPointer(ptr unsafe.Pointer) (n *QGlobalStatic) {
	n = new(QGlobalStatic)
	n.SetPointer(ptr)
	return
}

func (ptr *QGlobalStatic) DestroyQGlobalStatic() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QHash struct {
	ptr unsafe.Pointer
}

type QHash_ITF interface {
	QHash_PTR() *QHash
}

func (ptr *QHash) QHash_PTR() *QHash {
	return ptr
}

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

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

func PointerFromQHash(ptr QHash_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHash_PTR().Pointer()
	}
	return nil
}

func NewQHashFromPointer(ptr unsafe.Pointer) (n *QHash) {
	n = new(QHash)
	n.SetPointer(ptr)
	return
}

type QHashData struct {
	ptr unsafe.Pointer
}

type QHashData_ITF interface {
	QHashData_PTR() *QHashData
}

func (ptr *QHashData) QHashData_PTR() *QHashData {
	return ptr
}

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

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

func PointerFromQHashData(ptr QHashData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHashData_PTR().Pointer()
	}
	return nil
}

func NewQHashDataFromPointer(ptr unsafe.Pointer) (n *QHashData) {
	n = new(QHashData)
	n.SetPointer(ptr)
	return
}

func (ptr *QHashData) DestroyQHashData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QHashIterator struct {
	ptr unsafe.Pointer
}

type QHashIterator_ITF interface {
	QHashIterator_PTR() *QHashIterator
}

func (ptr *QHashIterator) QHashIterator_PTR() *QHashIterator {
	return ptr
}

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

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

func PointerFromQHashIterator(ptr QHashIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHashIterator_PTR().Pointer()
	}
	return nil
}

func NewQHashIteratorFromPointer(ptr unsafe.Pointer) (n *QHashIterator) {
	n = new(QHashIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QHashIterator) DestroyQHashIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QHashNode struct {
	ptr unsafe.Pointer
}

type QHashNode_ITF interface {
	QHashNode_PTR() *QHashNode
}

func (ptr *QHashNode) QHashNode_PTR() *QHashNode {
	return ptr
}

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

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

func PointerFromQHashNode(ptr QHashNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHashNode_PTR().Pointer()
	}
	return nil
}

func NewQHashNodeFromPointer(ptr unsafe.Pointer) (n *QHashNode) {
	n = new(QHashNode)
	n.SetPointer(ptr)
	return
}

func (ptr *QHashNode) DestroyQHashNode() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QHistoryState struct {
	QAbstractState
}

type QHistoryState_ITF interface {
	QAbstractState_ITF
	QHistoryState_PTR() *QHistoryState
}

func (ptr *QHistoryState) QHistoryState_PTR() *QHistoryState {
	return ptr
}

func (ptr *QHistoryState) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractState_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQHistoryState(ptr QHistoryState_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHistoryState_PTR().Pointer()
	}
	return nil
}

func NewQHistoryStateFromPointer(ptr unsafe.Pointer) (n *QHistoryState) {
	n = new(QHistoryState)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QHistoryState__HistoryType
//QHistoryState::HistoryType
type QHistoryState__HistoryType int64

const (
	QHistoryState__ShallowHistory QHistoryState__HistoryType = QHistoryState__HistoryType(0)
	QHistoryState__DeepHistory    QHistoryState__HistoryType = QHistoryState__HistoryType(1)
)

func NewQHistoryState(parent QState_ITF) *QHistoryState {
	tmpValue := NewQHistoryStateFromPointer(C.QHistoryState_NewQHistoryState(PointerFromQState(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQHistoryState2(ty QHistoryState__HistoryType, parent QState_ITF) *QHistoryState {
	tmpValue := NewQHistoryStateFromPointer(C.QHistoryState_NewQHistoryState2(C.longlong(ty), PointerFromQState(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QHistoryState) DefaultState() *QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractStateFromPointer(C.QHistoryState_DefaultState(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQHistoryState_DefaultStateChanged
func callbackQHistoryState_DefaultStateChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "defaultStateChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QHistoryState) ConnectDefaultStateChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "defaultStateChanged") {
			C.QHistoryState_ConnectDefaultStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "defaultStateChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "defaultStateChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "defaultStateChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "defaultStateChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHistoryState) DisconnectDefaultStateChanged() {
	if ptr.Pointer() != nil {
		C.QHistoryState_DisconnectDefaultStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "defaultStateChanged")
	}
}

func (ptr *QHistoryState) DefaultTransition() *QAbstractTransition {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractTransitionFromPointer(C.QHistoryState_DefaultTransition(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQHistoryState_DefaultTransitionChanged
func callbackQHistoryState_DefaultTransitionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "defaultTransitionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QHistoryState) ConnectDefaultTransitionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "defaultTransitionChanged") {
			C.QHistoryState_ConnectDefaultTransitionChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "defaultTransitionChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "defaultTransitionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "defaultTransitionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "defaultTransitionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHistoryState) DisconnectDefaultTransitionChanged() {
	if ptr.Pointer() != nil {
		C.QHistoryState_DisconnectDefaultTransitionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "defaultTransitionChanged")
	}
}

func (ptr *QHistoryState) HistoryType() QHistoryState__HistoryType {
	if ptr.Pointer() != nil {
		return QHistoryState__HistoryType(C.QHistoryState_HistoryType(ptr.Pointer()))
	}
	return 0
}

//export callbackQHistoryState_HistoryTypeChanged
func callbackQHistoryState_HistoryTypeChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "historyTypeChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QHistoryState) ConnectHistoryTypeChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "historyTypeChanged") {
			C.QHistoryState_ConnectHistoryTypeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "historyTypeChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "historyTypeChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "historyTypeChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "historyTypeChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHistoryState) DisconnectHistoryTypeChanged() {
	if ptr.Pointer() != nil {
		C.QHistoryState_DisconnectHistoryTypeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "historyTypeChanged")
	}
}

//export callbackQHistoryState_OnEntry
func callbackQHistoryState_OnEntry(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onEntry"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	} else {
		NewQHistoryStateFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QHistoryState) ConnectOnEntry(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onEntry"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onEntry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onEntry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHistoryState) DisconnectOnEntry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onEntry")
	}
}

func (ptr *QHistoryState) OnEntry(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QHistoryState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QHistoryState) OnEntryDefault(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QHistoryState_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

//export callbackQHistoryState_OnExit
func callbackQHistoryState_OnExit(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onExit"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	} else {
		NewQHistoryStateFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QHistoryState) ConnectOnExit(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onExit"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onExit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onExit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHistoryState) DisconnectOnExit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onExit")
	}
}

func (ptr *QHistoryState) OnExit(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QHistoryState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QHistoryState) OnExitDefault(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QHistoryState_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QHistoryState) SetDefaultState(state QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QHistoryState_SetDefaultState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

func (ptr *QHistoryState) SetDefaultTransition(transition QAbstractTransition_ITF) {
	if ptr.Pointer() != nil {
		C.QHistoryState_SetDefaultTransition(ptr.Pointer(), PointerFromQAbstractTransition(transition))
	}
}

func (ptr *QHistoryState) SetHistoryType(ty QHistoryState__HistoryType) {
	if ptr.Pointer() != nil {
		C.QHistoryState_SetHistoryType(ptr.Pointer(), C.longlong(ty))
	}
}

//export callbackQHistoryState_DestroyQHistoryState
func callbackQHistoryState_DestroyQHistoryState(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QHistoryState"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQHistoryStateFromPointer(ptr).DestroyQHistoryStateDefault()
	}
}

func (ptr *QHistoryState) ConnectDestroyQHistoryState(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QHistoryState"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QHistoryState", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QHistoryState", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHistoryState) DisconnectDestroyQHistoryState() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QHistoryState")
	}
}

func (ptr *QHistoryState) DestroyQHistoryState() {
	if ptr.Pointer() != nil {
		C.QHistoryState_DestroyQHistoryState(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QHistoryState) DestroyQHistoryStateDefault() {
	if ptr.Pointer() != nil {
		C.QHistoryState_DestroyQHistoryStateDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QIODevice struct {
	QObject
}

type QIODevice_ITF interface {
	QObject_ITF
	QIODevice_PTR() *QIODevice
}

func (ptr *QIODevice) QIODevice_PTR() *QIODevice {
	return ptr
}

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

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

func PointerFromQIODevice(ptr QIODevice_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIODevice_PTR().Pointer()
	}
	return nil
}

func NewQIODeviceFromPointer(ptr unsafe.Pointer) (n *QIODevice) {
	n = new(QIODevice)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QIODevice__OpenModeFlag
//QIODevice::OpenModeFlag
type QIODevice__OpenModeFlag int64

const (
	QIODevice__NotOpen      QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(0x0000)
	QIODevice__ReadOnly     QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(0x0001)
	QIODevice__WriteOnly    QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(0x0002)
	QIODevice__ReadWrite    QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(QIODevice__ReadOnly | QIODevice__WriteOnly)
	QIODevice__Append       QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(0x0004)
	QIODevice__Truncate     QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(0x0008)
	QIODevice__Text         QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(0x0010)
	QIODevice__Unbuffered   QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(0x0020)
	QIODevice__NewOnly      QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(0x0040)
	QIODevice__ExistingOnly QIODevice__OpenModeFlag = QIODevice__OpenModeFlag(0x0080)
)

func NewQIODevice() *QIODevice {
	tmpValue := NewQIODeviceFromPointer(C.QIODevice_NewQIODevice())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQIODevice2(parent QObject_ITF) *QIODevice {
	tmpValue := NewQIODeviceFromPointer(C.QIODevice_NewQIODevice2(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQIODevice_AboutToClose
func callbackQIODevice_AboutToClose(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "aboutToClose"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QIODevice) ConnectAboutToClose(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "aboutToClose") {
			C.QIODevice_ConnectAboutToClose(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "aboutToClose")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "aboutToClose"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "aboutToClose", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "aboutToClose", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectAboutToClose() {
	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectAboutToClose(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "aboutToClose")
	}
}

func (ptr *QIODevice) AboutToClose() {
	if ptr.Pointer() != nil {
		C.QIODevice_AboutToClose(ptr.Pointer())
	}
}

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

	return C.char(int8(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).AtEndDefault())))
}

func (ptr *QIODevice) ConnectAtEnd(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "atEnd"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "atEnd", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "atEnd", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectAtEnd() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "atEnd")
	}
}

func (ptr *QIODevice) AtEnd() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_AtEnd(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QIODevice) AtEndDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_AtEndDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQIODevice_BytesAvailable
func callbackQIODevice_BytesAvailable(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "bytesAvailable"); signal != nil {
		return C.longlong((*(*func() int64)(signal))())
	}

	return C.longlong(NewQIODeviceFromPointer(ptr).BytesAvailableDefault())
}

func (ptr *QIODevice) ConnectBytesAvailable(f func() int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "bytesAvailable"); signal != nil {
			f := func() int64 {
				(*(*func() int64)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "bytesAvailable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "bytesAvailable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectBytesAvailable() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "bytesAvailable")
	}
}

func (ptr *QIODevice) BytesAvailable() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_BytesAvailable(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) BytesAvailableDefault() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_BytesAvailableDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQIODevice_BytesToWrite
func callbackQIODevice_BytesToWrite(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "bytesToWrite"); signal != nil {
		return C.longlong((*(*func() int64)(signal))())
	}

	return C.longlong(NewQIODeviceFromPointer(ptr).BytesToWriteDefault())
}

func (ptr *QIODevice) ConnectBytesToWrite(f func() int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "bytesToWrite"); signal != nil {
			f := func() int64 {
				(*(*func() int64)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "bytesToWrite", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "bytesToWrite", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectBytesToWrite() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "bytesToWrite")
	}
}

func (ptr *QIODevice) BytesToWrite() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_BytesToWrite(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) BytesToWriteDefault() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_BytesToWriteDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQIODevice_BytesWritten
func callbackQIODevice_BytesWritten(ptr unsafe.Pointer, bytes C.longlong) {
	if signal := qt.GetSignal(ptr, "bytesWritten"); signal != nil {
		(*(*func(int64))(signal))(int64(bytes))
	}

}

func (ptr *QIODevice) ConnectBytesWritten(f func(bytes int64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "bytesWritten") {
			C.QIODevice_ConnectBytesWritten(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bytesWritten")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "bytesWritten"); signal != nil {
			f := func(bytes int64) {
				(*(*func(int64))(signal))(bytes)
				f(bytes)
			}
			qt.ConnectSignal(ptr.Pointer(), "bytesWritten", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "bytesWritten", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectBytesWritten() {
	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectBytesWritten(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "bytesWritten")
	}
}

func (ptr *QIODevice) BytesWritten(bytes int64) {
	if ptr.Pointer() != nil {
		C.QIODevice_BytesWritten(ptr.Pointer(), C.longlong(bytes))
	}
}

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

	return C.char(int8(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).CanReadLineDefault())))
}

func (ptr *QIODevice) ConnectCanReadLine(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "canReadLine"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "canReadLine", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canReadLine", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectCanReadLine() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "canReadLine")
	}
}

func (ptr *QIODevice) CanReadLine() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_CanReadLine(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QIODevice) CanReadLineDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_CanReadLineDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQIODevice_ChannelBytesWritten
func callbackQIODevice_ChannelBytesWritten(ptr unsafe.Pointer, channel C.int, bytes C.longlong) {
	if signal := qt.GetSignal(ptr, "channelBytesWritten"); signal != nil {
		(*(*func(int, int64))(signal))(int(int32(channel)), int64(bytes))
	}

}

func (ptr *QIODevice) ConnectChannelBytesWritten(f func(channel int, bytes int64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "channelBytesWritten") {
			C.QIODevice_ConnectChannelBytesWritten(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "channelBytesWritten")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "channelBytesWritten"); signal != nil {
			f := func(channel int, bytes int64) {
				(*(*func(int, int64))(signal))(channel, bytes)
				f(channel, bytes)
			}
			qt.ConnectSignal(ptr.Pointer(), "channelBytesWritten", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "channelBytesWritten", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectChannelBytesWritten() {
	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectChannelBytesWritten(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "channelBytesWritten")
	}
}

func (ptr *QIODevice) ChannelBytesWritten(channel int, bytes int64) {
	if ptr.Pointer() != nil {
		C.QIODevice_ChannelBytesWritten(ptr.Pointer(), C.int(int32(channel)), C.longlong(bytes))
	}
}

//export callbackQIODevice_ChannelReadyRead
func callbackQIODevice_ChannelReadyRead(ptr unsafe.Pointer, channel C.int) {
	if signal := qt.GetSignal(ptr, "channelReadyRead"); signal != nil {
		(*(*func(int))(signal))(int(int32(channel)))
	}

}

func (ptr *QIODevice) ConnectChannelReadyRead(f func(channel int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "channelReadyRead") {
			C.QIODevice_ConnectChannelReadyRead(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "channelReadyRead")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "channelReadyRead"); signal != nil {
			f := func(channel int) {
				(*(*func(int))(signal))(channel)
				f(channel)
			}
			qt.ConnectSignal(ptr.Pointer(), "channelReadyRead", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "channelReadyRead", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectChannelReadyRead() {
	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectChannelReadyRead(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "channelReadyRead")
	}
}

func (ptr *QIODevice) ChannelReadyRead(channel int) {
	if ptr.Pointer() != nil {
		C.QIODevice_ChannelReadyRead(ptr.Pointer(), C.int(int32(channel)))
	}
}

//export callbackQIODevice_Close
func callbackQIODevice_Close(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "close"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQIODeviceFromPointer(ptr).CloseDefault()
	}
}

func (ptr *QIODevice) ConnectClose(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "close"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "close", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "close", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectClose() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "close")
	}
}

func (ptr *QIODevice) Close() {
	if ptr.Pointer() != nil {
		C.QIODevice_Close(ptr.Pointer())
	}
}

func (ptr *QIODevice) CloseDefault() {
	if ptr.Pointer() != nil {
		C.QIODevice_CloseDefault(ptr.Pointer())
	}
}

func (ptr *QIODevice) CommitTransaction() {
	if ptr.Pointer() != nil {
		C.QIODevice_CommitTransaction(ptr.Pointer())
	}
}

func (ptr *QIODevice) CurrentReadChannel() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QIODevice_CurrentReadChannel(ptr.Pointer())))
	}
	return 0
}

func (ptr *QIODevice) CurrentWriteChannel() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QIODevice_CurrentWriteChannel(ptr.Pointer())))
	}
	return 0
}

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

func (ptr *QIODevice) GetChar(c string) bool {
	if ptr.Pointer() != nil {
		var cC *C.char
		if c != "" {
			cC = C.CString(c)
			defer C.free(unsafe.Pointer(cC))
		}
		return int8(C.QIODevice_GetChar(ptr.Pointer(), cC)) != 0
	}
	return false
}

func (ptr *QIODevice) IsOpen() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_IsOpen(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QIODevice) IsReadable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_IsReadable(ptr.Pointer())) != 0
	}
	return false
}

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

	return C.char(int8(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).IsSequentialDefault())))
}

func (ptr *QIODevice) ConnectIsSequential(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isSequential"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "isSequential", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isSequential", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectIsSequential() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isSequential")
	}
}

func (ptr *QIODevice) IsSequential() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_IsSequential(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QIODevice) IsSequentialDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_IsSequentialDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QIODevice) IsTextModeEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_IsTextModeEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QIODevice) IsTransactionStarted() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_IsTransactionStarted(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QIODevice) IsWritable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_IsWritable(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQIODevice_Open
func callbackQIODevice_Open(ptr unsafe.Pointer, mode C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "open"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(QIODevice__OpenModeFlag) bool)(signal))(QIODevice__OpenModeFlag(mode)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).OpenDefault(QIODevice__OpenModeFlag(mode)))))
}

func (ptr *QIODevice) ConnectOpen(f func(mode QIODevice__OpenModeFlag) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "open"); signal != nil {
			f := func(mode QIODevice__OpenModeFlag) bool {
				(*(*func(QIODevice__OpenModeFlag) bool)(signal))(mode)
				return f(mode)
			}
			qt.ConnectSignal(ptr.Pointer(), "open", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "open", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectOpen() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "open")
	}
}

func (ptr *QIODevice) Open(mode QIODevice__OpenModeFlag) bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_Open(ptr.Pointer(), C.longlong(mode))) != 0
	}
	return false
}

func (ptr *QIODevice) OpenDefault(mode QIODevice__OpenModeFlag) bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_OpenDefault(ptr.Pointer(), C.longlong(mode))) != 0
	}
	return false
}

func (ptr *QIODevice) OpenMode() QIODevice__OpenModeFlag {
	if ptr.Pointer() != nil {
		return QIODevice__OpenModeFlag(C.QIODevice_OpenMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) Peek(data string, maxSize int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if data != "" {
			dataC = C.CString(data)
			defer C.free(unsafe.Pointer(dataC))
		}
		return int64(C.QIODevice_Peek(ptr.Pointer(), dataC, C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) Peek2(maxSize int64) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QIODevice_Peek2(ptr.Pointer(), C.longlong(maxSize)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

//export callbackQIODevice_Pos
func callbackQIODevice_Pos(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "pos"); signal != nil {
		return C.longlong((*(*func() int64)(signal))())
	}

	return C.longlong(NewQIODeviceFromPointer(ptr).PosDefault())
}

func (ptr *QIODevice) ConnectPos(f func() int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "pos"); signal != nil {
			f := func() int64 {
				(*(*func() int64)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "pos", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "pos", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectPos() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "pos")
	}
}

func (ptr *QIODevice) Pos() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Pos(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) PosDefault() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_PosDefault(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) PutChar(c string) bool {
	if ptr.Pointer() != nil {
		var cC *C.char
		if c != "" {
			cC = C.CString(c)
			defer C.free(unsafe.Pointer(cC))
		}
		return int8(C.QIODevice_PutChar(ptr.Pointer(), cC)) != 0
	}
	return false
}

func (ptr *QIODevice) Read(data []byte, maxSize int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QIODevice_Read(ptr.Pointer(), dataC, C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) Read2(maxSize int64) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QIODevice_Read2(ptr.Pointer(), C.longlong(maxSize)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QIODevice) ReadAll() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QIODevice_ReadAll(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QIODevice) ReadChannelCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QIODevice_ReadChannelCount(ptr.Pointer())))
	}
	return 0
}

//export callbackQIODevice_ReadChannelFinished
func callbackQIODevice_ReadChannelFinished(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "readChannelFinished"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QIODevice) ConnectReadChannelFinished(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "readChannelFinished") {
			C.QIODevice_ConnectReadChannelFinished(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "readChannelFinished")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "readChannelFinished"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "readChannelFinished", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "readChannelFinished", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectReadChannelFinished() {
	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectReadChannelFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "readChannelFinished")
	}
}

func (ptr *QIODevice) ReadChannelFinished() {
	if ptr.Pointer() != nil {
		C.QIODevice_ReadChannelFinished(ptr.Pointer())
	}
}

//export callbackQIODevice_ReadData
func callbackQIODevice_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, maxSize C.longlong) C.longlong {
	if signal := qt.GetSignal(ptr, "readData"); signal != nil {
		retS := cGoUnpackString(data)
		ret := C.longlong((*(*func(*string, int64) int64)(signal))(&retS, int64(maxSize)))
		if ret > 0 {
			C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&retS)).Data), C.size_t(ret))
		}
		return ret
	}

	return C.longlong(0)
}

func (ptr *QIODevice) ConnectReadData(f func(data *string, maxSize int64) int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "readData"); signal != nil {
			f := func(data *string, maxSize int64) int64 {
				(*(*func(*string, int64) int64)(signal))(data, maxSize)
				return f(data, maxSize)
			}
			qt.ConnectSignal(ptr.Pointer(), "readData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "readData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectReadData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "readData")
	}
}

func (ptr *QIODevice) ReadData(data *string, maxSize int64) int64 {
	if ptr.Pointer() != nil {
		dataC := C.CString(strings.Repeat("0", int(maxSize)))
		defer C.free(unsafe.Pointer(dataC))
		ret := int64(C.QIODevice_ReadData(ptr.Pointer(), dataC, C.longlong(maxSize)))
		if ret > 0 {
			*data = C.GoStringN(dataC, C.int(ret))
		}
		return ret
	}
	return 0
}

func (ptr *QIODevice) ReadLine(data []byte, maxSize int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QIODevice_ReadLine(ptr.Pointer(), dataC, C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) ReadLine2(maxSize int64) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QIODevice_ReadLine2(ptr.Pointer(), C.longlong(maxSize)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

//export callbackQIODevice_ReadLineData
func callbackQIODevice_ReadLineData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, maxSize C.longlong) C.longlong {
	if signal := qt.GetSignal(ptr, "readLineData"); signal != nil {
		return C.longlong((*(*func([]byte, int64) int64)(signal))(cGoUnpackBytes(data), int64(maxSize)))
	}

	return C.longlong(NewQIODeviceFromPointer(ptr).ReadLineDataDefault(cGoUnpackBytes(data), int64(maxSize)))
}

func (ptr *QIODevice) ConnectReadLineData(f func(data []byte, maxSize int64) int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "readLineData"); signal != nil {
			f := func(data []byte, maxSize int64) int64 {
				(*(*func([]byte, int64) int64)(signal))(data, maxSize)
				return f(data, maxSize)
			}
			qt.ConnectSignal(ptr.Pointer(), "readLineData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "readLineData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectReadLineData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "readLineData")
	}
}

func (ptr *QIODevice) ReadLineData(data []byte, maxSize int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QIODevice_ReadLineData(ptr.Pointer(), dataC, C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) ReadLineDataDefault(data []byte, maxSize int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QIODevice_ReadLineDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
	}
	return 0
}

//export callbackQIODevice_ReadyRead
func callbackQIODevice_ReadyRead(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "readyRead"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QIODevice) ConnectReadyRead(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "readyRead") {
			C.QIODevice_ConnectReadyRead(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "readyRead")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "readyRead"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "readyRead", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "readyRead", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectReadyRead() {
	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectReadyRead(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "readyRead")
	}
}

func (ptr *QIODevice) ReadyRead() {
	if ptr.Pointer() != nil {
		C.QIODevice_ReadyRead(ptr.Pointer())
	}
}

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

	return C.char(int8(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).ResetDefault())))
}

func (ptr *QIODevice) ConnectReset(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "reset"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectReset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "reset")
	}
}

func (ptr *QIODevice) Reset() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_Reset(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QIODevice) ResetDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_ResetDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QIODevice) RollbackTransaction() {
	if ptr.Pointer() != nil {
		C.QIODevice_RollbackTransaction(ptr.Pointer())
	}
}

//export callbackQIODevice_Seek
func callbackQIODevice_Seek(ptr unsafe.Pointer, pos C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "seek"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int64) bool)(signal))(int64(pos)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).SeekDefault(int64(pos)))))
}

func (ptr *QIODevice) ConnectSeek(f func(pos int64) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "seek"); signal != nil {
			f := func(pos int64) bool {
				(*(*func(int64) bool)(signal))(pos)
				return f(pos)
			}
			qt.ConnectSignal(ptr.Pointer(), "seek", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "seek", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectSeek() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "seek")
	}
}

func (ptr *QIODevice) Seek(pos int64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_Seek(ptr.Pointer(), C.longlong(pos))) != 0
	}
	return false
}

func (ptr *QIODevice) SeekDefault(pos int64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_SeekDefault(ptr.Pointer(), C.longlong(pos))) != 0
	}
	return false
}

func (ptr *QIODevice) SetCurrentReadChannel(channel int) {
	if ptr.Pointer() != nil {
		C.QIODevice_SetCurrentReadChannel(ptr.Pointer(), C.int(int32(channel)))
	}
}

func (ptr *QIODevice) SetCurrentWriteChannel(channel int) {
	if ptr.Pointer() != nil {
		C.QIODevice_SetCurrentWriteChannel(ptr.Pointer(), C.int(int32(channel)))
	}
}

func (ptr *QIODevice) SetErrorString(str string) {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		C.QIODevice_SetErrorString(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))})
	}
}

func (ptr *QIODevice) SetOpenMode(openMode QIODevice__OpenModeFlag) {
	if ptr.Pointer() != nil {
		C.QIODevice_SetOpenMode(ptr.Pointer(), C.longlong(openMode))
	}
}

func (ptr *QIODevice) SetTextModeEnabled(enabled bool) {
	if ptr.Pointer() != nil {
		C.QIODevice_SetTextModeEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

//export callbackQIODevice_Size
func callbackQIODevice_Size(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "size"); signal != nil {
		return C.longlong((*(*func() int64)(signal))())
	}

	return C.longlong(NewQIODeviceFromPointer(ptr).SizeDefault())
}

func (ptr *QIODevice) ConnectSize(f func() int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "size"); signal != nil {
			f := func() int64 {
				(*(*func() int64)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "size", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "size", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "size")
	}
}

func (ptr *QIODevice) Size() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) SizeDefault() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_SizeDefault(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) Skip(maxSize int64) int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Skip(ptr.Pointer(), C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) StartTransaction() {
	if ptr.Pointer() != nil {
		C.QIODevice_StartTransaction(ptr.Pointer())
	}
}

func (ptr *QIODevice) UngetChar(c string) {
	if ptr.Pointer() != nil {
		var cC *C.char
		if c != "" {
			cC = C.CString(c)
			defer C.free(unsafe.Pointer(cC))
		}
		C.QIODevice_UngetChar(ptr.Pointer(), cC)
	}
}

//export callbackQIODevice_WaitForBytesWritten
func callbackQIODevice_WaitForBytesWritten(ptr unsafe.Pointer, msecs C.int) C.char {
	if signal := qt.GetSignal(ptr, "waitForBytesWritten"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int) bool)(signal))(int(int32(msecs))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).WaitForBytesWrittenDefault(int(int32(msecs))))))
}

func (ptr *QIODevice) ConnectWaitForBytesWritten(f func(msecs int) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "waitForBytesWritten"); signal != nil {
			f := func(msecs int) bool {
				(*(*func(int) bool)(signal))(msecs)
				return f(msecs)
			}
			qt.ConnectSignal(ptr.Pointer(), "waitForBytesWritten", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "waitForBytesWritten", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectWaitForBytesWritten() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "waitForBytesWritten")
	}
}

func (ptr *QIODevice) WaitForBytesWritten(msecs int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_WaitForBytesWritten(ptr.Pointer(), C.int(int32(msecs)))) != 0
	}
	return false
}

func (ptr *QIODevice) WaitForBytesWrittenDefault(msecs int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_WaitForBytesWrittenDefault(ptr.Pointer(), C.int(int32(msecs)))) != 0
	}
	return false
}

//export callbackQIODevice_WaitForReadyRead
func callbackQIODevice_WaitForReadyRead(ptr unsafe.Pointer, msecs C.int) C.char {
	if signal := qt.GetSignal(ptr, "waitForReadyRead"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int) bool)(signal))(int(int32(msecs))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQIODeviceFromPointer(ptr).WaitForReadyReadDefault(int(int32(msecs))))))
}

func (ptr *QIODevice) ConnectWaitForReadyRead(f func(msecs int) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "waitForReadyRead"); signal != nil {
			f := func(msecs int) bool {
				(*(*func(int) bool)(signal))(msecs)
				return f(msecs)
			}
			qt.ConnectSignal(ptr.Pointer(), "waitForReadyRead", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "waitForReadyRead", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectWaitForReadyRead() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "waitForReadyRead")
	}
}

func (ptr *QIODevice) WaitForReadyRead(msecs int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_WaitForReadyRead(ptr.Pointer(), C.int(int32(msecs)))) != 0
	}
	return false
}

func (ptr *QIODevice) WaitForReadyReadDefault(msecs int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QIODevice_WaitForReadyReadDefault(ptr.Pointer(), C.int(int32(msecs)))) != 0
	}
	return false
}

func (ptr *QIODevice) Write(data []byte, maxSize int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QIODevice_Write(ptr.Pointer(), dataC, C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) Write2(data string) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if data != "" {
			dataC = C.CString(data)
			defer C.free(unsafe.Pointer(dataC))
		}
		return int64(C.QIODevice_Write2(ptr.Pointer(), dataC))
	}
	return 0
}

func (ptr *QIODevice) Write3(byteArray QByteArray_ITF) int64 {
	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Write3(ptr.Pointer(), PointerFromQByteArray(byteArray)))
	}
	return 0
}

func (ptr *QIODevice) WriteChannelCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QIODevice_WriteChannelCount(ptr.Pointer())))
	}
	return 0
}

//export callbackQIODevice_WriteData
func callbackQIODevice_WriteData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, maxSize C.longlong) C.longlong {
	if signal := qt.GetSignal(ptr, "writeData"); signal != nil {
		return C.longlong((*(*func([]byte, int64) int64)(signal))(cGoUnpackBytes(data), int64(maxSize)))
	}

	return C.longlong(0)
}

func (ptr *QIODevice) ConnectWriteData(f func(data []byte, maxSize int64) int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "writeData"); signal != nil {
			f := func(data []byte, maxSize int64) int64 {
				(*(*func([]byte, int64) int64)(signal))(data, maxSize)
				return f(data, maxSize)
			}
			qt.ConnectSignal(ptr.Pointer(), "writeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "writeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectWriteData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "writeData")
	}
}

func (ptr *QIODevice) WriteData(data []byte, maxSize int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QIODevice_WriteData(ptr.Pointer(), dataC, C.longlong(maxSize)))
	}
	return 0
}

//export callbackQIODevice_DestroyQIODevice
func callbackQIODevice_DestroyQIODevice(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QIODevice"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQIODeviceFromPointer(ptr).DestroyQIODeviceDefault()
	}
}

func (ptr *QIODevice) ConnectDestroyQIODevice(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QIODevice"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QIODevice", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QIODevice", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIODevice) DisconnectDestroyQIODevice() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QIODevice")
	}
}

func (ptr *QIODevice) DestroyQIODevice() {
	if ptr.Pointer() != nil {
		C.QIODevice_DestroyQIODevice(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QIODevice) DestroyQIODeviceDefault() {
	if ptr.Pointer() != nil {
		C.QIODevice_DestroyQIODeviceDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QIdentityProxyModel struct {
	QAbstractProxyModel
}

type QIdentityProxyModel_ITF interface {
	QAbstractProxyModel_ITF
	QIdentityProxyModel_PTR() *QIdentityProxyModel
}

func (ptr *QIdentityProxyModel) QIdentityProxyModel_PTR() *QIdentityProxyModel {
	return ptr
}

func (ptr *QIdentityProxyModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractProxyModel_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQIdentityProxyModel(ptr QIdentityProxyModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIdentityProxyModel_PTR().Pointer()
	}
	return nil
}

func NewQIdentityProxyModelFromPointer(ptr unsafe.Pointer) (n *QIdentityProxyModel) {
	n = new(QIdentityProxyModel)
	n.SetPointer(ptr)
	return
}
func NewQIdentityProxyModel(parent QObject_ITF) *QIdentityProxyModel {
	tmpValue := NewQIdentityProxyModelFromPointer(C.QIdentityProxyModel_NewQIdentityProxyModel(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQIdentityProxyModel_ColumnCount
func callbackQIdentityProxyModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQIdentityProxyModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QIdentityProxyModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIdentityProxyModel) DisconnectColumnCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnCount")
	}
}

func (ptr *QIdentityProxyModel) ColumnCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QIdentityProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QIdentityProxyModel) ColumnCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QIdentityProxyModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQIdentityProxyModel_Index
func callbackQIdentityProxyModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return PointerFromQModelIndex((*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
	}

	return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).IndexDefault(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
}

func (ptr *QIdentityProxyModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "index"); signal != nil {
			f := func(row int, column int, parent *QModelIndex) *QModelIndex {
				(*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(row, column, parent)
				return f(row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIdentityProxyModel) DisconnectIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "index")
	}
}

func (ptr *QIdentityProxyModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QIdentityProxyModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QIdentityProxyModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QIdentityProxyModel_IndexDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQIdentityProxyModel_MapFromSource
func callbackQIdentityProxyModel_MapFromSource(ptr unsafe.Pointer, sourceIndex unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapFromSource"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(sourceIndex)))
	}

	return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).MapFromSourceDefault(NewQModelIndexFromPointer(sourceIndex)))
}

func (ptr *QIdentityProxyModel) ConnectMapFromSource(f func(sourceIndex *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapFromSource"); signal != nil {
			f := func(sourceIndex *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(sourceIndex)
				return f(sourceIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapFromSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapFromSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIdentityProxyModel) DisconnectMapFromSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapFromSource")
	}
}

func (ptr *QIdentityProxyModel) MapFromSource(sourceIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QIdentityProxyModel_MapFromSource(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QIdentityProxyModel) MapFromSourceDefault(sourceIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QIdentityProxyModel_MapFromSourceDefault(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQIdentityProxyModel_MapToSource
func callbackQIdentityProxyModel_MapToSource(ptr unsafe.Pointer, proxyIndex unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapToSource"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(proxyIndex)))
	}

	return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).MapToSourceDefault(NewQModelIndexFromPointer(proxyIndex)))
}

func (ptr *QIdentityProxyModel) ConnectMapToSource(f func(proxyIndex *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapToSource"); signal != nil {
			f := func(proxyIndex *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(proxyIndex)
				return f(proxyIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapToSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapToSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIdentityProxyModel) DisconnectMapToSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapToSource")
	}
}

func (ptr *QIdentityProxyModel) MapToSource(proxyIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QIdentityProxyModel_MapToSource(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QIdentityProxyModel) MapToSourceDefault(proxyIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QIdentityProxyModel_MapToSourceDefault(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQIdentityProxyModel_Parent
func callbackQIdentityProxyModel_Parent(ptr unsafe.Pointer, child unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(child)))
	}

	return PointerFromQModelIndex(NewQIdentityProxyModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(child)))
}

func (ptr *QIdentityProxyModel) ConnectParent(f func(child *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "parent"); signal != nil {
			f := func(child *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(child)
				return f(child)
			}
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIdentityProxyModel) DisconnectParent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "parent")
	}
}

func (ptr *QIdentityProxyModel) Parent(child QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QIdentityProxyModel_Parent(ptr.Pointer(), PointerFromQModelIndex(child)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QIdentityProxyModel) ParentDefault(child QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QIdentityProxyModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(child)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQIdentityProxyModel_RowCount
func callbackQIdentityProxyModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQIdentityProxyModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QIdentityProxyModel) ConnectRowCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIdentityProxyModel) DisconnectRowCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowCount")
	}
}

func (ptr *QIdentityProxyModel) RowCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QIdentityProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QIdentityProxyModel) RowCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QIdentityProxyModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQIdentityProxyModel_DestroyQIdentityProxyModel
func callbackQIdentityProxyModel_DestroyQIdentityProxyModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QIdentityProxyModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQIdentityProxyModelFromPointer(ptr).DestroyQIdentityProxyModelDefault()
	}
}

func (ptr *QIdentityProxyModel) ConnectDestroyQIdentityProxyModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QIdentityProxyModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QIdentityProxyModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QIdentityProxyModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QIdentityProxyModel) DisconnectDestroyQIdentityProxyModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QIdentityProxyModel")
	}
}

func (ptr *QIdentityProxyModel) DestroyQIdentityProxyModel() {
	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_DestroyQIdentityProxyModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QIdentityProxyModel) DestroyQIdentityProxyModelDefault() {
	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_DestroyQIdentityProxyModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QIncompatibleFlag struct {
	ptr unsafe.Pointer
}

type QIncompatibleFlag_ITF interface {
	QIncompatibleFlag_PTR() *QIncompatibleFlag
}

func (ptr *QIncompatibleFlag) QIncompatibleFlag_PTR() *QIncompatibleFlag {
	return ptr
}

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

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

func PointerFromQIncompatibleFlag(ptr QIncompatibleFlag_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIncompatibleFlag_PTR().Pointer()
	}
	return nil
}

func NewQIncompatibleFlagFromPointer(ptr unsafe.Pointer) (n *QIncompatibleFlag) {
	n = new(QIncompatibleFlag)
	n.SetPointer(ptr)
	return
}

func (ptr *QIncompatibleFlag) DestroyQIncompatibleFlag() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QInternal struct {
	ptr unsafe.Pointer
}

type QInternal_ITF interface {
	QInternal_PTR() *QInternal
}

func (ptr *QInternal) QInternal_PTR() *QInternal {
	return ptr
}

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

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

func PointerFromQInternal(ptr QInternal_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QInternal_PTR().Pointer()
	}
	return nil
}

func NewQInternalFromPointer(ptr unsafe.Pointer) (n *QInternal) {
	n = new(QInternal)
	n.SetPointer(ptr)
	return
}

func (ptr *QInternal) DestroyQInternal() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QItemSelection struct {
	ptr unsafe.Pointer
}

type QItemSelection_ITF interface {
	QItemSelection_PTR() *QItemSelection
}

func (ptr *QItemSelection) QItemSelection_PTR() *QItemSelection {
	return ptr
}

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

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

func PointerFromQItemSelection(ptr QItemSelection_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemSelection_PTR().Pointer()
	}
	return nil
}

func NewQItemSelectionFromPointer(ptr unsafe.Pointer) (n *QItemSelection) {
	n = new(QItemSelection)
	n.SetPointer(ptr)
	return
}

func (ptr *QItemSelection) DestroyQItemSelection() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQItemSelection() *QItemSelection {
	tmpValue := NewQItemSelectionFromPointer(C.QItemSelection_NewQItemSelection())
	runtime.SetFinalizer(tmpValue, (*QItemSelection).DestroyQItemSelection)
	return tmpValue
}

func NewQItemSelection2(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF) *QItemSelection {
	tmpValue := NewQItemSelectionFromPointer(C.QItemSelection_NewQItemSelection2(PointerFromQModelIndex(topLeft), PointerFromQModelIndex(bottomRight)))
	runtime.SetFinalizer(tmpValue, (*QItemSelection).DestroyQItemSelection)
	return tmpValue
}

func (ptr *QItemSelection) Contains(index QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelection_Contains(ptr.Pointer(), PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QItemSelection) Indexes() []*QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
			out := make([]*QModelIndex, int(l.len))
			tmpList := NewQItemSelectionFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__indexes_atList(i)
			}
			return out
		}(C.QItemSelection_Indexes(ptr.Pointer()))
	}
	return make([]*QModelIndex, 0)
}

func (ptr *QItemSelection) Merge(other QItemSelection_ITF, command QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QItemSelection_Merge(ptr.Pointer(), PointerFromQItemSelection(other), C.longlong(command))
	}
}

func (ptr *QItemSelection) Select(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelection_Select(ptr.Pointer(), PointerFromQModelIndex(topLeft), PointerFromQModelIndex(bottomRight))
	}
}

func QItemSelection_Split(ran QItemSelectionRange_ITF, other QItemSelectionRange_ITF, result QItemSelection_ITF) {
	C.QItemSelection_QItemSelection_Split(PointerFromQItemSelectionRange(ran), PointerFromQItemSelectionRange(other), PointerFromQItemSelection(result))
}

func (ptr *QItemSelection) Split(ran QItemSelectionRange_ITF, other QItemSelectionRange_ITF, result QItemSelection_ITF) {
	C.QItemSelection_QItemSelection_Split(PointerFromQItemSelectionRange(ran), PointerFromQItemSelectionRange(other), PointerFromQItemSelection(result))
}

func (ptr *QItemSelection) __indexes_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QItemSelection___indexes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QItemSelection) __indexes_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelection___indexes_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QItemSelection) __indexes_newList() unsafe.Pointer {
	return C.QItemSelection___indexes_newList(ptr.Pointer())
}

type QItemSelectionModel struct {
	QObject
}

type QItemSelectionModel_ITF interface {
	QObject_ITF
	QItemSelectionModel_PTR() *QItemSelectionModel
}

func (ptr *QItemSelectionModel) QItemSelectionModel_PTR() *QItemSelectionModel {
	return ptr
}

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

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

func PointerFromQItemSelectionModel(ptr QItemSelectionModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemSelectionModel_PTR().Pointer()
	}
	return nil
}

func NewQItemSelectionModelFromPointer(ptr unsafe.Pointer) (n *QItemSelectionModel) {
	n = new(QItemSelectionModel)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QItemSelectionModel__SelectionFlag
//QItemSelectionModel::SelectionFlag
type QItemSelectionModel__SelectionFlag int64

const (
	QItemSelectionModel__NoUpdate       QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(0x0000)
	QItemSelectionModel__Clear          QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(0x0001)
	QItemSelectionModel__Select         QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(0x0002)
	QItemSelectionModel__Deselect       QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(0x0004)
	QItemSelectionModel__Toggle         QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(0x0008)
	QItemSelectionModel__Current        QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(0x0010)
	QItemSelectionModel__Rows           QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(0x0020)
	QItemSelectionModel__Columns        QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(0x0040)
	QItemSelectionModel__SelectCurrent  QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(QItemSelectionModel__Select | QItemSelectionModel__Current)
	QItemSelectionModel__ToggleCurrent  QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(QItemSelectionModel__Toggle | QItemSelectionModel__Current)
	QItemSelectionModel__ClearAndSelect QItemSelectionModel__SelectionFlag = QItemSelectionModel__SelectionFlag(QItemSelectionModel__Clear | QItemSelectionModel__Select)
)

func NewQItemSelectionModel(model QAbstractItemModel_ITF) *QItemSelectionModel {
	tmpValue := NewQItemSelectionModelFromPointer(C.QItemSelectionModel_NewQItemSelectionModel(PointerFromQAbstractItemModel(model)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQItemSelectionModel2(model QAbstractItemModel_ITF, parent QObject_ITF) *QItemSelectionModel {
	tmpValue := NewQItemSelectionModelFromPointer(C.QItemSelectionModel_NewQItemSelectionModel2(PointerFromQAbstractItemModel(model), PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQItemSelectionModel_Clear
func callbackQItemSelectionModel_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQItemSelectionModelFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QItemSelectionModel) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QItemSelectionModel) Clear() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_Clear(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ClearDefault(ptr.Pointer())
	}
}

//export callbackQItemSelectionModel_ClearCurrentIndex
func callbackQItemSelectionModel_ClearCurrentIndex(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clearCurrentIndex"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQItemSelectionModelFromPointer(ptr).ClearCurrentIndexDefault()
	}
}

func (ptr *QItemSelectionModel) ConnectClearCurrentIndex(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clearCurrentIndex"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clearCurrentIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clearCurrentIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectClearCurrentIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clearCurrentIndex")
	}
}

func (ptr *QItemSelectionModel) ClearCurrentIndex() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ClearCurrentIndex(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ClearCurrentIndexDefault() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ClearCurrentIndexDefault(ptr.Pointer())
	}
}

//export callbackQItemSelectionModel_ClearSelection
func callbackQItemSelectionModel_ClearSelection(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clearSelection"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQItemSelectionModelFromPointer(ptr).ClearSelectionDefault()
	}
}

func (ptr *QItemSelectionModel) ConnectClearSelection(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clearSelection"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clearSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clearSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectClearSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clearSelection")
	}
}

func (ptr *QItemSelectionModel) ClearSelection() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ClearSelection(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ClearSelectionDefault() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ClearSelectionDefault(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ColumnIntersectsSelection(column int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionModel_ColumnIntersectsSelection(ptr.Pointer(), C.int(int32(column)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQItemSelectionModel_CurrentChanged
func callbackQItemSelectionModel_CurrentChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(*QModelIndex, *QModelIndex))(signal))(NewQModelIndexFromPointer(current), NewQModelIndexFromPointer(previous))
	}

}

func (ptr *QItemSelectionModel) ConnectCurrentChanged(f func(current *QModelIndex, previous *QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentChanged") {
			C.QItemSelectionModel_ConnectCurrentChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(current *QModelIndex, previous *QModelIndex) {
				(*(*func(*QModelIndex, *QModelIndex))(signal))(current, previous)
				f(current, previous)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_DisconnectCurrentChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QItemSelectionModel) CurrentChanged(current QModelIndex_ITF, previous QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_CurrentChanged(ptr.Pointer(), PointerFromQModelIndex(current), PointerFromQModelIndex(previous))
	}
}

//export callbackQItemSelectionModel_CurrentColumnChanged
func callbackQItemSelectionModel_CurrentColumnChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentColumnChanged"); signal != nil {
		(*(*func(*QModelIndex, *QModelIndex))(signal))(NewQModelIndexFromPointer(current), NewQModelIndexFromPointer(previous))
	}

}

func (ptr *QItemSelectionModel) ConnectCurrentColumnChanged(f func(current *QModelIndex, previous *QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentColumnChanged") {
			C.QItemSelectionModel_ConnectCurrentColumnChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentColumnChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentColumnChanged"); signal != nil {
			f := func(current *QModelIndex, previous *QModelIndex) {
				(*(*func(*QModelIndex, *QModelIndex))(signal))(current, previous)
				f(current, previous)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentColumnChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentColumnChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectCurrentColumnChanged() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_DisconnectCurrentColumnChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentColumnChanged")
	}
}

func (ptr *QItemSelectionModel) CurrentColumnChanged(current QModelIndex_ITF, previous QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_CurrentColumnChanged(ptr.Pointer(), PointerFromQModelIndex(current), PointerFromQModelIndex(previous))
	}
}

func (ptr *QItemSelectionModel) CurrentIndex() *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QItemSelectionModel_CurrentIndex(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQItemSelectionModel_CurrentRowChanged
func callbackQItemSelectionModel_CurrentRowChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentRowChanged"); signal != nil {
		(*(*func(*QModelIndex, *QModelIndex))(signal))(NewQModelIndexFromPointer(current), NewQModelIndexFromPointer(previous))
	}

}

func (ptr *QItemSelectionModel) ConnectCurrentRowChanged(f func(current *QModelIndex, previous *QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentRowChanged") {
			C.QItemSelectionModel_ConnectCurrentRowChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentRowChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentRowChanged"); signal != nil {
			f := func(current *QModelIndex, previous *QModelIndex) {
				(*(*func(*QModelIndex, *QModelIndex))(signal))(current, previous)
				f(current, previous)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentRowChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentRowChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectCurrentRowChanged() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_DisconnectCurrentRowChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentRowChanged")
	}
}

func (ptr *QItemSelectionModel) CurrentRowChanged(current QModelIndex_ITF, previous QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_CurrentRowChanged(ptr.Pointer(), PointerFromQModelIndex(current), PointerFromQModelIndex(previous))
	}
}

func (ptr *QItemSelectionModel) EmitSelectionChanged(newSelection QItemSelection_ITF, oldSelection QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_EmitSelectionChanged(ptr.Pointer(), PointerFromQItemSelection(newSelection), PointerFromQItemSelection(oldSelection))
	}
}

func (ptr *QItemSelectionModel) HasSelection() bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionModel_HasSelection(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) IsColumnSelected(column int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionModel_IsColumnSelected(ptr.Pointer(), C.int(int32(column)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) IsRowSelected(row int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionModel_IsRowSelected(ptr.Pointer(), C.int(int32(row)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) IsSelected(index QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionModel_IsSelected(ptr.Pointer(), PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) Model() *QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemModelFromPointer(C.QItemSelectionModel_Model(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QItemSelectionModel) Model2() *QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemModelFromPointer(C.QItemSelectionModel_Model2(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQItemSelectionModel_ModelChanged
func callbackQItemSelectionModel_ModelChanged(ptr unsafe.Pointer, model unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "modelChanged"); signal != nil {
		(*(*func(*QAbstractItemModel))(signal))(NewQAbstractItemModelFromPointer(model))
	}

}

func (ptr *QItemSelectionModel) ConnectModelChanged(f func(model *QAbstractItemModel)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "modelChanged") {
			C.QItemSelectionModel_ConnectModelChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "modelChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "modelChanged"); signal != nil {
			f := func(model *QAbstractItemModel) {
				(*(*func(*QAbstractItemModel))(signal))(model)
				f(model)
			}
			qt.ConnectSignal(ptr.Pointer(), "modelChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "modelChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectModelChanged() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_DisconnectModelChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "modelChanged")
	}
}

func (ptr *QItemSelectionModel) ModelChanged(model QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ModelChanged(ptr.Pointer(), PointerFromQAbstractItemModel(model))
	}
}

//export callbackQItemSelectionModel_Reset
func callbackQItemSelectionModel_Reset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "reset"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQItemSelectionModelFromPointer(ptr).ResetDefault()
	}
}

func (ptr *QItemSelectionModel) ConnectReset(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "reset"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectReset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "reset")
	}
}

func (ptr *QItemSelectionModel) Reset() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_Reset(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ResetDefault() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ResetDefault(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) RowIntersectsSelection(row int, parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionModel_RowIntersectsSelection(ptr.Pointer(), C.int(int32(row)), PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQItemSelectionModel_Select
func callbackQItemSelectionModel_Select(ptr unsafe.Pointer, index unsafe.Pointer, command C.longlong) {
	if signal := qt.GetSignal(ptr, "select"); signal != nil {
		(*(*func(*QModelIndex, QItemSelectionModel__SelectionFlag))(signal))(NewQModelIndexFromPointer(index), QItemSelectionModel__SelectionFlag(command))
	} else {
		NewQItemSelectionModelFromPointer(ptr).SelectDefault(NewQModelIndexFromPointer(index), QItemSelectionModel__SelectionFlag(command))
	}
}

func (ptr *QItemSelectionModel) ConnectSelect(f func(index *QModelIndex, command QItemSelectionModel__SelectionFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "select"); signal != nil {
			f := func(index *QModelIndex, command QItemSelectionModel__SelectionFlag) {
				(*(*func(*QModelIndex, QItemSelectionModel__SelectionFlag))(signal))(index, command)
				f(index, command)
			}
			qt.ConnectSignal(ptr.Pointer(), "select", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "select", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectSelect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "select")
	}
}

func (ptr *QItemSelectionModel) Select(index QModelIndex_ITF, command QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_Select(ptr.Pointer(), PointerFromQModelIndex(index), C.longlong(command))
	}
}

func (ptr *QItemSelectionModel) SelectDefault(index QModelIndex_ITF, command QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_SelectDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.longlong(command))
	}
}

//export callbackQItemSelectionModel_Select2
func callbackQItemSelectionModel_Select2(ptr unsafe.Pointer, selection unsafe.Pointer, command C.longlong) {
	if signal := qt.GetSignal(ptr, "select2"); signal != nil {
		(*(*func(*QItemSelection, QItemSelectionModel__SelectionFlag))(signal))(NewQItemSelectionFromPointer(selection), QItemSelectionModel__SelectionFlag(command))
	} else {
		NewQItemSelectionModelFromPointer(ptr).Select2Default(NewQItemSelectionFromPointer(selection), QItemSelectionModel__SelectionFlag(command))
	}
}

func (ptr *QItemSelectionModel) ConnectSelect2(f func(selection *QItemSelection, command QItemSelectionModel__SelectionFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "select2"); signal != nil {
			f := func(selection *QItemSelection, command QItemSelectionModel__SelectionFlag) {
				(*(*func(*QItemSelection, QItemSelectionModel__SelectionFlag))(signal))(selection, command)
				f(selection, command)
			}
			qt.ConnectSignal(ptr.Pointer(), "select2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "select2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectSelect2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "select2")
	}
}

func (ptr *QItemSelectionModel) Select2(selection QItemSelection_ITF, command QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_Select2(ptr.Pointer(), PointerFromQItemSelection(selection), C.longlong(command))
	}
}

func (ptr *QItemSelectionModel) Select2Default(selection QItemSelection_ITF, command QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_Select2Default(ptr.Pointer(), PointerFromQItemSelection(selection), C.longlong(command))
	}
}

func (ptr *QItemSelectionModel) SelectedColumns(row int) []*QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
			out := make([]*QModelIndex, int(l.len))
			tmpList := NewQItemSelectionModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedColumns_atList(i)
			}
			return out
		}(C.QItemSelectionModel_SelectedColumns(ptr.Pointer(), C.int(int32(row))))
	}
	return make([]*QModelIndex, 0)
}

func (ptr *QItemSelectionModel) SelectedIndexes() []*QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
			out := make([]*QModelIndex, int(l.len))
			tmpList := NewQItemSelectionModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedIndexes_atList(i)
			}
			return out
		}(C.QItemSelectionModel_SelectedIndexes(ptr.Pointer()))
	}
	return make([]*QModelIndex, 0)
}

func (ptr *QItemSelectionModel) SelectedRows(column int) []*QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
			out := make([]*QModelIndex, int(l.len))
			tmpList := NewQItemSelectionModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedRows_atList(i)
			}
			return out
		}(C.QItemSelectionModel_SelectedRows(ptr.Pointer(), C.int(int32(column))))
	}
	return make([]*QModelIndex, 0)
}

func (ptr *QItemSelectionModel) Selection() *QItemSelection {
	if ptr.Pointer() != nil {
		tmpValue := NewQItemSelectionFromPointer(C.QItemSelectionModel_Selection(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QItemSelection).DestroyQItemSelection)
		return tmpValue
	}
	return nil
}

//export callbackQItemSelectionModel_SelectionChanged
func callbackQItemSelectionModel_SelectionChanged(ptr unsafe.Pointer, selected unsafe.Pointer, deselected unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
		(*(*func(*QItemSelection, *QItemSelection))(signal))(NewQItemSelectionFromPointer(selected), NewQItemSelectionFromPointer(deselected))
	}

}

func (ptr *QItemSelectionModel) ConnectSelectionChanged(f func(selected *QItemSelection, deselected *QItemSelection)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "selectionChanged") {
			C.QItemSelectionModel_ConnectSelectionChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "selectionChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "selectionChanged"); signal != nil {
			f := func(selected *QItemSelection, deselected *QItemSelection) {
				(*(*func(*QItemSelection, *QItemSelection))(signal))(selected, deselected)
				f(selected, deselected)
			}
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_DisconnectSelectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "selectionChanged")
	}
}

func (ptr *QItemSelectionModel) SelectionChanged(selected QItemSelection_ITF, deselected QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_SelectionChanged(ptr.Pointer(), PointerFromQItemSelection(selected), PointerFromQItemSelection(deselected))
	}
}

//export callbackQItemSelectionModel_SetCurrentIndex
func callbackQItemSelectionModel_SetCurrentIndex(ptr unsafe.Pointer, index unsafe.Pointer, command C.longlong) {
	if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
		(*(*func(*QModelIndex, QItemSelectionModel__SelectionFlag))(signal))(NewQModelIndexFromPointer(index), QItemSelectionModel__SelectionFlag(command))
	} else {
		NewQItemSelectionModelFromPointer(ptr).SetCurrentIndexDefault(NewQModelIndexFromPointer(index), QItemSelectionModel__SelectionFlag(command))
	}
}

func (ptr *QItemSelectionModel) ConnectSetCurrentIndex(f func(index *QModelIndex, command QItemSelectionModel__SelectionFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentIndex"); signal != nil {
			f := func(index *QModelIndex, command QItemSelectionModel__SelectionFlag) {
				(*(*func(*QModelIndex, QItemSelectionModel__SelectionFlag))(signal))(index, command)
				f(index, command)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectSetCurrentIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentIndex")
	}
}

func (ptr *QItemSelectionModel) SetCurrentIndex(index QModelIndex_ITF, command QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_SetCurrentIndex(ptr.Pointer(), PointerFromQModelIndex(index), C.longlong(command))
	}
}

func (ptr *QItemSelectionModel) SetCurrentIndexDefault(index QModelIndex_ITF, command QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_SetCurrentIndexDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.longlong(command))
	}
}

func (ptr *QItemSelectionModel) SetModel(model QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_SetModel(ptr.Pointer(), PointerFromQAbstractItemModel(model))
	}
}

//export callbackQItemSelectionModel_DestroyQItemSelectionModel
func callbackQItemSelectionModel_DestroyQItemSelectionModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QItemSelectionModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQItemSelectionModelFromPointer(ptr).DestroyQItemSelectionModelDefault()
	}
}

func (ptr *QItemSelectionModel) ConnectDestroyQItemSelectionModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QItemSelectionModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QItemSelectionModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QItemSelectionModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemSelectionModel) DisconnectDestroyQItemSelectionModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QItemSelectionModel")
	}
}

func (ptr *QItemSelectionModel) DestroyQItemSelectionModel() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_DestroyQItemSelectionModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QItemSelectionModel) DestroyQItemSelectionModelDefault() {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel_DestroyQItemSelectionModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QItemSelectionModel) __selectedColumns_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QItemSelectionModel___selectedColumns_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QItemSelectionModel) __selectedColumns_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel___selectedColumns_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QItemSelectionModel) __selectedColumns_newList() unsafe.Pointer {
	return C.QItemSelectionModel___selectedColumns_newList(ptr.Pointer())
}

func (ptr *QItemSelectionModel) __selectedIndexes_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QItemSelectionModel___selectedIndexes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QItemSelectionModel) __selectedIndexes_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel___selectedIndexes_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QItemSelectionModel) __selectedIndexes_newList() unsafe.Pointer {
	return C.QItemSelectionModel___selectedIndexes_newList(ptr.Pointer())
}

func (ptr *QItemSelectionModel) __selectedRows_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QItemSelectionModel___selectedRows_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QItemSelectionModel) __selectedRows_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionModel___selectedRows_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QItemSelectionModel) __selectedRows_newList() unsafe.Pointer {
	return C.QItemSelectionModel___selectedRows_newList(ptr.Pointer())
}

type QItemSelectionRange struct {
	ptr unsafe.Pointer
}

type QItemSelectionRange_ITF interface {
	QItemSelectionRange_PTR() *QItemSelectionRange
}

func (ptr *QItemSelectionRange) QItemSelectionRange_PTR() *QItemSelectionRange {
	return ptr
}

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

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

func PointerFromQItemSelectionRange(ptr QItemSelectionRange_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemSelectionRange_PTR().Pointer()
	}
	return nil
}

func NewQItemSelectionRangeFromPointer(ptr unsafe.Pointer) (n *QItemSelectionRange) {
	n = new(QItemSelectionRange)
	n.SetPointer(ptr)
	return
}

func (ptr *QItemSelectionRange) DestroyQItemSelectionRange() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQItemSelectionRange() *QItemSelectionRange {
	tmpValue := NewQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange())
	runtime.SetFinalizer(tmpValue, (*QItemSelectionRange).DestroyQItemSelectionRange)
	return tmpValue
}

func NewQItemSelectionRange2(other QItemSelectionRange_ITF) *QItemSelectionRange {
	tmpValue := NewQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange2(PointerFromQItemSelectionRange(other)))
	runtime.SetFinalizer(tmpValue, (*QItemSelectionRange).DestroyQItemSelectionRange)
	return tmpValue
}

func NewQItemSelectionRange4(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF) *QItemSelectionRange {
	tmpValue := NewQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange4(PointerFromQModelIndex(topLeft), PointerFromQModelIndex(bottomRight)))
	runtime.SetFinalizer(tmpValue, (*QItemSelectionRange).DestroyQItemSelectionRange)
	return tmpValue
}

func NewQItemSelectionRange5(index QModelIndex_ITF) *QItemSelectionRange {
	tmpValue := NewQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange5(PointerFromQModelIndex(index)))
	runtime.SetFinalizer(tmpValue, (*QItemSelectionRange).DestroyQItemSelectionRange)
	return tmpValue
}

func (ptr *QItemSelectionRange) Bottom() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QItemSelectionRange_Bottom(ptr.Pointer())))
	}
	return 0
}

func (ptr *QItemSelectionRange) BottomRight() *QPersistentModelIndex {
	if ptr.Pointer() != nil {
		return NewQPersistentModelIndexFromPointer(C.QItemSelectionRange_BottomRight(ptr.Pointer()))
	}
	return nil
}

func (ptr *QItemSelectionRange) Contains(index QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionRange_Contains(ptr.Pointer(), PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QItemSelectionRange) Contains2(row int, column int, parentIndex QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionRange_Contains2(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parentIndex))) != 0
	}
	return false
}

func (ptr *QItemSelectionRange) Height() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QItemSelectionRange_Height(ptr.Pointer())))
	}
	return 0
}

func (ptr *QItemSelectionRange) Indexes() []*QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
			out := make([]*QModelIndex, int(l.len))
			tmpList := NewQItemSelectionRangeFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__indexes_atList(i)
			}
			return out
		}(C.QItemSelectionRange_Indexes(ptr.Pointer()))
	}
	return make([]*QModelIndex, 0)
}

func (ptr *QItemSelectionRange) Intersected(other QItemSelectionRange_ITF) *QItemSelectionRange {
	if ptr.Pointer() != nil {
		tmpValue := NewQItemSelectionRangeFromPointer(C.QItemSelectionRange_Intersected(ptr.Pointer(), PointerFromQItemSelectionRange(other)))
		runtime.SetFinalizer(tmpValue, (*QItemSelectionRange).DestroyQItemSelectionRange)
		return tmpValue
	}
	return nil
}

func (ptr *QItemSelectionRange) Intersects(other QItemSelectionRange_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionRange_Intersects(ptr.Pointer(), PointerFromQItemSelectionRange(other))) != 0
	}
	return false
}

func (ptr *QItemSelectionRange) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionRange_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QItemSelectionRange) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemSelectionRange_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QItemSelectionRange) Left() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QItemSelectionRange_Left(ptr.Pointer())))
	}
	return 0
}

func (ptr *QItemSelectionRange) Model() *QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemModelFromPointer(C.QItemSelectionRange_Model(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QItemSelectionRange) Parent() *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QItemSelectionRange_Parent(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QItemSelectionRange) Right() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QItemSelectionRange_Right(ptr.Pointer())))
	}
	return 0
}

func (ptr *QItemSelectionRange) Swap(other QItemSelectionRange_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionRange_Swap(ptr.Pointer(), PointerFromQItemSelectionRange(other))
	}
}

func (ptr *QItemSelectionRange) Top() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QItemSelectionRange_Top(ptr.Pointer())))
	}
	return 0
}

func (ptr *QItemSelectionRange) TopLeft() *QPersistentModelIndex {
	if ptr.Pointer() != nil {
		return NewQPersistentModelIndexFromPointer(C.QItemSelectionRange_TopLeft(ptr.Pointer()))
	}
	return nil
}

func (ptr *QItemSelectionRange) Width() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QItemSelectionRange_Width(ptr.Pointer())))
	}
	return 0
}

func (ptr *QItemSelectionRange) __indexes_atList(i int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QItemSelectionRange___indexes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QItemSelectionRange) __indexes_setList(i QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemSelectionRange___indexes_setList(ptr.Pointer(), PointerFromQModelIndex(i))
	}
}

func (ptr *QItemSelectionRange) __indexes_newList() unsafe.Pointer {
	return C.QItemSelectionRange___indexes_newList(ptr.Pointer())
}

type QJsonArray struct {
	ptr unsafe.Pointer
}

type QJsonArray_ITF interface {
	QJsonArray_PTR() *QJsonArray
}

func (ptr *QJsonArray) QJsonArray_PTR() *QJsonArray {
	return ptr
}

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

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

func PointerFromQJsonArray(ptr QJsonArray_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonArray_PTR().Pointer()
	}
	return nil
}

func NewQJsonArrayFromPointer(ptr unsafe.Pointer) (n *QJsonArray) {
	n = new(QJsonArray)
	n.SetPointer(ptr)
	return
}
func NewQJsonArray() *QJsonArray {
	tmpValue := NewQJsonArrayFromPointer(C.QJsonArray_NewQJsonArray())
	runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
	return tmpValue
}

func NewQJsonArray3(other QJsonArray_ITF) *QJsonArray {
	tmpValue := NewQJsonArrayFromPointer(C.QJsonArray_NewQJsonArray3(PointerFromQJsonArray(other)))
	runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
	return tmpValue
}

func NewQJsonArray4(other QJsonArray_ITF) *QJsonArray {
	tmpValue := NewQJsonArrayFromPointer(C.QJsonArray_NewQJsonArray4(PointerFromQJsonArray(other)))
	runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
	return tmpValue
}

func (ptr *QJsonArray) Append(value QJsonValue_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonArray_Append(ptr.Pointer(), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) At(i int) *QJsonValue {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonValueFromPointer(C.QJsonArray_At(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonArray) Contains(value QJsonValue_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonArray_Contains(ptr.Pointer(), PointerFromQJsonValue(value))) != 0
	}
	return false
}

func (ptr *QJsonArray) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QJsonArray_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QJsonArray) Empty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonArray_Empty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonArray) First() *QJsonValue {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonValueFromPointer(C.QJsonArray_First(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
		return tmpValue
	}
	return nil
}

func QJsonArray_FromStringList(list []string) *QJsonArray {
	listC := C.CString(strings.Join(list, "¡¦!"))
	defer C.free(unsafe.Pointer(listC))
	tmpValue := NewQJsonArrayFromPointer(C.QJsonArray_QJsonArray_FromStringList(C.struct_QtCore_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "¡¦!")))}))
	runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
	return tmpValue
}

func (ptr *QJsonArray) FromStringList(list []string) *QJsonArray {
	listC := C.CString(strings.Join(list, "¡¦!"))
	defer C.free(unsafe.Pointer(listC))
	tmpValue := NewQJsonArrayFromPointer(C.QJsonArray_QJsonArray_FromStringList(C.struct_QtCore_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "¡¦!")))}))
	runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
	return tmpValue
}

func QJsonArray_FromVariantList(list []*QVariant) *QJsonArray {
	tmpValue := NewQJsonArrayFromPointer(C.QJsonArray_QJsonArray_FromVariantList(func() unsafe.Pointer {
		tmpList := NewQJsonArrayFromPointer(NewQJsonArrayFromPointer(nil).__fromVariantList_list_newList())
		for _, v := range list {
			tmpList.__fromVariantList_list_setList(v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
	return tmpValue
}

func (ptr *QJsonArray) FromVariantList(list []*QVariant) *QJsonArray {
	tmpValue := NewQJsonArrayFromPointer(C.QJsonArray_QJsonArray_FromVariantList(func() unsafe.Pointer {
		tmpList := NewQJsonArrayFromPointer(NewQJsonArrayFromPointer(nil).__fromVariantList_list_newList())
		for _, v := range list {
			tmpList.__fromVariantList_list_setList(v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
	return tmpValue
}

func (ptr *QJsonArray) Insert(i int, value QJsonValue_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonArray_Insert(ptr.Pointer(), C.int(int32(i)), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonArray_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonArray) Last() *QJsonValue {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonValueFromPointer(C.QJsonArray_Last(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonArray) Pop_back() {
	if ptr.Pointer() != nil {
		C.QJsonArray_Pop_back(ptr.Pointer())
	}
}

func (ptr *QJsonArray) Pop_front() {
	if ptr.Pointer() != nil {
		C.QJsonArray_Pop_front(ptr.Pointer())
	}
}

func (ptr *QJsonArray) Prepend(value QJsonValue_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonArray_Prepend(ptr.Pointer(), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) Push_back(value QJsonValue_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonArray_Push_back(ptr.Pointer(), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) Push_front(value QJsonValue_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonArray_Push_front(ptr.Pointer(), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) RemoveAt(i int) {
	if ptr.Pointer() != nil {
		C.QJsonArray_RemoveAt(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QJsonArray) RemoveFirst() {
	if ptr.Pointer() != nil {
		C.QJsonArray_RemoveFirst(ptr.Pointer())
	}
}

func (ptr *QJsonArray) RemoveLast() {
	if ptr.Pointer() != nil {
		C.QJsonArray_RemoveLast(ptr.Pointer())
	}
}

func (ptr *QJsonArray) Replace(i int, value QJsonValue_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonArray_Replace(ptr.Pointer(), C.int(int32(i)), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QJsonArray_Size(ptr.Pointer())))
	}
	return 0
}

func (ptr *QJsonArray) Swap(other QJsonArray_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonArray_Swap(ptr.Pointer(), PointerFromQJsonArray(other))
	}
}

func (ptr *QJsonArray) TakeAt(i int) *QJsonValue {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonValueFromPointer(C.QJsonArray_TakeAt(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonArray) ToVariantList() []*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QVariant {
			out := make([]*QVariant, int(l.len))
			tmpList := NewQJsonArrayFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__toVariantList_atList(i)
			}
			return out
		}(C.QJsonArray_ToVariantList(ptr.Pointer()))
	}
	return make([]*QVariant, 0)
}

func (ptr *QJsonArray) DestroyQJsonArray() {
	if ptr.Pointer() != nil {
		C.QJsonArray_DestroyQJsonArray(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QJsonArray) __fromVariantList_list_atList(i int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QJsonArray___fromVariantList_list_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonArray) __fromVariantList_list_setList(i QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonArray___fromVariantList_list_setList(ptr.Pointer(), PointerFromQVariant(i))
	}
}

func (ptr *QJsonArray) __fromVariantList_list_newList() unsafe.Pointer {
	return C.QJsonArray___fromVariantList_list_newList(ptr.Pointer())
}

func (ptr *QJsonArray) __toVariantList_atList(i int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QJsonArray___toVariantList_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonArray) __toVariantList_setList(i QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonArray___toVariantList_setList(ptr.Pointer(), PointerFromQVariant(i))
	}
}

func (ptr *QJsonArray) __toVariantList_newList() unsafe.Pointer {
	return C.QJsonArray___toVariantList_newList(ptr.Pointer())
}

type QJsonDocument struct {
	ptr unsafe.Pointer
}

type QJsonDocument_ITF interface {
	QJsonDocument_PTR() *QJsonDocument
}

func (ptr *QJsonDocument) QJsonDocument_PTR() *QJsonDocument {
	return ptr
}

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

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

func PointerFromQJsonDocument(ptr QJsonDocument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonDocument_PTR().Pointer()
	}
	return nil
}

func NewQJsonDocumentFromPointer(ptr unsafe.Pointer) (n *QJsonDocument) {
	n = new(QJsonDocument)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QJsonDocument__DataValidation
//QJsonDocument::DataValidation
type QJsonDocument__DataValidation int64

const (
	QJsonDocument__Validate         QJsonDocument__DataValidation = QJsonDocument__DataValidation(0)
	QJsonDocument__BypassValidation QJsonDocument__DataValidation = QJsonDocument__DataValidation(1)
)

//go:generate stringer -type=QJsonDocument__JsonFormat
//QJsonDocument::JsonFormat
type QJsonDocument__JsonFormat int64

const (
	QJsonDocument__Indented QJsonDocument__JsonFormat = QJsonDocument__JsonFormat(0)
	QJsonDocument__Compact  QJsonDocument__JsonFormat = QJsonDocument__JsonFormat(1)
)

func NewQJsonDocument() *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument())
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func NewQJsonDocument2(object QJsonObject_ITF) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument2(PointerFromQJsonObject(object)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func NewQJsonDocument3(array QJsonArray_ITF) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument3(PointerFromQJsonArray(array)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func NewQJsonDocument4(other QJsonDocument_ITF) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument4(PointerFromQJsonDocument(other)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func NewQJsonDocument5(other QJsonDocument_ITF) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument5(PointerFromQJsonDocument(other)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func (ptr *QJsonDocument) Array() *QJsonArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonArrayFromPointer(C.QJsonDocument_Array(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
		return tmpValue
	}
	return nil
}

func QJsonDocument_FromBinaryData(data QByteArray_ITF, validation QJsonDocument__DataValidation) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromBinaryData(PointerFromQByteArray(data), C.longlong(validation)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func (ptr *QJsonDocument) FromBinaryData(data QByteArray_ITF, validation QJsonDocument__DataValidation) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromBinaryData(PointerFromQByteArray(data), C.longlong(validation)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func QJsonDocument_FromJson(json QByteArray_ITF, error QJsonParseError_ITF) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromJson(PointerFromQByteArray(json), PointerFromQJsonParseError(error)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func (ptr *QJsonDocument) FromJson(json QByteArray_ITF, error QJsonParseError_ITF) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromJson(PointerFromQByteArray(json), PointerFromQJsonParseError(error)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func QJsonDocument_FromRawData(data []byte, size int, validation QJsonDocument__DataValidation) *QJsonDocument {
	var dataC *C.char
	if len(data) != 0 {
		dataC = (*C.char)(unsafe.Pointer(&data[0]))
	}
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromRawData(dataC, C.int(int32(size)), C.longlong(validation)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func (ptr *QJsonDocument) FromRawData(data []byte, size int, validation QJsonDocument__DataValidation) *QJsonDocument {
	var dataC *C.char
	if len(data) != 0 {
		dataC = (*C.char)(unsafe.Pointer(&data[0]))
	}
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromRawData(dataC, C.int(int32(size)), C.longlong(validation)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func QJsonDocument_FromVariant(variant QVariant_ITF) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromVariant(PointerFromQVariant(variant)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func (ptr *QJsonDocument) FromVariant(variant QVariant_ITF) *QJsonDocument {
	tmpValue := NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromVariant(PointerFromQVariant(variant)))
	runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
	return tmpValue
}

func (ptr *QJsonDocument) IsArray() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonDocument_IsArray(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonDocument) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonDocument_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonDocument) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonDocument_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonDocument) IsObject() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonDocument_IsObject(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonDocument) Object() *QJsonObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonObjectFromPointer(C.QJsonDocument_Object(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonDocument) RawData(size int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QJsonDocument_RawData(ptr.Pointer(), C.int(int32(size))))
	}
	return ""
}

func (ptr *QJsonDocument) SetArray(array QJsonArray_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonDocument_SetArray(ptr.Pointer(), PointerFromQJsonArray(array))
	}
}

func (ptr *QJsonDocument) SetObject(object QJsonObject_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonDocument_SetObject(ptr.Pointer(), PointerFromQJsonObject(object))
	}
}

func (ptr *QJsonDocument) Swap(other QJsonDocument_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonDocument_Swap(ptr.Pointer(), PointerFromQJsonDocument(other))
	}
}

func (ptr *QJsonDocument) ToBinaryData() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QJsonDocument_ToBinaryData(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonDocument) ToJson() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QJsonDocument_ToJson(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonDocument) ToJson2(format QJsonDocument__JsonFormat) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QJsonDocument_ToJson2(ptr.Pointer(), C.longlong(format)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonDocument) ToVariant() *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QJsonDocument_ToVariant(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonDocument) DestroyQJsonDocument() {
	if ptr.Pointer() != nil {
		C.QJsonDocument_DestroyQJsonDocument(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QJsonObject struct {
	ptr unsafe.Pointer
}

type QJsonObject_ITF interface {
	QJsonObject_PTR() *QJsonObject
}

func (ptr *QJsonObject) QJsonObject_PTR() *QJsonObject {
	return ptr
}

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

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

func PointerFromQJsonObject(ptr QJsonObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonObject_PTR().Pointer()
	}
	return nil
}

func NewQJsonObjectFromPointer(ptr unsafe.Pointer) (n *QJsonObject) {
	n = new(QJsonObject)
	n.SetPointer(ptr)
	return
}
func NewQJsonObject() *QJsonObject {
	tmpValue := NewQJsonObjectFromPointer(C.QJsonObject_NewQJsonObject())
	runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
	return tmpValue
}

func NewQJsonObject3(other QJsonObject_ITF) *QJsonObject {
	tmpValue := NewQJsonObjectFromPointer(C.QJsonObject_NewQJsonObject3(PointerFromQJsonObject(other)))
	runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
	return tmpValue
}

func NewQJsonObject4(other QJsonObject_ITF) *QJsonObject {
	tmpValue := NewQJsonObjectFromPointer(C.QJsonObject_NewQJsonObject4(PointerFromQJsonObject(other)))
	runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
	return tmpValue
}

func (ptr *QJsonObject) Contains(key string) bool {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		return int8(C.QJsonObject_Contains(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})) != 0
	}
	return false
}

func (ptr *QJsonObject) Contains2(key QLatin1String_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonObject_Contains2(ptr.Pointer(), PointerFromQLatin1String(key))) != 0
	}
	return false
}

func (ptr *QJsonObject) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QJsonObject_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QJsonObject) Empty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonObject_Empty(ptr.Pointer())) != 0
	}
	return false
}

func QJsonObject_FromVariantHash(hash map[string]*QVariant) *QJsonObject {
	tmpValue := NewQJsonObjectFromPointer(C.QJsonObject_QJsonObject_FromVariantHash(func() unsafe.Pointer {
		tmpList := NewQJsonObjectFromPointer(NewQJsonObjectFromPointer(nil).__fromVariantHash_hash_newList())
		for k, v := range hash {
			tmpList.__fromVariantHash_hash_setList(k, v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
	return tmpValue
}

func (ptr *QJsonObject) FromVariantHash(hash map[string]*QVariant) *QJsonObject {
	tmpValue := NewQJsonObjectFromPointer(C.QJsonObject_QJsonObject_FromVariantHash(func() unsafe.Pointer {
		tmpList := NewQJsonObjectFromPointer(NewQJsonObjectFromPointer(nil).__fromVariantHash_hash_newList())
		for k, v := range hash {
			tmpList.__fromVariantHash_hash_setList(k, v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
	return tmpValue
}

func (ptr *QJsonObject) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonObject_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonObject) Keys() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QJsonObject_Keys(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QJsonObject) Length() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QJsonObject_Length(ptr.Pointer())))
	}
	return 0
}

func (ptr *QJsonObject) Remove(key string) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QJsonObject_Remove(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})
	}
}

func (ptr *QJsonObject) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QJsonObject_Size(ptr.Pointer())))
	}
	return 0
}

func (ptr *QJsonObject) Swap(other QJsonObject_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonObject_Swap(ptr.Pointer(), PointerFromQJsonObject(other))
	}
}

func (ptr *QJsonObject) Take(key string) *QJsonValue {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		tmpValue := NewQJsonValueFromPointer(C.QJsonObject_Take(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}))
		runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonObject) ToVariantHash() map[string]*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[string]*QVariant {
			out := make(map[string]*QVariant, int(l.len))
			tmpList := NewQJsonObjectFromPointer(l.data)
			for i, v := range tmpList.__toVariantHash_keyList() {
				out[v] = tmpList.__toVariantHash_atList(v, i)
			}
			return out
		}(C.QJsonObject_ToVariantHash(ptr.Pointer()))
	}
	return make(map[string]*QVariant, 0)
}

func (ptr *QJsonObject) ToVariantMap() map[string]*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[string]*QVariant {
			out := make(map[string]*QVariant, int(l.len))
			tmpList := NewQJsonObjectFromPointer(l.data)
			for i, v := range tmpList.__toVariantMap_keyList() {
				out[v] = tmpList.__toVariantMap_atList(v, i)
			}
			return out
		}(C.QJsonObject_ToVariantMap(ptr.Pointer()))
	}
	return make(map[string]*QVariant, 0)
}

func (ptr *QJsonObject) Value(key string) *QJsonValue {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		tmpValue := NewQJsonValueFromPointer(C.QJsonObject_Value(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}))
		runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonObject) Value2(key QLatin1String_ITF) *QJsonValue {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonValueFromPointer(C.QJsonObject_Value2(ptr.Pointer(), PointerFromQLatin1String(key)))
		runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonObject) DestroyQJsonObject() {
	if ptr.Pointer() != nil {
		C.QJsonObject_DestroyQJsonObject(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QJsonObject) __fromVariantHash_hash_atList(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QJsonObject___fromVariantHash_hash_atList(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonObject) __fromVariantHash_hash_setList(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QJsonObject___fromVariantHash_hash_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QJsonObject) __fromVariantHash_hash_newList() unsafe.Pointer {
	return C.QJsonObject___fromVariantHash_hash_newList(ptr.Pointer())
}

func (ptr *QJsonObject) __fromVariantHash_hash_keyList() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQJsonObjectFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____fromVariantHash_hash_keyList_atList(i)
			}
			return out
		}(C.QJsonObject___fromVariantHash_hash_keyList(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QJsonObject) __toVariantHash_atList(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QJsonObject___toVariantHash_atList(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonObject) __toVariantHash_setList(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QJsonObject___toVariantHash_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QJsonObject) __toVariantHash_newList() unsafe.Pointer {
	return C.QJsonObject___toVariantHash_newList(ptr.Pointer())
}

func (ptr *QJsonObject) __toVariantHash_keyList() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQJsonObjectFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____toVariantHash_keyList_atList(i)
			}
			return out
		}(C.QJsonObject___toVariantHash_keyList(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QJsonObject) __toVariantMap_atList(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QJsonObject___toVariantMap_atList(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonObject) __toVariantMap_setList(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QJsonObject___toVariantMap_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QJsonObject) __toVariantMap_newList() unsafe.Pointer {
	return C.QJsonObject___toVariantMap_newList(ptr.Pointer())
}

func (ptr *QJsonObject) __toVariantMap_keyList() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQJsonObjectFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____toVariantMap_keyList_atList(i)
			}
			return out
		}(C.QJsonObject___toVariantMap_keyList(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QJsonObject) ____fromVariantHash_hash_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QJsonObject_____fromVariantHash_hash_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QJsonObject) ____fromVariantHash_hash_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QJsonObject_____fromVariantHash_hash_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QJsonObject) ____fromVariantHash_hash_keyList_newList() unsafe.Pointer {
	return C.QJsonObject_____fromVariantHash_hash_keyList_newList(ptr.Pointer())
}

func (ptr *QJsonObject) ____fromVariantMap_map_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QJsonObject_____fromVariantMap_map_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QJsonObject) ____fromVariantMap_map_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QJsonObject_____fromVariantMap_map_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QJsonObject) ____fromVariantMap_map_keyList_newList() unsafe.Pointer {
	return C.QJsonObject_____fromVariantMap_map_keyList_newList(ptr.Pointer())
}

func (ptr *QJsonObject) ____toVariantHash_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QJsonObject_____toVariantHash_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QJsonObject) ____toVariantHash_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QJsonObject_____toVariantHash_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QJsonObject) ____toVariantHash_keyList_newList() unsafe.Pointer {
	return C.QJsonObject_____toVariantHash_keyList_newList(ptr.Pointer())
}

func (ptr *QJsonObject) ____toVariantMap_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QJsonObject_____toVariantMap_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QJsonObject) ____toVariantMap_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QJsonObject_____toVariantMap_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QJsonObject) ____toVariantMap_keyList_newList() unsafe.Pointer {
	return C.QJsonObject_____toVariantMap_keyList_newList(ptr.Pointer())
}

type QJsonParseError struct {
	ptr unsafe.Pointer
}

type QJsonParseError_ITF interface {
	QJsonParseError_PTR() *QJsonParseError
}

func (ptr *QJsonParseError) QJsonParseError_PTR() *QJsonParseError {
	return ptr
}

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

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

func PointerFromQJsonParseError(ptr QJsonParseError_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonParseError_PTR().Pointer()
	}
	return nil
}

func NewQJsonParseErrorFromPointer(ptr unsafe.Pointer) (n *QJsonParseError) {
	n = new(QJsonParseError)
	n.SetPointer(ptr)
	return
}

func (ptr *QJsonParseError) DestroyQJsonParseError() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QJsonParseError__ParseError
//QJsonParseError::ParseError
type QJsonParseError__ParseError int64

const (
	QJsonParseError__NoError               QJsonParseError__ParseError = QJsonParseError__ParseError(0)
	QJsonParseError__UnterminatedObject    QJsonParseError__ParseError = QJsonParseError__ParseError(1)
	QJsonParseError__MissingNameSeparator  QJsonParseError__ParseError = QJsonParseError__ParseError(2)
	QJsonParseError__UnterminatedArray     QJsonParseError__ParseError = QJsonParseError__ParseError(3)
	QJsonParseError__MissingValueSeparator QJsonParseError__ParseError = QJsonParseError__ParseError(4)
	QJsonParseError__IllegalValue          QJsonParseError__ParseError = QJsonParseError__ParseError(5)
	QJsonParseError__TerminationByNumber   QJsonParseError__ParseError = QJsonParseError__ParseError(6)
	QJsonParseError__IllegalNumber         QJsonParseError__ParseError = QJsonParseError__ParseError(7)
	QJsonParseError__IllegalEscapeSequence QJsonParseError__ParseError = QJsonParseError__ParseError(8)
	QJsonParseError__IllegalUTF8String     QJsonParseError__ParseError = QJsonParseError__ParseError(9)
	QJsonParseError__UnterminatedString    QJsonParseError__ParseError = QJsonParseError__ParseError(10)
	QJsonParseError__MissingObject         QJsonParseError__ParseError = QJsonParseError__ParseError(11)
	QJsonParseError__DeepNesting           QJsonParseError__ParseError = QJsonParseError__ParseError(12)
	QJsonParseError__DocumentTooLarge      QJsonParseError__ParseError = QJsonParseError__ParseError(13)
	QJsonParseError__GarbageAtEnd          QJsonParseError__ParseError = QJsonParseError__ParseError(14)
)

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

func (ptr *QJsonParseError) Offset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QJsonParseError_Offset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QJsonParseError) SetOffset(vin int) {
	if ptr.Pointer() != nil {
		C.QJsonParseError_SetOffset(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QJsonParseError) Error() QJsonParseError__ParseError {
	if ptr.Pointer() != nil {
		return QJsonParseError__ParseError(C.QJsonParseError_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QJsonParseError) SetError(vqj QJsonParseError__ParseError) {
	if ptr.Pointer() != nil {
		C.QJsonParseError_SetError(ptr.Pointer(), C.longlong(vqj))
	}
}

type QJsonValue struct {
	ptr unsafe.Pointer
}

type QJsonValue_ITF interface {
	QJsonValue_PTR() *QJsonValue
}

func (ptr *QJsonValue) QJsonValue_PTR() *QJsonValue {
	return ptr
}

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

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

func PointerFromQJsonValue(ptr QJsonValue_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonValue_PTR().Pointer()
	}
	return nil
}

func NewQJsonValueFromPointer(ptr unsafe.Pointer) (n *QJsonValue) {
	n = new(QJsonValue)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QJsonValue__Type
//QJsonValue::Type
type QJsonValue__Type int64

const (
	QJsonValue__Null      QJsonValue__Type = QJsonValue__Type(0x0)
	QJsonValue__Bool      QJsonValue__Type = QJsonValue__Type(0x1)
	QJsonValue__Double    QJsonValue__Type = QJsonValue__Type(0x2)
	QJsonValue__String    QJsonValue__Type = QJsonValue__Type(0x3)
	QJsonValue__Array     QJsonValue__Type = QJsonValue__Type(0x4)
	QJsonValue__Object    QJsonValue__Type = QJsonValue__Type(0x5)
	QJsonValue__Undefined QJsonValue__Type = QJsonValue__Type(0x80)
)

func NewQJsonValue(ty QJsonValue__Type) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue(C.longlong(ty)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue2(b bool) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue2(C.char(int8(qt.GoBoolToInt(b)))))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue3(n float64) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue3(C.double(n)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue4(n int) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue4(C.int(int32(n))))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue5(n int64) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue5(C.longlong(n)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue6(s string) *QJsonValue {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue6(C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue7(s QLatin1String_ITF) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue7(PointerFromQLatin1String(s)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue8(s string) *QJsonValue {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue8(sC))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue9(a QJsonArray_ITF) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue9(PointerFromQJsonArray(a)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue10(o QJsonObject_ITF) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue10(PointerFromQJsonObject(o)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue11(other QJsonValue_ITF) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue11(PointerFromQJsonValue(other)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func NewQJsonValue12(other QJsonValue_ITF) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_NewQJsonValue12(PointerFromQJsonValue(other)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func QJsonValue_FromVariant(variant QVariant_ITF) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_QJsonValue_FromVariant(PointerFromQVariant(variant)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func (ptr *QJsonValue) FromVariant(variant QVariant_ITF) *QJsonValue {
	tmpValue := NewQJsonValueFromPointer(C.QJsonValue_QJsonValue_FromVariant(PointerFromQVariant(variant)))
	runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
	return tmpValue
}

func (ptr *QJsonValue) IsArray() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonValue_IsArray(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonValue) IsBool() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonValue_IsBool(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonValue) IsDouble() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonValue_IsDouble(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonValue) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonValue_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonValue) IsObject() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonValue_IsObject(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonValue) IsString() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonValue_IsString(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonValue) IsUndefined() bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonValue_IsUndefined(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QJsonValue) Swap(other QJsonValue_ITF) {
	if ptr.Pointer() != nil {
		C.QJsonValue_Swap(ptr.Pointer(), PointerFromQJsonValue(other))
	}
}

func (ptr *QJsonValue) ToArray(defaultValue QJsonArray_ITF) *QJsonArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonArrayFromPointer(C.QJsonValue_ToArray(ptr.Pointer(), PointerFromQJsonArray(defaultValue)))
		runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonValue) ToArray2() *QJsonArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonArrayFromPointer(C.QJsonValue_ToArray2(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonValue) ToBool(defaultValue bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QJsonValue_ToBool(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(defaultValue))))) != 0
	}
	return false
}

func (ptr *QJsonValue) ToDouble(defaultValue float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QJsonValue_ToDouble(ptr.Pointer(), C.double(defaultValue)))
	}
	return 0
}

func (ptr *QJsonValue) ToInt(defaultValue int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QJsonValue_ToInt(ptr.Pointer(), C.int(int32(defaultValue)))))
	}
	return 0
}

func (ptr *QJsonValue) ToObject(defaultValue QJsonObject_ITF) *QJsonObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonObjectFromPointer(C.QJsonValue_ToObject(ptr.Pointer(), PointerFromQJsonObject(defaultValue)))
		runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonValue) ToObject2() *QJsonObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonObjectFromPointer(C.QJsonValue_ToObject2(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonValue) ToString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QJsonValue_ToString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QJsonValue) ToString2(defaultValue string) string {
	if ptr.Pointer() != nil {
		var defaultValueC *C.char
		if defaultValue != "" {
			defaultValueC = C.CString(defaultValue)
			defer C.free(unsafe.Pointer(defaultValueC))
		}
		return cGoUnpackString(C.QJsonValue_ToString2(ptr.Pointer(), C.struct_QtCore_PackedString{data: defaultValueC, len: C.longlong(len(defaultValue))}))
	}
	return ""
}

func (ptr *QJsonValue) ToVariant() *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QJsonValue_ToVariant(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QJsonValue) Type() QJsonValue__Type {
	if ptr.Pointer() != nil {
		return QJsonValue__Type(C.QJsonValue_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QJsonValue) DestroyQJsonValue() {
	if ptr.Pointer() != nil {
		C.QJsonValue_DestroyQJsonValue(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QJsonValuePtr struct {
	ptr unsafe.Pointer
}

type QJsonValuePtr_ITF interface {
	QJsonValuePtr_PTR() *QJsonValuePtr
}

func (ptr *QJsonValuePtr) QJsonValuePtr_PTR() *QJsonValuePtr {
	return ptr
}

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

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

func PointerFromQJsonValuePtr(ptr QJsonValuePtr_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonValuePtr_PTR().Pointer()
	}
	return nil
}

func NewQJsonValuePtrFromPointer(ptr unsafe.Pointer) (n *QJsonValuePtr) {
	n = new(QJsonValuePtr)
	n.SetPointer(ptr)
	return
}

func (ptr *QJsonValuePtr) DestroyQJsonValuePtr() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QJsonValueRefPtr struct {
	ptr unsafe.Pointer
}

type QJsonValueRefPtr_ITF interface {
	QJsonValueRefPtr_PTR() *QJsonValueRefPtr
}

func (ptr *QJsonValueRefPtr) QJsonValueRefPtr_PTR() *QJsonValueRefPtr {
	return ptr
}

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

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

func PointerFromQJsonValueRefPtr(ptr QJsonValueRefPtr_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonValueRefPtr_PTR().Pointer()
	}
	return nil
}

func NewQJsonValueRefPtrFromPointer(ptr unsafe.Pointer) (n *QJsonValueRefPtr) {
	n = new(QJsonValueRefPtr)
	n.SetPointer(ptr)
	return
}

func (ptr *QJsonValueRefPtr) DestroyQJsonValueRefPtr() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QKeyValueIterator struct {
	ptr unsafe.Pointer
}

type QKeyValueIterator_ITF interface {
	QKeyValueIterator_PTR() *QKeyValueIterator
}

func (ptr *QKeyValueIterator) QKeyValueIterator_PTR() *QKeyValueIterator {
	return ptr
}

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

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

func PointerFromQKeyValueIterator(ptr QKeyValueIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QKeyValueIterator_PTR().Pointer()
	}
	return nil
}

func NewQKeyValueIteratorFromPointer(ptr unsafe.Pointer) (n *QKeyValueIterator) {
	n = new(QKeyValueIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QKeyValueIterator) DestroyQKeyValueIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QLEInteger struct {
	ptr unsafe.Pointer
}

type QLEInteger_ITF interface {
	QLEInteger_PTR() *QLEInteger
}

func (ptr *QLEInteger) QLEInteger_PTR() *QLEInteger {
	return ptr
}

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

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

func PointerFromQLEInteger(ptr QLEInteger_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLEInteger_PTR().Pointer()
	}
	return nil
}

func NewQLEIntegerFromPointer(ptr unsafe.Pointer) (n *QLEInteger) {
	n = new(QLEInteger)
	n.SetPointer(ptr)
	return
}

func (ptr *QLEInteger) DestroyQLEInteger() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QLatin1Char struct {
	ptr unsafe.Pointer
}

type QLatin1Char_ITF interface {
	QLatin1Char_PTR() *QLatin1Char
}

func (ptr *QLatin1Char) QLatin1Char_PTR() *QLatin1Char {
	return ptr
}

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

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

func PointerFromQLatin1Char(ptr QLatin1Char_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLatin1Char_PTR().Pointer()
	}
	return nil
}

func NewQLatin1CharFromPointer(ptr unsafe.Pointer) (n *QLatin1Char) {
	n = new(QLatin1Char)
	n.SetPointer(ptr)
	return
}

func (ptr *QLatin1Char) DestroyQLatin1Char() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQLatin1Char(c string) *QLatin1Char {
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	tmpValue := NewQLatin1CharFromPointer(C.QLatin1Char_NewQLatin1Char(cC))
	runtime.SetFinalizer(tmpValue, (*QLatin1Char).DestroyQLatin1Char)
	return tmpValue
}

func (ptr *QLatin1Char) ToLatin1() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLatin1Char_ToLatin1(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLatin1Char) Unicode() uint16 {
	if ptr.Pointer() != nil {
		return uint16(C.QLatin1Char_Unicode(ptr.Pointer()))
	}
	return 0
}

type QLatin1String struct {
	ptr unsafe.Pointer
}

type QLatin1String_ITF interface {
	QLatin1String_PTR() *QLatin1String
}

func (ptr *QLatin1String) QLatin1String_PTR() *QLatin1String {
	return ptr
}

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

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

func PointerFromQLatin1String(ptr QLatin1String_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLatin1String_PTR().Pointer()
	}
	return nil
}

func NewQLatin1StringFromPointer(ptr unsafe.Pointer) (n *QLatin1String) {
	n = new(QLatin1String)
	n.SetPointer(ptr)
	return
}

func (ptr *QLatin1String) DestroyQLatin1String() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQLatin1String() *QLatin1String {
	tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String())
	runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
	return tmpValue
}

func NewQLatin1String2(str string) *QLatin1String {
	var strC *C.char
	if str != "" {
		strC = C.CString(str)
		defer C.free(unsafe.Pointer(strC))
	}
	tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String2(strC))
	runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
	return tmpValue
}

func NewQLatin1String3(first string, last string) *QLatin1String {
	var firstC *C.char
	if first != "" {
		firstC = C.CString(first)
		defer C.free(unsafe.Pointer(firstC))
	}
	var lastC *C.char
	if last != "" {
		lastC = C.CString(last)
		defer C.free(unsafe.Pointer(lastC))
	}
	tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String3(firstC, lastC))
	runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
	return tmpValue
}

func NewQLatin1String4(str string, size int) *QLatin1String {
	var strC *C.char
	if str != "" {
		strC = C.CString(str)
		defer C.free(unsafe.Pointer(strC))
	}
	tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String4(strC, C.int(int32(size))))
	runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
	return tmpValue
}

func NewQLatin1String5(str QByteArray_ITF) *QLatin1String {
	tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String5(PointerFromQByteArray(str)))
	runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
	return tmpValue
}

func (ptr *QLatin1String) Chop(length int) {
	if ptr.Pointer() != nil {
		C.QLatin1String_Chop(ptr.Pointer(), C.int(int32(length)))
	}
}

func (ptr *QLatin1String) Chopped(length int) *QLatin1String {
	if ptr.Pointer() != nil {
		tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_Chopped(ptr.Pointer(), C.int(int32(length))))
		runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
		return tmpValue
	}
	return nil
}

func (ptr *QLatin1String) Data() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLatin1String_Data(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLatin1String) EndsWith(str QStringView_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_EndsWith(ptr.Pointer(), PointerFromQStringView(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QLatin1String) EndsWith2(l1 QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_EndsWith2(ptr.Pointer(), PointerFromQLatin1String(l1), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QLatin1String) EndsWith3(ch QChar_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_EndsWith3(ptr.Pointer(), PointerFromQChar(ch))) != 0
	}
	return false
}

func (ptr *QLatin1String) EndsWith4(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_EndsWith4(ptr.Pointer(), PointerFromQChar(ch), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QLatin1String) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLatin1String) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLatin1String) Latin1() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLatin1String_Latin1(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLatin1String) Left(length int) *QLatin1String {
	if ptr.Pointer() != nil {
		tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_Left(ptr.Pointer(), C.int(int32(length))))
		runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
		return tmpValue
	}
	return nil
}

func (ptr *QLatin1String) Mid(start int) *QLatin1String {
	if ptr.Pointer() != nil {
		tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_Mid(ptr.Pointer(), C.int(int32(start))))
		runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
		return tmpValue
	}
	return nil
}

func (ptr *QLatin1String) Mid2(start int, length int) *QLatin1String {
	if ptr.Pointer() != nil {
		tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_Mid2(ptr.Pointer(), C.int(int32(start)), C.int(int32(length))))
		runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
		return tmpValue
	}
	return nil
}

func (ptr *QLatin1String) Right(length int) *QLatin1String {
	if ptr.Pointer() != nil {
		tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_Right(ptr.Pointer(), C.int(int32(length))))
		runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
		return tmpValue
	}
	return nil
}

func (ptr *QLatin1String) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLatin1String_Size(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLatin1String) StartsWith(str QStringView_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_StartsWith(ptr.Pointer(), PointerFromQStringView(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QLatin1String) StartsWith2(l1 QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_StartsWith2(ptr.Pointer(), PointerFromQLatin1String(l1), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QLatin1String) StartsWith3(ch QChar_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_StartsWith3(ptr.Pointer(), PointerFromQChar(ch))) != 0
	}
	return false
}

func (ptr *QLatin1String) StartsWith4(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLatin1String_StartsWith4(ptr.Pointer(), PointerFromQChar(ch), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QLatin1String) Trimmed() *QLatin1String {
	if ptr.Pointer() != nil {
		tmpValue := NewQLatin1StringFromPointer(C.QLatin1String_Trimmed(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLatin1String).DestroyQLatin1String)
		return tmpValue
	}
	return nil
}

func (ptr *QLatin1String) Truncate(length int) {
	if ptr.Pointer() != nil {
		C.QLatin1String_Truncate(ptr.Pointer(), C.int(int32(length)))
	}
}

type QLibrary struct {
	QObject
}

type QLibrary_ITF interface {
	QObject_ITF
	QLibrary_PTR() *QLibrary
}

func (ptr *QLibrary) QLibrary_PTR() *QLibrary {
	return ptr
}

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

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

func PointerFromQLibrary(ptr QLibrary_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLibrary_PTR().Pointer()
	}
	return nil
}

func NewQLibraryFromPointer(ptr unsafe.Pointer) (n *QLibrary) {
	n = new(QLibrary)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QLibrary__LoadHint
//QLibrary::LoadHint
type QLibrary__LoadHint int64

const (
	QLibrary__ResolveAllSymbolsHint     QLibrary__LoadHint = QLibrary__LoadHint(0x01)
	QLibrary__ExportExternalSymbolsHint QLibrary__LoadHint = QLibrary__LoadHint(0x02)
	QLibrary__LoadArchiveMemberHint     QLibrary__LoadHint = QLibrary__LoadHint(0x04)
	QLibrary__PreventUnloadHint         QLibrary__LoadHint = QLibrary__LoadHint(0x08)
	QLibrary__DeepBindHint              QLibrary__LoadHint = QLibrary__LoadHint(0x10)
)

func NewQLibrary(parent QObject_ITF) *QLibrary {
	tmpValue := NewQLibraryFromPointer(C.QLibrary_NewQLibrary(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQLibrary2(fileName string, parent QObject_ITF) *QLibrary {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	tmpValue := NewQLibraryFromPointer(C.QLibrary_NewQLibrary2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQLibrary3(fileName string, verNum int, parent QObject_ITF) *QLibrary {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	tmpValue := NewQLibraryFromPointer(C.QLibrary_NewQLibrary3(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.int(int32(verNum)), PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQLibrary4(fileName string, version string, parent QObject_ITF) *QLibrary {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	var versionC *C.char
	if version != "" {
		versionC = C.CString(version)
		defer C.free(unsafe.Pointer(versionC))
	}
	tmpValue := NewQLibraryFromPointer(C.QLibrary_NewQLibrary4(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.struct_QtCore_PackedString{data: versionC, len: C.longlong(len(version))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

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

func (ptr *QLibrary) FileName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLibrary_FileName(ptr.Pointer()))
	}
	return ""
}

func QLibrary_IsLibrary(fileName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QLibrary_QLibrary_IsLibrary(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func (ptr *QLibrary) IsLibrary(fileName string) bool {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return int8(C.QLibrary_QLibrary_IsLibrary(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})) != 0
}

func (ptr *QLibrary) IsLoaded() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLibrary_IsLoaded(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLibrary) Load() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLibrary_Load(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLibrary) LoadHints() QLibrary__LoadHint {
	if ptr.Pointer() != nil {
		return QLibrary__LoadHint(C.QLibrary_LoadHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLibrary) SetFileName(fileName string) {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		C.QLibrary_SetFileName(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})
	}
}

func (ptr *QLibrary) SetFileNameAndVersion(fileName string, versionNumber int) {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		C.QLibrary_SetFileNameAndVersion(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.int(int32(versionNumber)))
	}
}

func (ptr *QLibrary) SetFileNameAndVersion2(fileName string, version string) {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		var versionC *C.char
		if version != "" {
			versionC = C.CString(version)
			defer C.free(unsafe.Pointer(versionC))
		}
		C.QLibrary_SetFileNameAndVersion2(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.struct_QtCore_PackedString{data: versionC, len: C.longlong(len(version))})
	}
}

func (ptr *QLibrary) SetLoadHints(hints QLibrary__LoadHint) {
	if ptr.Pointer() != nil {
		C.QLibrary_SetLoadHints(ptr.Pointer(), C.longlong(hints))
	}
}

func (ptr *QLibrary) Unload() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLibrary_Unload(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQLibrary_DestroyQLibrary
func callbackQLibrary_DestroyQLibrary(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QLibrary"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLibraryFromPointer(ptr).DestroyQLibraryDefault()
	}
}

func (ptr *QLibrary) ConnectDestroyQLibrary(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QLibrary"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QLibrary", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QLibrary", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLibrary) DisconnectDestroyQLibrary() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QLibrary")
	}
}

func (ptr *QLibrary) DestroyQLibrary() {
	if ptr.Pointer() != nil {
		C.QLibrary_DestroyQLibrary(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLibrary) DestroyQLibraryDefault() {
	if ptr.Pointer() != nil {
		C.QLibrary_DestroyQLibraryDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QLibraryInfo struct {
	ptr unsafe.Pointer
}

type QLibraryInfo_ITF interface {
	QLibraryInfo_PTR() *QLibraryInfo
}

func (ptr *QLibraryInfo) QLibraryInfo_PTR() *QLibraryInfo {
	return ptr
}

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

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

func PointerFromQLibraryInfo(ptr QLibraryInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLibraryInfo_PTR().Pointer()
	}
	return nil
}

func NewQLibraryInfoFromPointer(ptr unsafe.Pointer) (n *QLibraryInfo) {
	n = new(QLibraryInfo)
	n.SetPointer(ptr)
	return
}

func (ptr *QLibraryInfo) DestroyQLibraryInfo() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QLibraryInfo__LibraryLocation
//QLibraryInfo::LibraryLocation
type QLibraryInfo__LibraryLocation int64

const (
	QLibraryInfo__PrefixPath             QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(0)
	QLibraryInfo__DocumentationPath      QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(1)
	QLibraryInfo__HeadersPath            QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(2)
	QLibraryInfo__LibrariesPath          QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(3)
	QLibraryInfo__LibraryExecutablesPath QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(4)
	QLibraryInfo__BinariesPath           QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(5)
	QLibraryInfo__PluginsPath            QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(6)
	QLibraryInfo__ImportsPath            QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(7)
	QLibraryInfo__Qml2ImportsPath        QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(8)
	QLibraryInfo__ArchDataPath           QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(9)
	QLibraryInfo__DataPath               QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(10)
	QLibraryInfo__TranslationsPath       QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(11)
	QLibraryInfo__ExamplesPath           QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(12)
	QLibraryInfo__TestsPath              QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(13)
	QLibraryInfo__SettingsPath           QLibraryInfo__LibraryLocation = QLibraryInfo__LibraryLocation(100)
)

func QLibraryInfo_IsDebugBuild() bool {
	return int8(C.QLibraryInfo_QLibraryInfo_IsDebugBuild()) != 0
}

func (ptr *QLibraryInfo) IsDebugBuild() bool {
	return int8(C.QLibraryInfo_QLibraryInfo_IsDebugBuild()) != 0
}

func QLibraryInfo_Location(loc QLibraryInfo__LibraryLocation) string {
	return cGoUnpackString(C.QLibraryInfo_QLibraryInfo_Location(C.longlong(loc)))
}

func (ptr *QLibraryInfo) Location(loc QLibraryInfo__LibraryLocation) string {
	return cGoUnpackString(C.QLibraryInfo_QLibraryInfo_Location(C.longlong(loc)))
}

func QLibraryInfo_Version() *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QLibraryInfo_QLibraryInfo_Version())
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func (ptr *QLibraryInfo) Version() *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QLibraryInfo_QLibraryInfo_Version())
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

type QLine struct {
	ptr unsafe.Pointer
}

type QLine_ITF interface {
	QLine_PTR() *QLine
}

func (ptr *QLine) QLine_PTR() *QLine {
	return ptr
}

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

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

func PointerFromQLine(ptr QLine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLine_PTR().Pointer()
	}
	return nil
}

func NewQLineFromPointer(ptr unsafe.Pointer) (n *QLine) {
	n = new(QLine)
	n.SetPointer(ptr)
	return
}

func (ptr *QLine) DestroyQLine() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQLine() *QLine {
	tmpValue := NewQLineFromPointer(C.QLine_NewQLine())
	runtime.SetFinalizer(tmpValue, (*QLine).DestroyQLine)
	return tmpValue
}

func NewQLine2(p1 QPoint_ITF, p2 QPoint_ITF) *QLine {
	tmpValue := NewQLineFromPointer(C.QLine_NewQLine2(PointerFromQPoint(p1), PointerFromQPoint(p2)))
	runtime.SetFinalizer(tmpValue, (*QLine).DestroyQLine)
	return tmpValue
}

func NewQLine3(x1 int, y1 int, x2 int, y2 int) *QLine {
	tmpValue := NewQLineFromPointer(C.QLine_NewQLine3(C.int(int32(x1)), C.int(int32(y1)), C.int(int32(x2)), C.int(int32(y2))))
	runtime.SetFinalizer(tmpValue, (*QLine).DestroyQLine)
	return tmpValue
}

func (ptr *QLine) Center() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QLine_Center(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QLine) Dx() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLine_Dx(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLine) Dy() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLine_Dy(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLine) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLine_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLine) P1() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QLine_P1(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QLine) P2() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QLine_P2(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QLine) SetLine(x1 int, y1 int, x2 int, y2 int) {
	if ptr.Pointer() != nil {
		C.QLine_SetLine(ptr.Pointer(), C.int(int32(x1)), C.int(int32(y1)), C.int(int32(x2)), C.int(int32(y2)))
	}
}

func (ptr *QLine) SetP1(p1 QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QLine_SetP1(ptr.Pointer(), PointerFromQPoint(p1))
	}
}

func (ptr *QLine) SetP2(p2 QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QLine_SetP2(ptr.Pointer(), PointerFromQPoint(p2))
	}
}

func (ptr *QLine) SetPoints(p1 QPoint_ITF, p2 QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QLine_SetPoints(ptr.Pointer(), PointerFromQPoint(p1), PointerFromQPoint(p2))
	}
}

func (ptr *QLine) Translate(offset QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QLine_Translate(ptr.Pointer(), PointerFromQPoint(offset))
	}
}

func (ptr *QLine) Translate2(dx int, dy int) {
	if ptr.Pointer() != nil {
		C.QLine_Translate2(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy)))
	}
}

func (ptr *QLine) Translated(offset QPoint_ITF) *QLine {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineFromPointer(C.QLine_Translated(ptr.Pointer(), PointerFromQPoint(offset)))
		runtime.SetFinalizer(tmpValue, (*QLine).DestroyQLine)
		return tmpValue
	}
	return nil
}

func (ptr *QLine) Translated2(dx int, dy int) *QLine {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineFromPointer(C.QLine_Translated2(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy))))
		runtime.SetFinalizer(tmpValue, (*QLine).DestroyQLine)
		return tmpValue
	}
	return nil
}

func (ptr *QLine) X1() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLine_X1(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLine) X2() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLine_X2(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLine) Y1() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLine_Y1(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLine) Y2() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLine_Y2(ptr.Pointer())))
	}
	return 0
}

type QLineF struct {
	ptr unsafe.Pointer
}

type QLineF_ITF interface {
	QLineF_PTR() *QLineF
}

func (ptr *QLineF) QLineF_PTR() *QLineF {
	return ptr
}

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

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

func PointerFromQLineF(ptr QLineF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLineF_PTR().Pointer()
	}
	return nil
}

func NewQLineFFromPointer(ptr unsafe.Pointer) (n *QLineF) {
	n = new(QLineF)
	n.SetPointer(ptr)
	return
}

func (ptr *QLineF) DestroyQLineF() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QLineF__IntersectType
//QLineF::IntersectType
type QLineF__IntersectType int64

const (
	QLineF__NoIntersection        QLineF__IntersectType = QLineF__IntersectType(0)
	QLineF__BoundedIntersection   QLineF__IntersectType = QLineF__IntersectType(1)
	QLineF__UnboundedIntersection QLineF__IntersectType = QLineF__IntersectType(2)
)

func NewQLineF() *QLineF {
	tmpValue := NewQLineFFromPointer(C.QLineF_NewQLineF())
	runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
	return tmpValue
}

func NewQLineF2(p1 QPointF_ITF, p2 QPointF_ITF) *QLineF {
	tmpValue := NewQLineFFromPointer(C.QLineF_NewQLineF2(PointerFromQPointF(p1), PointerFromQPointF(p2)))
	runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
	return tmpValue
}

func NewQLineF3(x1 float64, y1 float64, x2 float64, y2 float64) *QLineF {
	tmpValue := NewQLineFFromPointer(C.QLineF_NewQLineF3(C.double(x1), C.double(y1), C.double(x2), C.double(y2)))
	runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
	return tmpValue
}

func NewQLineF4(line QLine_ITF) *QLineF {
	tmpValue := NewQLineFFromPointer(C.QLineF_NewQLineF4(PointerFromQLine(line)))
	runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
	return tmpValue
}

func (ptr *QLineF) Angle() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLineF_Angle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) AngleTo(line QLineF_ITF) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLineF_AngleTo(ptr.Pointer(), PointerFromQLineF(line)))
	}
	return 0
}

func (ptr *QLineF) Center() *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QLineF_Center(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QLineF) Dx() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLineF_Dx(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) Dy() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLineF_Dy(ptr.Pointer()))
	}
	return 0
}

func QLineF_FromPolar(length float64, angle float64) *QLineF {
	tmpValue := NewQLineFFromPointer(C.QLineF_QLineF_FromPolar(C.double(length), C.double(angle)))
	runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
	return tmpValue
}

func (ptr *QLineF) FromPolar(length float64, angle float64) *QLineF {
	tmpValue := NewQLineFFromPointer(C.QLineF_QLineF_FromPolar(C.double(length), C.double(angle)))
	runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
	return tmpValue
}

func (ptr *QLineF) Intersect(line QLineF_ITF, intersectionPoint QPointF_ITF) QLineF__IntersectType {
	if ptr.Pointer() != nil {
		return QLineF__IntersectType(C.QLineF_Intersect(ptr.Pointer(), PointerFromQLineF(line), PointerFromQPointF(intersectionPoint)))
	}
	return 0
}

func (ptr *QLineF) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineF_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineF) Length() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLineF_Length(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) NormalVector() *QLineF {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineFFromPointer(C.QLineF_NormalVector(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
		return tmpValue
	}
	return nil
}

func (ptr *QLineF) P1() *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QLineF_P1(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QLineF) P2() *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QLineF_P2(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QLineF) PointAt(t float64) *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QLineF_PointAt(ptr.Pointer(), C.double(t)))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QLineF) SetAngle(angle float64) {
	if ptr.Pointer() != nil {
		C.QLineF_SetAngle(ptr.Pointer(), C.double(angle))
	}
}

func (ptr *QLineF) SetLength(length float64) {
	if ptr.Pointer() != nil {
		C.QLineF_SetLength(ptr.Pointer(), C.double(length))
	}
}

func (ptr *QLineF) SetLine(x1 float64, y1 float64, x2 float64, y2 float64) {
	if ptr.Pointer() != nil {
		C.QLineF_SetLine(ptr.Pointer(), C.double(x1), C.double(y1), C.double(x2), C.double(y2))
	}
}

func (ptr *QLineF) SetP1(p1 QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QLineF_SetP1(ptr.Pointer(), PointerFromQPointF(p1))
	}
}

func (ptr *QLineF) SetP2(p2 QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QLineF_SetP2(ptr.Pointer(), PointerFromQPointF(p2))
	}
}

func (ptr *QLineF) SetPoints(p1 QPointF_ITF, p2 QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QLineF_SetPoints(ptr.Pointer(), PointerFromQPointF(p1), PointerFromQPointF(p2))
	}
}

func (ptr *QLineF) ToLine() *QLine {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineFromPointer(C.QLineF_ToLine(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLine).DestroyQLine)
		return tmpValue
	}
	return nil
}

func (ptr *QLineF) Translate(offset QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QLineF_Translate(ptr.Pointer(), PointerFromQPointF(offset))
	}
}

func (ptr *QLineF) Translate2(dx float64, dy float64) {
	if ptr.Pointer() != nil {
		C.QLineF_Translate2(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

func (ptr *QLineF) Translated(offset QPointF_ITF) *QLineF {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineFFromPointer(C.QLineF_Translated(ptr.Pointer(), PointerFromQPointF(offset)))
		runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
		return tmpValue
	}
	return nil
}

func (ptr *QLineF) Translated2(dx float64, dy float64) *QLineF {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineFFromPointer(C.QLineF_Translated2(ptr.Pointer(), C.double(dx), C.double(dy)))
		runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
		return tmpValue
	}
	return nil
}

func (ptr *QLineF) UnitVector() *QLineF {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineFFromPointer(C.QLineF_UnitVector(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
		return tmpValue
	}
	return nil
}

func (ptr *QLineF) X1() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLineF_X1(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) X2() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLineF_X2(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) Y1() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLineF_Y1(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) Y2() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLineF_Y2(ptr.Pointer()))
	}
	return 0
}

type QLinkedList struct {
	ptr unsafe.Pointer
}

type QLinkedList_ITF interface {
	QLinkedList_PTR() *QLinkedList
}

func (ptr *QLinkedList) QLinkedList_PTR() *QLinkedList {
	return ptr
}

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

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

func PointerFromQLinkedList(ptr QLinkedList_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLinkedList_PTR().Pointer()
	}
	return nil
}

func NewQLinkedListFromPointer(ptr unsafe.Pointer) (n *QLinkedList) {
	n = new(QLinkedList)
	n.SetPointer(ptr)
	return
}

type QLinkedListIterator struct {
	ptr unsafe.Pointer
}

type QLinkedListIterator_ITF interface {
	QLinkedListIterator_PTR() *QLinkedListIterator
}

func (ptr *QLinkedListIterator) QLinkedListIterator_PTR() *QLinkedListIterator {
	return ptr
}

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

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

func PointerFromQLinkedListIterator(ptr QLinkedListIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLinkedListIterator_PTR().Pointer()
	}
	return nil
}

func NewQLinkedListIteratorFromPointer(ptr unsafe.Pointer) (n *QLinkedListIterator) {
	n = new(QLinkedListIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QLinkedListIterator) DestroyQLinkedListIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QLinkedListNode struct {
	ptr unsafe.Pointer
}

type QLinkedListNode_ITF interface {
	QLinkedListNode_PTR() *QLinkedListNode
}

func (ptr *QLinkedListNode) QLinkedListNode_PTR() *QLinkedListNode {
	return ptr
}

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

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

func PointerFromQLinkedListNode(ptr QLinkedListNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLinkedListNode_PTR().Pointer()
	}
	return nil
}

func NewQLinkedListNodeFromPointer(ptr unsafe.Pointer) (n *QLinkedListNode) {
	n = new(QLinkedListNode)
	n.SetPointer(ptr)
	return
}

func (ptr *QLinkedListNode) DestroyQLinkedListNode() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QListData struct {
	ptr unsafe.Pointer
}

type QListData_ITF interface {
	QListData_PTR() *QListData
}

func (ptr *QListData) QListData_PTR() *QListData {
	return ptr
}

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

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

func PointerFromQListData(ptr QListData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QListData_PTR().Pointer()
	}
	return nil
}

func NewQListDataFromPointer(ptr unsafe.Pointer) (n *QListData) {
	n = new(QListData)
	n.SetPointer(ptr)
	return
}

func (ptr *QListData) DestroyQListData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QListIterator struct {
	ptr unsafe.Pointer
}

type QListIterator_ITF interface {
	QListIterator_PTR() *QListIterator
}

func (ptr *QListIterator) QListIterator_PTR() *QListIterator {
	return ptr
}

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

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

func PointerFromQListIterator(ptr QListIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QListIterator_PTR().Pointer()
	}
	return nil
}

func NewQListIteratorFromPointer(ptr unsafe.Pointer) (n *QListIterator) {
	n = new(QListIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QListIterator) DestroyQListIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QListSpecialMethods struct {
	ptr unsafe.Pointer
}

type QListSpecialMethods_ITF interface {
	QListSpecialMethods_PTR() *QListSpecialMethods
}

func (ptr *QListSpecialMethods) QListSpecialMethods_PTR() *QListSpecialMethods {
	return ptr
}

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

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

func PointerFromQListSpecialMethods(ptr QListSpecialMethods_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QListSpecialMethods_PTR().Pointer()
	}
	return nil
}

func NewQListSpecialMethodsFromPointer(ptr unsafe.Pointer) (n *QListSpecialMethods) {
	n = new(QListSpecialMethods)
	n.SetPointer(ptr)
	return
}

func (ptr *QListSpecialMethods) DestroyQListSpecialMethods() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QLittleEndianStorageType struct {
	ptr unsafe.Pointer
}

type QLittleEndianStorageType_ITF interface {
	QLittleEndianStorageType_PTR() *QLittleEndianStorageType
}

func (ptr *QLittleEndianStorageType) QLittleEndianStorageType_PTR() *QLittleEndianStorageType {
	return ptr
}

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

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

func PointerFromQLittleEndianStorageType(ptr QLittleEndianStorageType_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLittleEndianStorageType_PTR().Pointer()
	}
	return nil
}

func NewQLittleEndianStorageTypeFromPointer(ptr unsafe.Pointer) (n *QLittleEndianStorageType) {
	n = new(QLittleEndianStorageType)
	n.SetPointer(ptr)
	return
}

func (ptr *QLittleEndianStorageType) DestroyQLittleEndianStorageType() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QLocale struct {
	ptr unsafe.Pointer
}

type QLocale_ITF interface {
	QLocale_PTR() *QLocale
}

func (ptr *QLocale) QLocale_PTR() *QLocale {
	return ptr
}

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

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

func PointerFromQLocale(ptr QLocale_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLocale_PTR().Pointer()
	}
	return nil
}

func NewQLocaleFromPointer(ptr unsafe.Pointer) (n *QLocale) {
	n = new(QLocale)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QLocale__Language
//QLocale::Language
type QLocale__Language int64

const (
	QLocale__AnyLanguage               QLocale__Language = QLocale__Language(0)
	QLocale__C                         QLocale__Language = QLocale__Language(1)
	QLocale__Abkhazian                 QLocale__Language = QLocale__Language(2)
	QLocale__Oromo                     QLocale__Language = QLocale__Language(3)
	QLocale__Afar                      QLocale__Language = QLocale__Language(4)
	QLocale__Afrikaans                 QLocale__Language = QLocale__Language(5)
	QLocale__Albanian                  QLocale__Language = QLocale__Language(6)
	QLocale__Amharic                   QLocale__Language = QLocale__Language(7)
	QLocale__Arabic                    QLocale__Language = QLocale__Language(8)
	QLocale__Armenian                  QLocale__Language = QLocale__Language(9)
	QLocale__Assamese                  QLocale__Language = QLocale__Language(10)
	QLocale__Aymara                    QLocale__Language = QLocale__Language(11)
	QLocale__Azerbaijani               QLocale__Language = QLocale__Language(12)
	QLocale__Bashkir                   QLocale__Language = QLocale__Language(13)
	QLocale__Basque                    QLocale__Language = QLocale__Language(14)
	QLocale__Bengali                   QLocale__Language = QLocale__Language(15)
	QLocale__Dzongkha                  QLocale__Language = QLocale__Language(16)
	QLocale__Bihari                    QLocale__Language = QLocale__Language(17)
	QLocale__Bislama                   QLocale__Language = QLocale__Language(18)
	QLocale__Breton                    QLocale__Language = QLocale__Language(19)
	QLocale__Bulgarian                 QLocale__Language = QLocale__Language(20)
	QLocale__Burmese                   QLocale__Language = QLocale__Language(21)
	QLocale__Belarusian                QLocale__Language = QLocale__Language(22)
	QLocale__Khmer                     QLocale__Language = QLocale__Language(23)
	QLocale__Catalan                   QLocale__Language = QLocale__Language(24)
	QLocale__Chinese                   QLocale__Language = QLocale__Language(25)
	QLocale__Corsican                  QLocale__Language = QLocale__Language(26)
	QLocale__Croatian                  QLocale__Language = QLocale__Language(27)
	QLocale__Czech                     QLocale__Language = QLocale__Language(28)
	QLocale__Danish                    QLocale__Language = QLocale__Language(29)
	QLocale__Dutch                     QLocale__Language = QLocale__Language(30)
	QLocale__English                   QLocale__Language = QLocale__Language(31)
	QLocale__Esperanto                 QLocale__Language = QLocale__Language(32)
	QLocale__Estonian                  QLocale__Language = QLocale__Language(33)
	QLocale__Faroese                   QLocale__Language = QLocale__Language(34)
	QLocale__Fijian                    QLocale__Language = QLocale__Language(35)
	QLocale__Finnish                   QLocale__Language = QLocale__Language(36)
	QLocale__French                    QLocale__Language = QLocale__Language(37)
	QLocale__WesternFrisian            QLocale__Language = QLocale__Language(38)
	QLocale__Gaelic                    QLocale__Language = QLocale__Language(39)
	QLocale__Galician                  QLocale__Language = QLocale__Language(40)
	QLocale__Georgian                  QLocale__Language = QLocale__Language(41)
	QLocale__German                    QLocale__Language = QLocale__Language(42)
	QLocale__Greek                     QLocale__Language = QLocale__Language(43)
	QLocale__Greenlandic               QLocale__Language = QLocale__Language(44)
	QLocale__Guarani                   QLocale__Language = QLocale__Language(45)
	QLocale__Gujarati                  QLocale__Language = QLocale__Language(46)
	QLocale__Hausa                     QLocale__Language = QLocale__Language(47)
	QLocale__Hebrew                    QLocale__Language = QLocale__Language(48)
	QLocale__Hindi                     QLocale__Language = QLocale__Language(49)
	QLocale__Hungarian                 QLocale__Language = QLocale__Language(50)
	QLocale__Icelandic                 QLocale__Language = QLocale__Language(51)
	QLocale__Indonesian                QLocale__Language = QLocale__Language(52)
	QLocale__Interlingua               QLocale__Language = QLocale__Language(53)
	QLocale__Interlingue               QLocale__Language = QLocale__Language(54)
	QLocale__Inuktitut                 QLocale__Language = QLocale__Language(55)
	QLocale__Inupiak                   QLocale__Language = QLocale__Language(56)
	QLocale__Irish                     QLocale__Language = QLocale__Language(57)
	QLocale__Italian                   QLocale__Language = QLocale__Language(58)
	QLocale__Japanese                  QLocale__Language = QLocale__Language(59)
	QLocale__Javanese                  QLocale__Language = QLocale__Language(60)
	QLocale__Kannada                   QLocale__Language = QLocale__Language(61)
	QLocale__Kashmiri                  QLocale__Language = QLocale__Language(62)
	QLocale__Kazakh                    QLocale__Language = QLocale__Language(63)
	QLocale__Kinyarwanda               QLocale__Language = QLocale__Language(64)
	QLocale__Kirghiz                   QLocale__Language = QLocale__Language(65)
	QLocale__Korean                    QLocale__Language = QLocale__Language(66)
	QLocale__Kurdish                   QLocale__Language = QLocale__Language(67)
	QLocale__Rundi                     QLocale__Language = QLocale__Language(68)
	QLocale__Lao                       QLocale__Language = QLocale__Language(69)
	QLocale__Latin                     QLocale__Language = QLocale__Language(70)
	QLocale__Latvian                   QLocale__Language = QLocale__Language(71)
	QLocale__Lingala                   QLocale__Language = QLocale__Language(72)
	QLocale__Lithuanian                QLocale__Language = QLocale__Language(73)
	QLocale__Macedonian                QLocale__Language = QLocale__Language(74)
	QLocale__Malagasy                  QLocale__Language = QLocale__Language(75)
	QLocale__Malay                     QLocale__Language = QLocale__Language(76)
	QLocale__Malayalam                 QLocale__Language = QLocale__Language(77)
	QLocale__Maltese                   QLocale__Language = QLocale__Language(78)
	QLocale__Maori                     QLocale__Language = QLocale__Language(79)
	QLocale__Marathi                   QLocale__Language = QLocale__Language(80)
	QLocale__Marshallese               QLocale__Language = QLocale__Language(81)
	QLocale__Mongolian                 QLocale__Language = QLocale__Language(82)
	QLocale__NauruLanguage             QLocale__Language = QLocale__Language(83)
	QLocale__Nepali                    QLocale__Language = QLocale__Language(84)
	QLocale__NorwegianBokmal           QLocale__Language = QLocale__Language(85)
	QLocale__Occitan                   QLocale__Language = QLocale__Language(86)
	QLocale__Oriya                     QLocale__Language = QLocale__Language(87)
	QLocale__Pashto                    QLocale__Language = QLocale__Language(88)
	QLocale__Persian                   QLocale__Language = QLocale__Language(89)
	QLocale__Polish                    QLocale__Language = QLocale__Language(90)
	QLocale__Portuguese                QLocale__Language = QLocale__Language(91)
	QLocale__Punjabi                   QLocale__Language = QLocale__Language(92)
	QLocale__Quechua                   QLocale__Language = QLocale__Language(93)
	QLocale__Romansh                   QLocale__Language = QLocale__Language(94)
	QLocale__Romanian                  QLocale__Language = QLocale__Language(95)
	QLocale__Russian                   QLocale__Language = QLocale__Language(96)
	QLocale__Samoan                    QLocale__Language = QLocale__Language(97)
	QLocale__Sango                     QLocale__Language = QLocale__Language(98)
	QLocale__Sanskrit                  QLocale__Language = QLocale__Language(99)
	QLocale__Serbian                   QLocale__Language = QLocale__Language(100)
	QLocale__Ossetic                   QLocale__Language = QLocale__Language(101)
	QLocale__SouthernSotho             QLocale__Language = QLocale__Language(102)
	QLocale__Tswana                    QLocale__Language = QLocale__Language(103)
	QLocale__Shona                     QLocale__Language = QLocale__Language(104)
	QLocale__Sindhi                    QLocale__Language = QLocale__Language(105)
	QLocale__Sinhala                   QLocale__Language = QLocale__Language(106)
	QLocale__Swati                     QLocale__Language = QLocale__Language(107)
	QLocale__Slovak                    QLocale__Language = QLocale__Language(108)
	QLocale__Slovenian                 QLocale__Language = QLocale__Language(109)
	QLocale__Somali                    QLocale__Language = QLocale__Language(110)
	QLocale__Spanish                   QLocale__Language = QLocale__Language(111)
	QLocale__Sundanese                 QLocale__Language = QLocale__Language(112)
	QLocale__Swahili                   QLocale__Language = QLocale__Language(113)
	QLocale__Swedish                   QLocale__Language = QLocale__Language(114)
	QLocale__Sardinian                 QLocale__Language = QLocale__Language(115)
	QLocale__Tajik                     QLocale__Language = QLocale__Language(116)
	QLocale__Tamil                     QLocale__Language = QLocale__Language(117)
	QLocale__Tatar                     QLocale__Language = QLocale__Language(118)
	QLocale__Telugu                    QLocale__Language = QLocale__Language(119)
	QLocale__Thai                      QLocale__Language = QLocale__Language(120)
	QLocale__Tibetan                   QLocale__Language = QLocale__Language(121)
	QLocale__Tigrinya                  QLocale__Language = QLocale__Language(122)
	QLocale__Tongan                    QLocale__Language = QLocale__Language(123)
	QLocale__Tsonga                    QLocale__Language = QLocale__Language(124)
	QLocale__Turkish                   QLocale__Language = QLocale__Language(125)
	QLocale__Turkmen                   QLocale__Language = QLocale__Language(126)
	QLocale__Tahitian                  QLocale__Language = QLocale__Language(127)
	QLocale__Uighur                    QLocale__Language = QLocale__Language(128)
	QLocale__Ukrainian                 QLocale__Language = QLocale__Language(129)
	QLocale__Urdu                      QLocale__Language = QLocale__Language(130)
	QLocale__Uzbek                     QLocale__Language = QLocale__Language(131)
	QLocale__Vietnamese                QLocale__Language = QLocale__Language(132)
	QLocale__Volapuk                   QLocale__Language = QLocale__Language(133)
	QLocale__Welsh                     QLocale__Language = QLocale__Language(134)
	QLocale__Wolof                     QLocale__Language = QLocale__Language(135)
	QLocale__Xhosa                     QLocale__Language = QLocale__Language(136)
	QLocale__Yiddish                   QLocale__Language = QLocale__Language(137)
	QLocale__Yoruba                    QLocale__Language = QLocale__Language(138)
	QLocale__Zhuang                    QLocale__Language = QLocale__Language(139)
	QLocale__Zulu                      QLocale__Language = QLocale__Language(140)
	QLocale__NorwegianNynorsk          QLocale__Language = QLocale__Language(141)
	QLocale__Bosnian                   QLocale__Language = QLocale__Language(142)
	QLocale__Divehi                    QLocale__Language = QLocale__Language(143)
	QLocale__Manx                      QLocale__Language = QLocale__Language(144)
	QLocale__Cornish                   QLocale__Language = QLocale__Language(145)
	QLocale__Akan                      QLocale__Language = QLocale__Language(146)
	QLocale__Konkani                   QLocale__Language = QLocale__Language(147)
	QLocale__Ga                        QLocale__Language = QLocale__Language(148)
	QLocale__Igbo                      QLocale__Language = QLocale__Language(149)
	QLocale__Kamba                     QLocale__Language = QLocale__Language(150)
	QLocale__Syriac                    QLocale__Language = QLocale__Language(151)
	QLocale__Blin                      QLocale__Language = QLocale__Language(152)
	QLocale__Geez                      QLocale__Language = QLocale__Language(153)
	QLocale__Koro                      QLocale__Language = QLocale__Language(154)
	QLocale__Sidamo                    QLocale__Language = QLocale__Language(155)
	QLocale__Atsam                     QLocale__Language = QLocale__Language(156)
	QLocale__Tigre                     QLocale__Language = QLocale__Language(157)
	QLocale__Jju                       QLocale__Language = QLocale__Language(158)
	QLocale__Friulian                  QLocale__Language = QLocale__Language(159)
	QLocale__Venda                     QLocale__Language = QLocale__Language(160)
	QLocale__Ewe                       QLocale__Language = QLocale__Language(161)
	QLocale__Walamo                    QLocale__Language = QLocale__Language(162)
	QLocale__Hawaiian                  QLocale__Language = QLocale__Language(163)
	QLocale__Tyap                      QLocale__Language = QLocale__Language(164)
	QLocale__Nyanja                    QLocale__Language = QLocale__Language(165)
	QLocale__Filipino                  QLocale__Language = QLocale__Language(166)
	QLocale__SwissGerman               QLocale__Language = QLocale__Language(167)
	QLocale__SichuanYi                 QLocale__Language = QLocale__Language(168)
	QLocale__Kpelle                    QLocale__Language = QLocale__Language(169)
	QLocale__LowGerman                 QLocale__Language = QLocale__Language(170)
	QLocale__SouthNdebele              QLocale__Language = QLocale__Language(171)
	QLocale__NorthernSotho             QLocale__Language = QLocale__Language(172)
	QLocale__NorthernSami              QLocale__Language = QLocale__Language(173)
	QLocale__Taroko                    QLocale__Language = QLocale__Language(174)
	QLocale__Gusii                     QLocale__Language = QLocale__Language(175)
	QLocale__Taita                     QLocale__Language = QLocale__Language(176)
	QLocale__Fulah                     QLocale__Language = QLocale__Language(177)
	QLocale__Kikuyu                    QLocale__Language = QLocale__Language(178)
	QLocale__Samburu                   QLocale__Language = QLocale__Language(179)
	QLocale__Sena                      QLocale__Language = QLocale__Language(180)
	QLocale__NorthNdebele              QLocale__Language = QLocale__Language(181)
	QLocale__Rombo                     QLocale__Language = QLocale__Language(182)
	QLocale__Tachelhit                 QLocale__Language = QLocale__Language(183)
	QLocale__Kabyle                    QLocale__Language = QLocale__Language(184)
	QLocale__Nyankole                  QLocale__Language = QLocale__Language(185)
	QLocale__Bena                      QLocale__Language = QLocale__Language(186)
	QLocale__Vunjo                     QLocale__Language = QLocale__Language(187)
	QLocale__Bambara                   QLocale__Language = QLocale__Language(188)
	QLocale__Embu                      QLocale__Language = QLocale__Language(189)
	QLocale__Cherokee                  QLocale__Language = QLocale__Language(190)
	QLocale__Morisyen                  QLocale__Language = QLocale__Language(191)
	QLocale__Makonde                   QLocale__Language = QLocale__Language(192)
	QLocale__Langi                     QLocale__Language = QLocale__Language(193)
	QLocale__Ganda                     QLocale__Language = QLocale__Language(194)
	QLocale__Bemba                     QLocale__Language = QLocale__Language(195)
	QLocale__Kabuverdianu              QLocale__Language = QLocale__Language(196)
	QLocale__Meru                      QLocale__Language = QLocale__Language(197)
	QLocale__Kalenjin                  QLocale__Language = QLocale__Language(198)
	QLocale__Nama                      QLocale__Language = QLocale__Language(199)
	QLocale__Machame                   QLocale__Language = QLocale__Language(200)
	QLocale__Colognian                 QLocale__Language = QLocale__Language(201)
	QLocale__Masai                     QLocale__Language = QLocale__Language(202)
	QLocale__Soga                      QLocale__Language = QLocale__Language(203)
	QLocale__Luyia                     QLocale__Language = QLocale__Language(204)
	QLocale__Asu                       QLocale__Language = QLocale__Language(205)
	QLocale__Teso                      QLocale__Language = QLocale__Language(206)
	QLocale__Saho                      QLocale__Language = QLocale__Language(207)
	QLocale__KoyraChiini               QLocale__Language = QLocale__Language(208)
	QLocale__Rwa                       QLocale__Language = QLocale__Language(209)
	QLocale__Luo                       QLocale__Language = QLocale__Language(210)
	QLocale__Chiga                     QLocale__Language = QLocale__Language(211)
	QLocale__CentralMoroccoTamazight   QLocale__Language = QLocale__Language(212)
	QLocale__KoyraboroSenni            QLocale__Language = QLocale__Language(213)
	QLocale__Shambala                  QLocale__Language = QLocale__Language(214)
	QLocale__Bodo                      QLocale__Language = QLocale__Language(215)
	QLocale__Avaric                    QLocale__Language = QLocale__Language(216)
	QLocale__Chamorro                  QLocale__Language = QLocale__Language(217)
	QLocale__Chechen                   QLocale__Language = QLocale__Language(218)
	QLocale__Church                    QLocale__Language = QLocale__Language(219)
	QLocale__Chuvash                   QLocale__Language = QLocale__Language(220)
	QLocale__Cree                      QLocale__Language = QLocale__Language(221)
	QLocale__Haitian                   QLocale__Language = QLocale__Language(222)
	QLocale__Herero                    QLocale__Language = QLocale__Language(223)
	QLocale__HiriMotu                  QLocale__Language = QLocale__Language(224)
	QLocale__Kanuri                    QLocale__Language = QLocale__Language(225)
	QLocale__Komi                      QLocale__Language = QLocale__Language(226)
	QLocale__Kongo                     QLocale__Language = QLocale__Language(227)
	QLocale__Kwanyama                  QLocale__Language = QLocale__Language(228)
	QLocale__Limburgish                QLocale__Language = QLocale__Language(229)
	QLocale__LubaKatanga               QLocale__Language = QLocale__Language(230)
	QLocale__Luxembourgish             QLocale__Language = QLocale__Language(231)
	QLocale__Navaho                    QLocale__Language = QLocale__Language(232)
	QLocale__Ndonga                    QLocale__Language = QLocale__Language(233)
	QLocale__Ojibwa                    QLocale__Language = QLocale__Language(234)
	QLocale__Pali                      QLocale__Language = QLocale__Language(235)
	QLocale__Walloon                   QLocale__Language = QLocale__Language(236)
	QLocale__Aghem                     QLocale__Language = QLocale__Language(237)
	QLocale__Basaa                     QLocale__Language = QLocale__Language(238)
	QLocale__Zarma                     QLocale__Language = QLocale__Language(239)
	QLocale__Duala                     QLocale__Language = QLocale__Language(240)
	QLocale__JolaFonyi                 QLocale__Language = QLocale__Language(241)
	QLocale__Ewondo                    QLocale__Language = QLocale__Language(242)
	QLocale__Bafia                     QLocale__Language = QLocale__Language(243)
	QLocale__MakhuwaMeetto             QLocale__Language = QLocale__Language(244)
	QLocale__Mundang                   QLocale__Language = QLocale__Language(245)
	QLocale__Kwasio                    QLocale__Language = QLocale__Language(246)
	QLocale__Nuer                      QLocale__Language = QLocale__Language(247)
	QLocale__Sakha                     QLocale__Language = QLocale__Language(248)
	QLocale__Sangu                     QLocale__Language = QLocale__Language(249)
	QLocale__CongoSwahili              QLocale__Language = QLocale__Language(250)
	QLocale__Tasawaq                   QLocale__Language = QLocale__Language(251)
	QLocale__Vai                       QLocale__Language = QLocale__Language(252)
	QLocale__Walser                    QLocale__Language = QLocale__Language(253)
	QLocale__Yangben                   QLocale__Language = QLocale__Language(254)
	QLocale__Avestan                   QLocale__Language = QLocale__Language(255)
	QLocale__Asturian                  QLocale__Language = QLocale__Language(256)
	QLocale__Ngomba                    QLocale__Language = QLocale__Language(257)
	QLocale__Kako                      QLocale__Language = QLocale__Language(258)
	QLocale__Meta                      QLocale__Language = QLocale__Language(259)
	QLocale__Ngiemboon                 QLocale__Language = QLocale__Language(260)
	QLocale__Aragonese                 QLocale__Language = QLocale__Language(261)
	QLocale__Akkadian                  QLocale__Language = QLocale__Language(262)
	QLocale__AncientEgyptian           QLocale__Language = QLocale__Language(263)
	QLocale__AncientGreek              QLocale__Language = QLocale__Language(264)
	QLocale__Aramaic                   QLocale__Language = QLocale__Language(265)
	QLocale__Balinese                  QLocale__Language = QLocale__Language(266)
	QLocale__Bamun                     QLocale__Language = QLocale__Language(267)
	QLocale__BatakToba                 QLocale__Language = QLocale__Language(268)
	QLocale__Buginese                  QLocale__Language = QLocale__Language(269)
	QLocale__Buhid                     QLocale__Language = QLocale__Language(270)
	QLocale__Carian                    QLocale__Language = QLocale__Language(271)
	QLocale__Chakma                    QLocale__Language = QLocale__Language(272)
	QLocale__ClassicalMandaic          QLocale__Language = QLocale__Language(273)
	QLocale__Coptic                    QLocale__Language = QLocale__Language(274)
	QLocale__Dogri                     QLocale__Language = QLocale__Language(275)
	QLocale__EasternCham               QLocale__Language = QLocale__Language(276)
	QLocale__EasternKayah              QLocale__Language = QLocale__Language(277)
	QLocale__Etruscan                  QLocale__Language = QLocale__Language(278)
	QLocale__Gothic                    QLocale__Language = QLocale__Language(279)
	QLocale__Hanunoo                   QLocale__Language = QLocale__Language(280)
	QLocale__Ingush                    QLocale__Language = QLocale__Language(281)
	QLocale__LargeFloweryMiao          QLocale__Language = QLocale__Language(282)
	QLocale__Lepcha                    QLocale__Language = QLocale__Language(283)
	QLocale__Limbu                     QLocale__Language = QLocale__Language(284)
	QLocale__Lisu                      QLocale__Language = QLocale__Language(285)
	QLocale__Lu                        QLocale__Language = QLocale__Language(286)
	QLocale__Lycian                    QLocale__Language = QLocale__Language(287)
	QLocale__Lydian                    QLocale__Language = QLocale__Language(288)
	QLocale__Mandingo                  QLocale__Language = QLocale__Language(289)
	QLocale__Manipuri                  QLocale__Language = QLocale__Language(290)
	QLocale__Meroitic                  QLocale__Language = QLocale__Language(291)
	QLocale__NorthernThai              QLocale__Language = QLocale__Language(292)
	QLocale__OldIrish                  QLocale__Language = QLocale__Language(293)
	QLocale__OldNorse                  QLocale__Language = QLocale__Language(294)
	QLocale__OldPersian                QLocale__Language = QLocale__Language(295)
	QLocale__OldTurkish                QLocale__Language = QLocale__Language(296)
	QLocale__Pahlavi                   QLocale__Language = QLocale__Language(297)
	QLocale__Parthian                  QLocale__Language = QLocale__Language(298)
	QLocale__Phoenician                QLocale__Language = QLocale__Language(299)
	QLocale__PrakritLanguage           QLocale__Language = QLocale__Language(300)
	QLocale__Rejang                    QLocale__Language = QLocale__Language(301)
	QLocale__Sabaean                   QLocale__Language = QLocale__Language(302)
	QLocale__Samaritan                 QLocale__Language = QLocale__Language(303)
	QLocale__Santali                   QLocale__Language = QLocale__Language(304)
	QLocale__Saurashtra                QLocale__Language = QLocale__Language(305)
	QLocale__Sora                      QLocale__Language = QLocale__Language(306)
	QLocale__Sylheti                   QLocale__Language = QLocale__Language(307)
	QLocale__Tagbanwa                  QLocale__Language = QLocale__Language(308)
	QLocale__TaiDam                    QLocale__Language = QLocale__Language(309)
	QLocale__TaiNua                    QLocale__Language = QLocale__Language(310)
	QLocale__Ugaritic                  QLocale__Language = QLocale__Language(311)
	QLocale__Akoose                    QLocale__Language = QLocale__Language(312)
	QLocale__Lakota                    QLocale__Language = QLocale__Language(313)
	QLocale__StandardMoroccanTamazight QLocale__Language = QLocale__Language(314)
	QLocale__Mapuche                   QLocale__Language = QLocale__Language(315)
	QLocale__CentralKurdish            QLocale__Language = QLocale__Language(316)
	QLocale__LowerSorbian              QLocale__Language = QLocale__Language(317)
	QLocale__UpperSorbian              QLocale__Language = QLocale__Language(318)
	QLocale__Kenyang                   QLocale__Language = QLocale__Language(319)
	QLocale__Mohawk                    QLocale__Language = QLocale__Language(320)
	QLocale__Nko                       QLocale__Language = QLocale__Language(321)
	QLocale__Prussian                  QLocale__Language = QLocale__Language(322)
	QLocale__Kiche                     QLocale__Language = QLocale__Language(323)
	QLocale__SouthernSami              QLocale__Language = QLocale__Language(324)
	QLocale__LuleSami                  QLocale__Language = QLocale__Language(325)
	QLocale__InariSami                 QLocale__Language = QLocale__Language(326)
	QLocale__SkoltSami                 QLocale__Language = QLocale__Language(327)
	QLocale__Warlpiri                  QLocale__Language = QLocale__Language(328)
	QLocale__ManichaeanMiddlePersian   QLocale__Language = QLocale__Language(329)
	QLocale__Mende                     QLocale__Language = QLocale__Language(330)
	QLocale__AncientNorthArabian       QLocale__Language = QLocale__Language(331)
	QLocale__LinearA                   QLocale__Language = QLocale__Language(332)
	QLocale__HmongNjua                 QLocale__Language = QLocale__Language(333)
	QLocale__Ho                        QLocale__Language = QLocale__Language(334)
	QLocale__Lezghian                  QLocale__Language = QLocale__Language(335)
	QLocale__Bassa                     QLocale__Language = QLocale__Language(336)
	QLocale__Mono                      QLocale__Language = QLocale__Language(337)
	QLocale__TedimChin                 QLocale__Language = QLocale__Language(338)
	QLocale__Maithili                  QLocale__Language = QLocale__Language(339)
	QLocale__Ahom                      QLocale__Language = QLocale__Language(340)
	QLocale__AmericanSignLanguage      QLocale__Language = QLocale__Language(341)
	QLocale__ArdhamagadhiPrakrit       QLocale__Language = QLocale__Language(342)
	QLocale__Bhojpuri                  QLocale__Language = QLocale__Language(343)
	QLocale__HieroglyphicLuwian        QLocale__Language = QLocale__Language(344)
	QLocale__LiteraryChinese           QLocale__Language = QLocale__Language(345)
	QLocale__Mazanderani               QLocale__Language = QLocale__Language(346)
	QLocale__Mru                       QLocale__Language = QLocale__Language(347)
	QLocale__Newari                    QLocale__Language = QLocale__Language(348)
	QLocale__NorthernLuri              QLocale__Language = QLocale__Language(349)
	QLocale__Palauan                   QLocale__Language = QLocale__Language(350)
	QLocale__Papiamento                QLocale__Language = QLocale__Language(351)
	QLocale__Saraiki                   QLocale__Language = QLocale__Language(352)
	QLocale__TokelauLanguage           QLocale__Language = QLocale__Language(353)
	QLocale__TokPisin                  QLocale__Language = QLocale__Language(354)
	QLocale__TuvaluLanguage            QLocale__Language = QLocale__Language(355)
	QLocale__UncodedLanguages          QLocale__Language = QLocale__Language(356)
	QLocale__Cantonese                 QLocale__Language = QLocale__Language(357)
	QLocale__Osage                     QLocale__Language = QLocale__Language(358)
	QLocale__Tangut                    QLocale__Language = QLocale__Language(359)
	QLocale__Ido                       QLocale__Language = QLocale__Language(360)
	QLocale__Lojban                    QLocale__Language = QLocale__Language(361)
	QLocale__Sicilian                  QLocale__Language = QLocale__Language(362)
	QLocale__SouthernKurdish           QLocale__Language = QLocale__Language(363)
	QLocale__WesternBalochi            QLocale__Language = QLocale__Language(364)
	QLocale__Afan                      QLocale__Language = QLocale__Language(QLocale__Oromo)
	QLocale__Bhutani                   QLocale__Language = QLocale__Language(QLocale__Dzongkha)
	QLocale__Byelorussian              QLocale__Language = QLocale__Language(QLocale__Belarusian)
	QLocale__Cambodian                 QLocale__Language = QLocale__Language(QLocale__Khmer)
	QLocale__Chewa                     QLocale__Language = QLocale__Language(QLocale__Nyanja)
	QLocale__Frisian                   QLocale__Language = QLocale__Language(QLocale__WesternFrisian)
	QLocale__Kurundi                   QLocale__Language = QLocale__Language(QLocale__Rundi)
	QLocale__Moldavian                 QLocale__Language = QLocale__Language(QLocale__Romanian)
	QLocale__Norwegian                 QLocale__Language = QLocale__Language(QLocale__NorwegianBokmal)
	QLocale__RhaetoRomance             QLocale__Language = QLocale__Language(QLocale__Romansh)
	QLocale__SerboCroatian             QLocale__Language = QLocale__Language(QLocale__Serbian)
	QLocale__Tagalog                   QLocale__Language = QLocale__Language(QLocale__Filipino)
	QLocale__Twi                       QLocale__Language = QLocale__Language(QLocale__Akan)
	QLocale__Uigur                     QLocale__Language = QLocale__Language(QLocale__Uighur)
	QLocale__LastLanguage              QLocale__Language = QLocale__Language(QLocale__WesternBalochi)
)

//go:generate stringer -type=QLocale__Script
//QLocale::Script
type QLocale__Script int64

const (
	QLocale__AnyScript                   QLocale__Script = QLocale__Script(0)
	QLocale__ArabicScript                QLocale__Script = QLocale__Script(1)
	QLocale__CyrillicScript              QLocale__Script = QLocale__Script(2)
	QLocale__DeseretScript               QLocale__Script = QLocale__Script(3)
	QLocale__GurmukhiScript              QLocale__Script = QLocale__Script(4)
	QLocale__SimplifiedHanScript         QLocale__Script = QLocale__Script(5)
	QLocale__TraditionalHanScript        QLocale__Script = QLocale__Script(6)
	QLocale__LatinScript                 QLocale__Script = QLocale__Script(7)
	QLocale__MongolianScript             QLocale__Script = QLocale__Script(8)
	QLocale__TifinaghScript              QLocale__Script = QLocale__Script(9)
	QLocale__ArmenianScript              QLocale__Script = QLocale__Script(10)
	QLocale__BengaliScript               QLocale__Script = QLocale__Script(11)
	QLocale__CherokeeScript              QLocale__Script = QLocale__Script(12)
	QLocale__DevanagariScript            QLocale__Script = QLocale__Script(13)
	QLocale__EthiopicScript              QLocale__Script = QLocale__Script(14)
	QLocale__GeorgianScript              QLocale__Script = QLocale__Script(15)
	QLocale__GreekScript                 QLocale__Script = QLocale__Script(16)
	QLocale__GujaratiScript              QLocale__Script = QLocale__Script(17)
	QLocale__HebrewScript                QLocale__Script = QLocale__Script(18)
	QLocale__JapaneseScript              QLocale__Script = QLocale__Script(19)
	QLocale__KhmerScript                 QLocale__Script = QLocale__Script(20)
	QLocale__KannadaScript               QLocale__Script = QLocale__Script(21)
	QLocale__KoreanScript                QLocale__Script = QLocale__Script(22)
	QLocale__LaoScript                   QLocale__Script = QLocale__Script(23)
	QLocale__MalayalamScript             QLocale__Script = QLocale__Script(24)
	QLocale__MyanmarScript               QLocale__Script = QLocale__Script(25)
	QLocale__OriyaScript                 QLocale__Script = QLocale__Script(26)
	QLocale__TamilScript                 QLocale__Script = QLocale__Script(27)
	QLocale__TeluguScript                QLocale__Script = QLocale__Script(28)
	QLocale__ThaanaScript                QLocale__Script = QLocale__Script(29)
	QLocale__ThaiScript                  QLocale__Script = QLocale__Script(30)
	QLocale__TibetanScript               QLocale__Script = QLocale__Script(31)
	QLocale__SinhalaScript               QLocale__Script = QLocale__Script(32)
	QLocale__SyriacScript                QLocale__Script = QLocale__Script(33)
	QLocale__YiScript                    QLocale__Script = QLocale__Script(34)
	QLocale__VaiScript                   QLocale__Script = QLocale__Script(35)
	QLocale__AvestanScript               QLocale__Script = QLocale__Script(36)
	QLocale__BalineseScript              QLocale__Script = QLocale__Script(37)
	QLocale__BamumScript                 QLocale__Script = QLocale__Script(38)
	QLocale__BatakScript                 QLocale__Script = QLocale__Script(39)
	QLocale__BopomofoScript              QLocale__Script = QLocale__Script(40)
	QLocale__BrahmiScript                QLocale__Script = QLocale__Script(41)
	QLocale__BugineseScript              QLocale__Script = QLocale__Script(42)
	QLocale__BuhidScript                 QLocale__Script = QLocale__Script(43)
	QLocale__CanadianAboriginalScript    QLocale__Script = QLocale__Script(44)
	QLocale__CarianScript                QLocale__Script = QLocale__Script(45)
	QLocale__ChakmaScript                QLocale__Script = QLocale__Script(46)
	QLocale__ChamScript                  QLocale__Script = QLocale__Script(47)
	QLocale__CopticScript                QLocale__Script = QLocale__Script(48)
	QLocale__CypriotScript               QLocale__Script = QLocale__Script(49)
	QLocale__EgyptianHieroglyphsScript   QLocale__Script = QLocale__Script(50)
	QLocale__FraserScript                QLocale__Script = QLocale__Script(51)
	QLocale__GlagoliticScript            QLocale__Script = QLocale__Script(52)
	QLocale__GothicScript                QLocale__Script = QLocale__Script(53)
	QLocale__HanScript                   QLocale__Script = QLocale__Script(54)
	QLocale__HangulScript                QLocale__Script = QLocale__Script(55)
	QLocale__HanunooScript               QLocale__Script = QLocale__Script(56)
	QLocale__ImperialAramaicScript       QLocale__Script = QLocale__Script(57)
	QLocale__InscriptionalPahlaviScript  QLocale__Script = QLocale__Script(58)
	QLocale__InscriptionalParthianScript QLocale__Script = QLocale__Script(59)
	QLocale__JavaneseScript              QLocale__Script = QLocale__Script(60)
	QLocale__KaithiScript                QLocale__Script = QLocale__Script(61)
	QLocale__KatakanaScript              QLocale__Script = QLocale__Script(62)
	QLocale__KayahLiScript               QLocale__Script = QLocale__Script(63)
	QLocale__KharoshthiScript            QLocale__Script = QLocale__Script(64)
	QLocale__LannaScript                 QLocale__Script = QLocale__Script(65)
	QLocale__LepchaScript                QLocale__Script = QLocale__Script(66)
	QLocale__LimbuScript                 QLocale__Script = QLocale__Script(67)
	QLocale__LinearBScript               QLocale__Script = QLocale__Script(68)
	QLocale__LycianScript                QLocale__Script = QLocale__Script(69)
	QLocale__LydianScript                QLocale__Script = QLocale__Script(70)
	QLocale__MandaeanScript              QLocale__Script = QLocale__Script(71)
	QLocale__MeiteiMayekScript           QLocale__Script = QLocale__Script(72)
	QLocale__MeroiticScript              QLocale__Script = QLocale__Script(73)
	QLocale__MeroiticCursiveScript       QLocale__Script = QLocale__Script(74)
	QLocale__NkoScript                   QLocale__Script = QLocale__Script(75)
	QLocale__NewTaiLueScript             QLocale__Script = QLocale__Script(76)
	QLocale__OghamScript                 QLocale__Script = QLocale__Script(77)
	QLocale__OlChikiScript               QLocale__Script = QLocale__Script(78)
	QLocale__OldItalicScript             QLocale__Script = QLocale__Script(79)
	QLocale__OldPersianScript            QLocale__Script = QLocale__Script(80)
	QLocale__OldSouthArabianScript       QLocale__Script = QLocale__Script(81)
	QLocale__OrkhonScript                QLocale__Script = QLocale__Script(82)
	QLocale__OsmanyaScript               QLocale__Script = QLocale__Script(83)
	QLocale__PhagsPaScript               QLocale__Script = QLocale__Script(84)
	QLocale__PhoenicianScript            QLocale__Script = QLocale__Script(85)
	QLocale__PollardPhoneticScript       QLocale__Script = QLocale__Script(86)
	QLocale__RejangScript                QLocale__Script = QLocale__Script(87)
	QLocale__RunicScript                 QLocale__Script = QLocale__Script(88)
	QLocale__SamaritanScript             QLocale__Script = QLocale__Script(89)
	QLocale__SaurashtraScript            QLocale__Script = QLocale__Script(90)
	QLocale__SharadaScript               QLocale__Script = QLocale__Script(91)
	QLocale__ShavianScript               QLocale__Script = QLocale__Script(92)
	QLocale__SoraSompengScript           QLocale__Script = QLocale__Script(93)
	QLocale__CuneiformScript             QLocale__Script = QLocale__Script(94)
	QLocale__SundaneseScript             QLocale__Script = QLocale__Script(95)
	QLocale__SylotiNagriScript           QLocale__Script = QLocale__Script(96)
	QLocale__TagalogScript               QLocale__Script = QLocale__Script(97)
	QLocale__TagbanwaScript              QLocale__Script = QLocale__Script(98)
	QLocale__TaiLeScript                 QLocale__Script = QLocale__Script(99)
	QLocale__TaiVietScript               QLocale__Script = QLocale__Script(100)
	QLocale__TakriScript                 QLocale__Script = QLocale__Script(101)
	QLocale__UgariticScript              QLocale__Script = QLocale__Script(102)
	QLocale__BrailleScript               QLocale__Script = QLocale__Script(103)
	QLocale__HiraganaScript              QLocale__Script = QLocale__Script(104)
	QLocale__CaucasianAlbanianScript     QLocale__Script = QLocale__Script(105)
	QLocale__BassaVahScript              QLocale__Script = QLocale__Script(106)
	QLocale__DuployanScript              QLocale__Script = QLocale__Script(107)
	QLocale__ElbasanScript               QLocale__Script = QLocale__Script(108)
	QLocale__GranthaScript               QLocale__Script = QLocale__Script(109)
	QLocale__PahawhHmongScript           QLocale__Script = QLocale__Script(110)
	QLocale__KhojkiScript                QLocale__Script = QLocale__Script(111)
	QLocale__LinearAScript               QLocale__Script = QLocale__Script(112)
	QLocale__MahajaniScript              QLocale__Script = QLocale__Script(113)
	QLocale__ManichaeanScript            QLocale__Script = QLocale__Script(114)
	QLocale__MendeKikakuiScript          QLocale__Script = QLocale__Script(115)
	QLocale__ModiScript                  QLocale__Script = QLocale__Script(116)
	QLocale__MroScript                   QLocale__Script = QLocale__Script(117)
	QLocale__OldNorthArabianScript       QLocale__Script = QLocale__Script(118)
	QLocale__NabataeanScript             QLocale__Script = QLocale__Script(119)
	QLocale__PalmyreneScript             QLocale__Script = QLocale__Script(120)
	QLocale__PauCinHauScript             QLocale__Script = QLocale__Script(121)
	QLocale__OldPermicScript             QLocale__Script = QLocale__Script(122)
	QLocale__PsalterPahlaviScript        QLocale__Script = QLocale__Script(123)
	QLocale__SiddhamScript               QLocale__Script = QLocale__Script(124)
	QLocale__KhudawadiScript             QLocale__Script = QLocale__Script(125)
	QLocale__TirhutaScript               QLocale__Script = QLocale__Script(126)
	QLocale__VarangKshitiScript          QLocale__Script = QLocale__Script(127)
	QLocale__AhomScript                  QLocale__Script = QLocale__Script(128)
	QLocale__AnatolianHieroglyphsScript  QLocale__Script = QLocale__Script(129)
	QLocale__HatranScript                QLocale__Script = QLocale__Script(130)
	QLocale__MultaniScript               QLocale__Script = QLocale__Script(131)
	QLocale__OldHungarianScript          QLocale__Script = QLocale__Script(132)
	QLocale__SignWritingScript           QLocale__Script = QLocale__Script(133)
	QLocale__AdlamScript                 QLocale__Script = QLocale__Script(134)
	QLocale__BhaiksukiScript             QLocale__Script = QLocale__Script(135)
	QLocale__MarchenScript               QLocale__Script = QLocale__Script(136)
	QLocale__NewaScript                  QLocale__Script = QLocale__Script(137)
	QLocale__OsageScript                 QLocale__Script = QLocale__Script(138)
	QLocale__TangutScript                QLocale__Script = QLocale__Script(139)
	QLocale__HanWithBopomofoScript       QLocale__Script = QLocale__Script(140)
	QLocale__JamoScript                  QLocale__Script = QLocale__Script(141)
	QLocale__SimplifiedChineseScript     QLocale__Script = QLocale__Script(QLocale__SimplifiedHanScript)
	QLocale__TraditionalChineseScript    QLocale__Script = QLocale__Script(QLocale__TraditionalHanScript)
	QLocale__LastScript                  QLocale__Script = QLocale__Script(QLocale__JamoScript)
)

//go:generate stringer -type=QLocale__Country
//QLocale::Country
type QLocale__Country int64

const (
	QLocale__AnyCountry                             QLocale__Country = QLocale__Country(0)
	QLocale__Afghanistan                            QLocale__Country = QLocale__Country(1)
	QLocale__Albania                                QLocale__Country = QLocale__Country(2)
	QLocale__Algeria                                QLocale__Country = QLocale__Country(3)
	QLocale__AmericanSamoa                          QLocale__Country = QLocale__Country(4)
	QLocale__Andorra                                QLocale__Country = QLocale__Country(5)
	QLocale__Angola                                 QLocale__Country = QLocale__Country(6)
	QLocale__Anguilla                               QLocale__Country = QLocale__Country(7)
	QLocale__Antarctica                             QLocale__Country = QLocale__Country(8)
	QLocale__AntiguaAndBarbuda                      QLocale__Country = QLocale__Country(9)
	QLocale__Argentina                              QLocale__Country = QLocale__Country(10)
	QLocale__Armenia                                QLocale__Country = QLocale__Country(11)
	QLocale__Aruba                                  QLocale__Country = QLocale__Country(12)
	QLocale__Australia                              QLocale__Country = QLocale__Country(13)
	QLocale__Austria                                QLocale__Country = QLocale__Country(14)
	QLocale__Azerbaijan                             QLocale__Country = QLocale__Country(15)
	QLocale__Bahamas                                QLocale__Country = QLocale__Country(16)
	QLocale__Bahrain                                QLocale__Country = QLocale__Country(17)
	QLocale__Bangladesh                             QLocale__Country = QLocale__Country(18)
	QLocale__Barbados                               QLocale__Country = QLocale__Country(19)
	QLocale__Belarus                                QLocale__Country = QLocale__Country(20)
	QLocale__Belgium                                QLocale__Country = QLocale__Country(21)
	QLocale__Belize                                 QLocale__Country = QLocale__Country(22)
	QLocale__Benin                                  QLocale__Country = QLocale__Country(23)
	QLocale__Bermuda                                QLocale__Country = QLocale__Country(24)
	QLocale__Bhutan                                 QLocale__Country = QLocale__Country(25)
	QLocale__Bolivia                                QLocale__Country = QLocale__Country(26)
	QLocale__BosniaAndHerzegowina                   QLocale__Country = QLocale__Country(27)
	QLocale__Botswana                               QLocale__Country = QLocale__Country(28)
	QLocale__BouvetIsland                           QLocale__Country = QLocale__Country(29)
	QLocale__Brazil                                 QLocale__Country = QLocale__Country(30)
	QLocale__BritishIndianOceanTerritory            QLocale__Country = QLocale__Country(31)
	QLocale__Brunei                                 QLocale__Country = QLocale__Country(32)
	QLocale__Bulgaria                               QLocale__Country = QLocale__Country(33)
	QLocale__BurkinaFaso                            QLocale__Country = QLocale__Country(34)
	QLocale__Burundi                                QLocale__Country = QLocale__Country(35)
	QLocale__Cambodia                               QLocale__Country = QLocale__Country(36)
	QLocale__Cameroon                               QLocale__Country = QLocale__Country(37)
	QLocale__Canada                                 QLocale__Country = QLocale__Country(38)
	QLocale__CapeVerde                              QLocale__Country = QLocale__Country(39)
	QLocale__CaymanIslands                          QLocale__Country = QLocale__Country(40)
	QLocale__CentralAfricanRepublic                 QLocale__Country = QLocale__Country(41)
	QLocale__Chad                                   QLocale__Country = QLocale__Country(42)
	QLocale__Chile                                  QLocale__Country = QLocale__Country(43)
	QLocale__China                                  QLocale__Country = QLocale__Country(44)
	QLocale__ChristmasIsland                        QLocale__Country = QLocale__Country(45)
	QLocale__CocosIslands                           QLocale__Country = QLocale__Country(46)
	QLocale__Colombia                               QLocale__Country = QLocale__Country(47)
	QLocale__Comoros                                QLocale__Country = QLocale__Country(48)
	QLocale__CongoKinshasa                          QLocale__Country = QLocale__Country(49)
	QLocale__CongoBrazzaville                       QLocale__Country = QLocale__Country(50)
	QLocale__CookIslands                            QLocale__Country = QLocale__Country(51)
	QLocale__CostaRica                              QLocale__Country = QLocale__Country(52)
	QLocale__IvoryCoast                             QLocale__Country = QLocale__Country(53)
	QLocale__Croatia                                QLocale__Country = QLocale__Country(54)
	QLocale__Cuba                                   QLocale__Country = QLocale__Country(55)
	QLocale__Cyprus                                 QLocale__Country = QLocale__Country(56)
	QLocale__CzechRepublic                          QLocale__Country = QLocale__Country(57)
	QLocale__Denmark                                QLocale__Country = QLocale__Country(58)
	QLocale__Djibouti                               QLocale__Country = QLocale__Country(59)
	QLocale__Dominica                               QLocale__Country = QLocale__Country(60)
	QLocale__DominicanRepublic                      QLocale__Country = QLocale__Country(61)
	QLocale__EastTimor                              QLocale__Country = QLocale__Country(62)
	QLocale__Ecuador                                QLocale__Country = QLocale__Country(63)
	QLocale__Egypt                                  QLocale__Country = QLocale__Country(64)
	QLocale__ElSalvador                             QLocale__Country = QLocale__Country(65)
	QLocale__EquatorialGuinea                       QLocale__Country = QLocale__Country(66)
	QLocale__Eritrea                                QLocale__Country = QLocale__Country(67)
	QLocale__Estonia                                QLocale__Country = QLocale__Country(68)
	QLocale__Ethiopia                               QLocale__Country = QLocale__Country(69)
	QLocale__FalklandIslands                        QLocale__Country = QLocale__Country(70)
	QLocale__FaroeIslands                           QLocale__Country = QLocale__Country(71)
	QLocale__Fiji                                   QLocale__Country = QLocale__Country(72)
	QLocale__Finland                                QLocale__Country = QLocale__Country(73)
	QLocale__France                                 QLocale__Country = QLocale__Country(74)
	QLocale__Guernsey                               QLocale__Country = QLocale__Country(75)
	QLocale__FrenchGuiana                           QLocale__Country = QLocale__Country(76)
	QLocale__FrenchPolynesia                        QLocale__Country = QLocale__Country(77)
	QLocale__FrenchSouthernTerritories              QLocale__Country = QLocale__Country(78)
	QLocale__Gabon                                  QLocale__Country = QLocale__Country(79)
	QLocale__Gambia                                 QLocale__Country = QLocale__Country(80)
	QLocale__Georgia                                QLocale__Country = QLocale__Country(81)
	QLocale__Germany                                QLocale__Country = QLocale__Country(82)
	QLocale__Ghana                                  QLocale__Country = QLocale__Country(83)
	QLocale__Gibraltar                              QLocale__Country = QLocale__Country(84)
	QLocale__Greece                                 QLocale__Country = QLocale__Country(85)
	QLocale__Greenland                              QLocale__Country = QLocale__Country(86)
	QLocale__Grenada                                QLocale__Country = QLocale__Country(87)
	QLocale__Guadeloupe                             QLocale__Country = QLocale__Country(88)
	QLocale__Guam                                   QLocale__Country = QLocale__Country(89)
	QLocale__Guatemala                              QLocale__Country = QLocale__Country(90)
	QLocale__Guinea                                 QLocale__Country = QLocale__Country(91)
	QLocale__GuineaBissau                           QLocale__Country = QLocale__Country(92)
	QLocale__Guyana                                 QLocale__Country = QLocale__Country(93)
	QLocale__Haiti                                  QLocale__Country = QLocale__Country(94)
	QLocale__HeardAndMcDonaldIslands                QLocale__Country = QLocale__Country(95)
	QLocale__Honduras                               QLocale__Country = QLocale__Country(96)
	QLocale__HongKong                               QLocale__Country = QLocale__Country(97)
	QLocale__Hungary                                QLocale__Country = QLocale__Country(98)
	QLocale__Iceland                                QLocale__Country = QLocale__Country(99)
	QLocale__India                                  QLocale__Country = QLocale__Country(100)
	QLocale__Indonesia                              QLocale__Country = QLocale__Country(101)
	QLocale__Iran                                   QLocale__Country = QLocale__Country(102)
	QLocale__Iraq                                   QLocale__Country = QLocale__Country(103)
	QLocale__Ireland                                QLocale__Country = QLocale__Country(104)
	QLocale__Israel                                 QLocale__Country = QLocale__Country(105)
	QLocale__Italy                                  QLocale__Country = QLocale__Country(106)
	QLocale__Jamaica                                QLocale__Country = QLocale__Country(107)
	QLocale__Japan                                  QLocale__Country = QLocale__Country(108)
	QLocale__Jordan                                 QLocale__Country = QLocale__Country(109)
	QLocale__Kazakhstan                             QLocale__Country = QLocale__Country(110)
	QLocale__Kenya                                  QLocale__Country = QLocale__Country(111)
	QLocale__Kiribati                               QLocale__Country = QLocale__Country(112)
	QLocale__NorthKorea                             QLocale__Country = QLocale__Country(113)
	QLocale__SouthKorea                             QLocale__Country = QLocale__Country(114)
	QLocale__Kuwait                                 QLocale__Country = QLocale__Country(115)
	QLocale__Kyrgyzstan                             QLocale__Country = QLocale__Country(116)
	QLocale__Laos                                   QLocale__Country = QLocale__Country(117)
	QLocale__Latvia                                 QLocale__Country = QLocale__Country(118)
	QLocale__Lebanon                                QLocale__Country = QLocale__Country(119)
	QLocale__Lesotho                                QLocale__Country = QLocale__Country(120)
	QLocale__Liberia                                QLocale__Country = QLocale__Country(121)
	QLocale__Libya                                  QLocale__Country = QLocale__Country(122)
	QLocale__Liechtenstein                          QLocale__Country = QLocale__Country(123)
	QLocale__Lithuania                              QLocale__Country = QLocale__Country(124)
	QLocale__Luxembourg                             QLocale__Country = QLocale__Country(125)
	QLocale__Macau                                  QLocale__Country = QLocale__Country(126)
	QLocale__Macedonia                              QLocale__Country = QLocale__Country(127)
	QLocale__Madagascar                             QLocale__Country = QLocale__Country(128)
	QLocale__Malawi                                 QLocale__Country = QLocale__Country(129)
	QLocale__Malaysia                               QLocale__Country = QLocale__Country(130)
	QLocale__Maldives                               QLocale__Country = QLocale__Country(131)
	QLocale__Mali                                   QLocale__Country = QLocale__Country(132)
	QLocale__Malta                                  QLocale__Country = QLocale__Country(133)
	QLocale__MarshallIslands                        QLocale__Country = QLocale__Country(134)
	QLocale__Martinique                             QLocale__Country = QLocale__Country(135)
	QLocale__Mauritania                             QLocale__Country = QLocale__Country(136)
	QLocale__Mauritius                              QLocale__Country = QLocale__Country(137)
	QLocale__Mayotte                                QLocale__Country = QLocale__Country(138)
	QLocale__Mexico                                 QLocale__Country = QLocale__Country(139)
	QLocale__Micronesia                             QLocale__Country = QLocale__Country(140)
	QLocale__Moldova                                QLocale__Country = QLocale__Country(141)
	QLocale__Monaco                                 QLocale__Country = QLocale__Country(142)
	QLocale__Mongolia                               QLocale__Country = QLocale__Country(143)
	QLocale__Montserrat                             QLocale__Country = QLocale__Country(144)
	QLocale__Morocco                                QLocale__Country = QLocale__Country(145)
	QLocale__Mozambique                             QLocale__Country = QLocale__Country(146)
	QLocale__Myanmar                                QLocale__Country = QLocale__Country(147)
	QLocale__Namibia                                QLocale__Country = QLocale__Country(148)
	QLocale__NauruCountry                           QLocale__Country = QLocale__Country(149)
	QLocale__Nepal                                  QLocale__Country = QLocale__Country(150)
	QLocale__Netherlands                            QLocale__Country = QLocale__Country(151)
	QLocale__CuraSao                                QLocale__Country = QLocale__Country(152)
	QLocale__NewCaledonia                           QLocale__Country = QLocale__Country(153)
	QLocale__NewZealand                             QLocale__Country = QLocale__Country(154)
	QLocale__Nicaragua                              QLocale__Country = QLocale__Country(155)
	QLocale__Niger                                  QLocale__Country = QLocale__Country(156)
	QLocale__Nigeria                                QLocale__Country = QLocale__Country(157)
	QLocale__Niue                                   QLocale__Country = QLocale__Country(158)
	QLocale__NorfolkIsland                          QLocale__Country = QLocale__Country(159)
	QLocale__NorthernMarianaIslands                 QLocale__Country = QLocale__Country(160)
	QLocale__Norway                                 QLocale__Country = QLocale__Country(161)
	QLocale__Oman                                   QLocale__Country = QLocale__Country(162)
	QLocale__Pakistan                               QLocale__Country = QLocale__Country(163)
	QLocale__Palau                                  QLocale__Country = QLocale__Country(164)
	QLocale__PalestinianTerritories                 QLocale__Country = QLocale__Country(165)
	QLocale__Panama                                 QLocale__Country = QLocale__Country(166)
	QLocale__PapuaNewGuinea                         QLocale__Country = QLocale__Country(167)
	QLocale__Paraguay                               QLocale__Country = QLocale__Country(168)
	QLocale__Peru                                   QLocale__Country = QLocale__Country(169)
	QLocale__Philippines                            QLocale__Country = QLocale__Country(170)
	QLocale__Pitcairn                               QLocale__Country = QLocale__Country(171)
	QLocale__Poland                                 QLocale__Country = QLocale__Country(172)
	QLocale__Portugal                               QLocale__Country = QLocale__Country(173)
	QLocale__PuertoRico                             QLocale__Country = QLocale__Country(174)
	QLocale__Qatar                                  QLocale__Country = QLocale__Country(175)
	QLocale__Reunion                                QLocale__Country = QLocale__Country(176)
	QLocale__Romania                                QLocale__Country = QLocale__Country(177)
	QLocale__Russia                                 QLocale__Country = QLocale__Country(178)
	QLocale__Rwanda                                 QLocale__Country = QLocale__Country(179)
	QLocale__SaintKittsAndNevis                     QLocale__Country = QLocale__Country(180)
	QLocale__SaintLucia                             QLocale__Country = QLocale__Country(181)
	QLocale__SaintVincentAndTheGrenadines           QLocale__Country = QLocale__Country(182)
	QLocale__Samoa                                  QLocale__Country = QLocale__Country(183)
	QLocale__SanMarino                              QLocale__Country = QLocale__Country(184)
	QLocale__SaoTomeAndPrincipe                     QLocale__Country = QLocale__Country(185)
	QLocale__SaudiArabia                            QLocale__Country = QLocale__Country(186)
	QLocale__Senegal                                QLocale__Country = QLocale__Country(187)
	QLocale__Seychelles                             QLocale__Country = QLocale__Country(188)
	QLocale__SierraLeone                            QLocale__Country = QLocale__Country(189)
	QLocale__Singapore                              QLocale__Country = QLocale__Country(190)
	QLocale__Slovakia                               QLocale__Country = QLocale__Country(191)
	QLocale__Slovenia                               QLocale__Country = QLocale__Country(192)
	QLocale__SolomonIslands                         QLocale__Country = QLocale__Country(193)
	QLocale__Somalia                                QLocale__Country = QLocale__Country(194)
	QLocale__SouthAfrica                            QLocale__Country = QLocale__Country(195)
	QLocale__SouthGeorgiaAndTheSouthSandwichIslands QLocale__Country = QLocale__Country(196)
	QLocale__Spain                                  QLocale__Country = QLocale__Country(197)
	QLocale__SriLanka                               QLocale__Country = QLocale__Country(198)
	QLocale__SaintHelena                            QLocale__Country = QLocale__Country(199)
	QLocale__SaintPierreAndMiquelon                 QLocale__Country = QLocale__Country(200)
	QLocale__Sudan                                  QLocale__Country = QLocale__Country(201)
	QLocale__Suriname                               QLocale__Country = QLocale__Country(202)
	QLocale__SvalbardAndJanMayenIslands             QLocale__Country = QLocale__Country(203)
	QLocale__Swaziland                              QLocale__Country = QLocale__Country(204)
	QLocale__Sweden                                 QLocale__Country = QLocale__Country(205)
	QLocale__Switzerland                            QLocale__Country = QLocale__Country(206)
	QLocale__Syria                                  QLocale__Country = QLocale__Country(207)
	QLocale__Taiwan                                 QLocale__Country = QLocale__Country(208)
	QLocale__Tajikistan                             QLocale__Country = QLocale__Country(209)
	QLocale__Tanzania                               QLocale__Country = QLocale__Country(210)
	QLocale__Thailand                               QLocale__Country = QLocale__Country(211)
	QLocale__Togo                                   QLocale__Country = QLocale__Country(212)
	QLocale__TokelauCountry                         QLocale__Country = QLocale__Country(213)
	QLocale__Tonga                                  QLocale__Country = QLocale__Country(214)
	QLocale__TrinidadAndTobago                      QLocale__Country = QLocale__Country(215)
	QLocale__Tunisia                                QLocale__Country = QLocale__Country(216)
	QLocale__Turkey                                 QLocale__Country = QLocale__Country(217)
	QLocale__Turkmenistan                           QLocale__Country = QLocale__Country(218)
	QLocale__TurksAndCaicosIslands                  QLocale__Country = QLocale__Country(219)
	QLocale__TuvaluCountry                          QLocale__Country = QLocale__Country(220)
	QLocale__Uganda                                 QLocale__Country = QLocale__Country(221)
	QLocale__Ukraine                                QLocale__Country = QLocale__Country(222)
	QLocale__UnitedArabEmirates                     QLocale__Country = QLocale__Country(223)
	QLocale__UnitedKingdom                          QLocale__Country = QLocale__Country(224)
	QLocale__UnitedStates                           QLocale__Country = QLocale__Country(225)
	QLocale__UnitedStatesMinorOutlyingIslands       QLocale__Country = QLocale__Country(226)
	QLocale__Uruguay                                QLocale__Country = QLocale__Country(227)
	QLocale__Uzbekistan                             QLocale__Country = QLocale__Country(228)
	QLocale__Vanuatu                                QLocale__Country = QLocale__Country(229)
	QLocale__VaticanCityState                       QLocale__Country = QLocale__Country(230)
	QLocale__Venezuela                              QLocale__Country = QLocale__Country(231)
	QLocale__Vietnam                                QLocale__Country = QLocale__Country(232)
	QLocale__BritishVirginIslands                   QLocale__Country = QLocale__Country(233)
	QLocale__UnitedStatesVirginIslands              QLocale__Country = QLocale__Country(234)
	QLocale__WallisAndFutunaIslands                 QLocale__Country = QLocale__Country(235)
	QLocale__WesternSahara                          QLocale__Country = QLocale__Country(236)
	QLocale__Yemen                                  QLocale__Country = QLocale__Country(237)
	QLocale__CanaryIslands                          QLocale__Country = QLocale__Country(238)
	QLocale__Zambia                                 QLocale__Country = QLocale__Country(239)
	QLocale__Zimbabwe                               QLocale__Country = QLocale__Country(240)
	QLocale__ClippertonIsland                       QLocale__Country = QLocale__Country(241)
	QLocale__Montenegro                             QLocale__Country = QLocale__Country(242)
	QLocale__Serbia                                 QLocale__Country = QLocale__Country(243)
	QLocale__SaintBarthelemy                        QLocale__Country = QLocale__Country(244)
	QLocale__SaintMartin                            QLocale__Country = QLocale__Country(245)
	QLocale__LatinAmerica                           QLocale__Country = QLocale__Country(246)
	QLocale__AscensionIsland                        QLocale__Country = QLocale__Country(247)
	QLocale__AlandIslands                           QLocale__Country = QLocale__Country(248)
	QLocale__DiegoGarcia                            QLocale__Country = QLocale__Country(249)
	QLocale__CeutaAndMelilla                        QLocale__Country = QLocale__Country(250)
	QLocale__IsleOfMan                              QLocale__Country = QLocale__Country(251)
	QLocale__Jersey                                 QLocale__Country = QLocale__Country(252)
	QLocale__TristanDaCunha                         QLocale__Country = QLocale__Country(253)
	QLocale__SouthSudan                             QLocale__Country = QLocale__Country(254)
	QLocale__Bonaire                                QLocale__Country = QLocale__Country(255)
	QLocale__SintMaarten                            QLocale__Country = QLocale__Country(256)
	QLocale__Kosovo                                 QLocale__Country = QLocale__Country(257)
	QLocale__EuropeanUnion                          QLocale__Country = QLocale__Country(258)
	QLocale__OutlyingOceania                        QLocale__Country = QLocale__Country(259)
	QLocale__World                                  QLocale__Country = QLocale__Country(260)
	QLocale__Europe                                 QLocale__Country = QLocale__Country(261)
	QLocale__DemocraticRepublicOfCongo              QLocale__Country = QLocale__Country(QLocale__CongoKinshasa)
	QLocale__DemocraticRepublicOfKorea              QLocale__Country = QLocale__Country(QLocale__NorthKorea)
	QLocale__LatinAmericaAndTheCaribbean            QLocale__Country = QLocale__Country(QLocale__LatinAmerica)
	QLocale__PeoplesRepublicOfCongo                 QLocale__Country = QLocale__Country(QLocale__CongoBrazzaville)
	QLocale__RepublicOfKorea                        QLocale__Country = QLocale__Country(QLocale__SouthKorea)
	QLocale__RussianFederation                      QLocale__Country = QLocale__Country(QLocale__Russia)
	QLocale__SyrianArabRepublic                     QLocale__Country = QLocale__Country(QLocale__Syria)
	QLocale__Tokelau                                QLocale__Country = QLocale__Country(QLocale__TokelauCountry)
	QLocale__Tuvalu                                 QLocale__Country = QLocale__Country(QLocale__TuvaluCountry)
	QLocale__LastCountry                            QLocale__Country = QLocale__Country(QLocale__Europe)
)

//go:generate stringer -type=QLocale__MeasurementSystem
//QLocale::MeasurementSystem
type QLocale__MeasurementSystem int64

const (
	QLocale__MetricSystem     QLocale__MeasurementSystem = QLocale__MeasurementSystem(0)
	QLocale__ImperialUSSystem QLocale__MeasurementSystem = QLocale__MeasurementSystem(1)
	QLocale__ImperialUKSystem QLocale__MeasurementSystem = QLocale__MeasurementSystem(2)
	QLocale__ImperialSystem   QLocale__MeasurementSystem = QLocale__MeasurementSystem(QLocale__ImperialUSSystem)
)

//go:generate stringer -type=QLocale__FormatType
//QLocale::FormatType
type QLocale__FormatType int64

const (
	QLocale__LongFormat   QLocale__FormatType = QLocale__FormatType(0)
	QLocale__ShortFormat  QLocale__FormatType = QLocale__FormatType(1)
	QLocale__NarrowFormat QLocale__FormatType = QLocale__FormatType(2)
)

//go:generate stringer -type=QLocale__NumberOption
//QLocale::NumberOption
type QLocale__NumberOption int64

const (
	QLocale__DefaultNumberOptions          QLocale__NumberOption = QLocale__NumberOption(0x0)
	QLocale__OmitGroupSeparator            QLocale__NumberOption = QLocale__NumberOption(0x01)
	QLocale__RejectGroupSeparator          QLocale__NumberOption = QLocale__NumberOption(0x02)
	QLocale__OmitLeadingZeroInExponent     QLocale__NumberOption = QLocale__NumberOption(0x04)
	QLocale__RejectLeadingZeroInExponent   QLocale__NumberOption = QLocale__NumberOption(0x08)
	QLocale__IncludeTrailingZeroesAfterDot QLocale__NumberOption = QLocale__NumberOption(0x10)
	QLocale__RejectTrailingZeroesAfterDot  QLocale__NumberOption = QLocale__NumberOption(0x20)
)

//go:generate stringer -type=QLocale__FloatingPointPrecisionOption
//QLocale::FloatingPointPrecisionOption
type QLocale__FloatingPointPrecisionOption int64

const (
	QLocale__FloatingPointShortest QLocale__FloatingPointPrecisionOption = QLocale__FloatingPointPrecisionOption(-128)
)

//go:generate stringer -type=QLocale__CurrencySymbolFormat
//QLocale::CurrencySymbolFormat
type QLocale__CurrencySymbolFormat int64

const (
	QLocale__CurrencyIsoCode     QLocale__CurrencySymbolFormat = QLocale__CurrencySymbolFormat(0)
	QLocale__CurrencySymbol      QLocale__CurrencySymbolFormat = QLocale__CurrencySymbolFormat(1)
	QLocale__CurrencyDisplayName QLocale__CurrencySymbolFormat = QLocale__CurrencySymbolFormat(2)
)

//go:generate stringer -type=QLocale__DataSizeFormat
//QLocale::DataSizeFormat
type QLocale__DataSizeFormat int64

const (
	QLocale__DataSizeBase1000          QLocale__DataSizeFormat = QLocale__DataSizeFormat(1)
	QLocale__DataSizeSIQuantifiers     QLocale__DataSizeFormat = QLocale__DataSizeFormat(2)
	QLocale__DataSizeIecFormat         QLocale__DataSizeFormat = QLocale__DataSizeFormat(0)
	QLocale__DataSizeTraditionalFormat QLocale__DataSizeFormat = QLocale__DataSizeFormat(QLocale__DataSizeSIQuantifiers)
	QLocale__DataSizeSIFormat          QLocale__DataSizeFormat = QLocale__DataSizeFormat(QLocale__DataSizeBase1000 | QLocale__DataSizeSIQuantifiers)
)

//go:generate stringer -type=QLocale__QuotationStyle
//QLocale::QuotationStyle
type QLocale__QuotationStyle int64

var (
	QLocale__StandardQuotation  QLocale__QuotationStyle = QLocale__QuotationStyle(0)
	QLocale__AlternateQuotation QLocale__QuotationStyle = QLocale__QuotationStyle(1)
)

func NewQLocale() *QLocale {
	tmpValue := NewQLocaleFromPointer(C.QLocale_NewQLocale())
	runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
	return tmpValue
}

func NewQLocale2(name string) *QLocale {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	tmpValue := NewQLocaleFromPointer(C.QLocale_NewQLocale2(C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}))
	runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
	return tmpValue
}

func NewQLocale3(language QLocale__Language, country QLocale__Country) *QLocale {
	tmpValue := NewQLocaleFromPointer(C.QLocale_NewQLocale3(C.longlong(language), C.longlong(country)))
	runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
	return tmpValue
}

func NewQLocale4(language QLocale__Language, scri QLocale__Script, country QLocale__Country) *QLocale {
	tmpValue := NewQLocaleFromPointer(C.QLocale_NewQLocale4(C.longlong(language), C.longlong(scri), C.longlong(country)))
	runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
	return tmpValue
}

func NewQLocale5(other QLocale_ITF) *QLocale {
	tmpValue := NewQLocaleFromPointer(C.QLocale_NewQLocale5(PointerFromQLocale(other)))
	runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
	return tmpValue
}

func (ptr *QLocale) AmText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_AmText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) Bcp47Name() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_Bcp47Name(ptr.Pointer()))
	}
	return ""
}

func QLocale_C() *QLocale {
	tmpValue := NewQLocaleFromPointer(C.QLocale_QLocale_C())
	runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
	return tmpValue
}

func (ptr *QLocale) C() *QLocale {
	tmpValue := NewQLocaleFromPointer(C.QLocale_QLocale_C())
	runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
	return tmpValue
}

func (ptr *QLocale) Country() QLocale__Country {
	if ptr.Pointer() != nil {
		return QLocale__Country(C.QLocale_Country(ptr.Pointer()))
	}
	return 0
}

func QLocale_CountryToString(country QLocale__Country) string {
	return cGoUnpackString(C.QLocale_QLocale_CountryToString(C.longlong(country)))
}

func (ptr *QLocale) CountryToString(country QLocale__Country) string {
	return cGoUnpackString(C.QLocale_QLocale_CountryToString(C.longlong(country)))
}

func (ptr *QLocale) CreateSeparatedList(list []string) string {
	if ptr.Pointer() != nil {
		listC := C.CString(strings.Join(list, "¡¦!"))
		defer C.free(unsafe.Pointer(listC))
		return cGoUnpackString(C.QLocale_CreateSeparatedList(ptr.Pointer(), C.struct_QtCore_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "¡¦!")))}))
	}
	return ""
}

func (ptr *QLocale) CurrencySymbol(format QLocale__CurrencySymbolFormat) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_CurrencySymbol(ptr.Pointer(), C.longlong(format)))
	}
	return ""
}

func (ptr *QLocale) DateFormat(format QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_DateFormat(ptr.Pointer(), C.longlong(format)))
	}
	return ""
}

func (ptr *QLocale) DateTimeFormat(format QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_DateTimeFormat(ptr.Pointer(), C.longlong(format)))
	}
	return ""
}

func (ptr *QLocale) DayName(day int, ty QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_DayName(ptr.Pointer(), C.int(int32(day)), C.longlong(ty)))
	}
	return ""
}

func (ptr *QLocale) DecimalPoint() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QLocale_DecimalPoint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) Exponential() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QLocale_Exponential(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) FirstDayOfWeek() Qt__DayOfWeek {
	if ptr.Pointer() != nil {
		return Qt__DayOfWeek(C.QLocale_FirstDayOfWeek(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLocale) FormattedDataSize2(bytes int64, precision int, format QLocale__DataSizeFormat) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_FormattedDataSize2(ptr.Pointer(), C.longlong(bytes), C.int(int32(precision)), C.longlong(format)))
	}
	return ""
}

func (ptr *QLocale) GroupSeparator() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QLocale_GroupSeparator(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) Language() QLocale__Language {
	if ptr.Pointer() != nil {
		return QLocale__Language(C.QLocale_Language(ptr.Pointer()))
	}
	return 0
}

func QLocale_LanguageToString(language QLocale__Language) string {
	return cGoUnpackString(C.QLocale_QLocale_LanguageToString(C.longlong(language)))
}

func (ptr *QLocale) LanguageToString(language QLocale__Language) string {
	return cGoUnpackString(C.QLocale_QLocale_LanguageToString(C.longlong(language)))
}

func QLocale_MatchingLocales(language QLocale__Language, scri QLocale__Script, country QLocale__Country) []*QLocale {
	return func(l C.struct_QtCore_PackedList) []*QLocale {
		out := make([]*QLocale, int(l.len))
		tmpList := NewQLocaleFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__matchingLocales_atList(i)
		}
		return out
	}(C.QLocale_QLocale_MatchingLocales(C.longlong(language), C.longlong(scri), C.longlong(country)))
}

func (ptr *QLocale) MatchingLocales(language QLocale__Language, scri QLocale__Script, country QLocale__Country) []*QLocale {
	return func(l C.struct_QtCore_PackedList) []*QLocale {
		out := make([]*QLocale, int(l.len))
		tmpList := NewQLocaleFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__matchingLocales_atList(i)
		}
		return out
	}(C.QLocale_QLocale_MatchingLocales(C.longlong(language), C.longlong(scri), C.longlong(country)))
}

func (ptr *QLocale) MeasurementSystem() QLocale__MeasurementSystem {
	if ptr.Pointer() != nil {
		return QLocale__MeasurementSystem(C.QLocale_MeasurementSystem(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLocale) MonthName(month int, ty QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_MonthName(ptr.Pointer(), C.int(int32(month)), C.longlong(ty)))
	}
	return ""
}

func (ptr *QLocale) Name() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) NativeCountryName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_NativeCountryName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) NativeLanguageName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_NativeLanguageName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) NegativeSign() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QLocale_NegativeSign(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) NumberOptions() QLocale__NumberOption {
	if ptr.Pointer() != nil {
		return QLocale__NumberOption(C.QLocale_NumberOptions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLocale) Percent() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QLocale_Percent(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) PmText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_PmText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) PositiveSign() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QLocale_PositiveSign(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) QuoteString(str string, style QLocale__QuotationStyle) string {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return cGoUnpackString(C.QLocale_QuoteString(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.longlong(style)))
	}
	return ""
}

func (ptr *QLocale) QuoteString2(str QStringRef_ITF, style QLocale__QuotationStyle) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_QuoteString2(ptr.Pointer(), PointerFromQStringRef(str), C.longlong(style)))
	}
	return ""
}

func (ptr *QLocale) Script() QLocale__Script {
	if ptr.Pointer() != nil {
		return QLocale__Script(C.QLocale_Script(ptr.Pointer()))
	}
	return 0
}

func QLocale_ScriptToString(scri QLocale__Script) string {
	return cGoUnpackString(C.QLocale_QLocale_ScriptToString(C.longlong(scri)))
}

func (ptr *QLocale) ScriptToString(scri QLocale__Script) string {
	return cGoUnpackString(C.QLocale_QLocale_ScriptToString(C.longlong(scri)))
}

func QLocale_SetDefault(locale QLocale_ITF) {
	C.QLocale_QLocale_SetDefault(PointerFromQLocale(locale))
}

func (ptr *QLocale) SetDefault(locale QLocale_ITF) {
	C.QLocale_QLocale_SetDefault(PointerFromQLocale(locale))
}

func (ptr *QLocale) SetNumberOptions(options QLocale__NumberOption) {
	if ptr.Pointer() != nil {
		C.QLocale_SetNumberOptions(ptr.Pointer(), C.longlong(options))
	}
}

func (ptr *QLocale) StandaloneDayName(day int, ty QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_StandaloneDayName(ptr.Pointer(), C.int(int32(day)), C.longlong(ty)))
	}
	return ""
}

func (ptr *QLocale) StandaloneMonthName(month int, ty QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_StandaloneMonthName(ptr.Pointer(), C.int(int32(month)), C.longlong(ty)))
	}
	return ""
}

func (ptr *QLocale) Swap(other QLocale_ITF) {
	if ptr.Pointer() != nil {
		C.QLocale_Swap(ptr.Pointer(), PointerFromQLocale(other))
	}
}

func QLocale_System() *QLocale {
	tmpValue := NewQLocaleFromPointer(C.QLocale_QLocale_System())
	runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
	return tmpValue
}

func (ptr *QLocale) System() *QLocale {
	tmpValue := NewQLocaleFromPointer(C.QLocale_QLocale_System())
	runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
	return tmpValue
}

func (ptr *QLocale) TextDirection() Qt__LayoutDirection {
	if ptr.Pointer() != nil {
		return Qt__LayoutDirection(C.QLocale_TextDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLocale) TimeFormat(format QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_TimeFormat(ptr.Pointer(), C.longlong(format)))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString(value int64, symbol string) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString(ptr.Pointer(), C.longlong(value), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString2(value uint64, symbol string) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString2(ptr.Pointer(), C.ulonglong(value), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString3(value int16, symbol string) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString3(ptr.Pointer(), C.short(value), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString4(value uint16, symbol string) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString4(ptr.Pointer(), C.ushort(value), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString5(value int, symbol string) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString5(ptr.Pointer(), C.int(int32(value)), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString6(value uint, symbol string) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString6(ptr.Pointer(), C.uint(uint32(value)), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString7(value float64, symbol string) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString7(ptr.Pointer(), C.double(value), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString8(value float64, symbol string, precision int) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString8(ptr.Pointer(), C.double(value), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}, C.int(int32(precision))))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString9(value float32, symbol string) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString9(ptr.Pointer(), C.float(value), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString10(i float32, symbol string, precision int) string {
	if ptr.Pointer() != nil {
		var symbolC *C.char
		if symbol != "" {
			symbolC = C.CString(symbol)
			defer C.free(unsafe.Pointer(symbolC))
		}
		return cGoUnpackString(C.QLocale_ToCurrencyString10(ptr.Pointer(), C.float(i), C.struct_QtCore_PackedString{data: symbolC, len: C.longlong(len(symbol))}, C.int(int32(precision))))
	}
	return ""
}

func (ptr *QLocale) ToDate(stri string, format QLocale__FormatType) *QDate {
	if ptr.Pointer() != nil {
		var striC *C.char
		if stri != "" {
			striC = C.CString(stri)
			defer C.free(unsafe.Pointer(striC))
		}
		tmpValue := NewQDateFromPointer(C.QLocale_ToDate(ptr.Pointer(), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(format)))
		runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) ToDate2(stri string, format string) *QDate {
	if ptr.Pointer() != nil {
		var striC *C.char
		if stri != "" {
			striC = C.CString(stri)
			defer C.free(unsafe.Pointer(striC))
		}
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		tmpValue := NewQDateFromPointer(C.QLocale_ToDate2(ptr.Pointer(), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
		runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) ToDateTime(stri string, format QLocale__FormatType) *QDateTime {
	if ptr.Pointer() != nil {
		var striC *C.char
		if stri != "" {
			striC = C.CString(stri)
			defer C.free(unsafe.Pointer(striC))
		}
		tmpValue := NewQDateTimeFromPointer(C.QLocale_ToDateTime(ptr.Pointer(), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(format)))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) ToDateTime2(stri string, format string) *QDateTime {
	if ptr.Pointer() != nil {
		var striC *C.char
		if stri != "" {
			striC = C.CString(stri)
			defer C.free(unsafe.Pointer(striC))
		}
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		tmpValue := NewQDateTimeFromPointer(C.QLocale_ToDateTime2(ptr.Pointer(), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) ToDouble(s string, ok *bool) float64 {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float64(C.QLocale_ToDouble(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC))
	}
	return 0
}

func (ptr *QLocale) ToDouble2(s QStringRef_ITF, ok *bool) float64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float64(C.QLocale_ToDouble2(ptr.Pointer(), PointerFromQStringRef(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToDouble3(s QStringView_ITF, ok *bool) float64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float64(C.QLocale_ToDouble3(ptr.Pointer(), PointerFromQStringView(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToFloat(s string, ok *bool) float32 {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float32(C.QLocale_ToFloat(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC))
	}
	return 0
}

func (ptr *QLocale) ToFloat2(s QStringRef_ITF, ok *bool) float32 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float32(C.QLocale_ToFloat2(ptr.Pointer(), PointerFromQStringRef(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToFloat3(s QStringView_ITF, ok *bool) float32 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float32(C.QLocale_ToFloat3(ptr.Pointer(), PointerFromQStringView(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToInt(s string, ok *bool) int {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QLocale_ToInt(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC)))
	}
	return 0
}

func (ptr *QLocale) ToInt2(s QStringRef_ITF, ok *bool) int {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QLocale_ToInt2(ptr.Pointer(), PointerFromQStringRef(s), &okC)))
	}
	return 0
}

func (ptr *QLocale) ToInt3(s QStringView_ITF, ok *bool) int {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QLocale_ToInt3(ptr.Pointer(), PointerFromQStringView(s), &okC)))
	}
	return 0
}

func (ptr *QLocale) ToLong(s string, ok *bool) int {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QLocale_ToLong(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC)))
	}
	return 0
}

func (ptr *QLocale) ToLong2(s QStringRef_ITF, ok *bool) int {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QLocale_ToLong2(ptr.Pointer(), PointerFromQStringRef(s), &okC)))
	}
	return 0
}

func (ptr *QLocale) ToLong3(s QStringView_ITF, ok *bool) int {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QLocale_ToLong3(ptr.Pointer(), PointerFromQStringView(s), &okC)))
	}
	return 0
}

func (ptr *QLocale) ToLongLong(s string, ok *bool) int64 {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int64(C.QLocale_ToLongLong(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC))
	}
	return 0
}

func (ptr *QLocale) ToLongLong2(s QStringRef_ITF, ok *bool) int64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int64(C.QLocale_ToLongLong2(ptr.Pointer(), PointerFromQStringRef(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToLongLong3(s QStringView_ITF, ok *bool) int64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int64(C.QLocale_ToLongLong3(ptr.Pointer(), PointerFromQStringView(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToLower(str string) string {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return cGoUnpackString(C.QLocale_ToLower(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
	}
	return ""
}

func (ptr *QLocale) ToShort(s string, ok *bool) int16 {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int16(C.QLocale_ToShort(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC))
	}
	return 0
}

func (ptr *QLocale) ToShort2(s QStringRef_ITF, ok *bool) int16 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int16(C.QLocale_ToShort2(ptr.Pointer(), PointerFromQStringRef(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToShort3(s QStringView_ITF, ok *bool) int16 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int16(C.QLocale_ToShort3(ptr.Pointer(), PointerFromQStringView(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToString(i int64) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString(ptr.Pointer(), C.longlong(i)))
	}
	return ""
}

func (ptr *QLocale) ToString2(i uint64) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString2(ptr.Pointer(), C.ulonglong(i)))
	}
	return ""
}

func (ptr *QLocale) ToString3(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString3(ptr.Pointer(), C.long(int32(i))))
	}
	return ""
}

func (ptr *QLocale) ToString4(i uint) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString4(ptr.Pointer(), C.ulong(uint32(i))))
	}
	return ""
}

func (ptr *QLocale) ToString5(i int16) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString5(ptr.Pointer(), C.short(i)))
	}
	return ""
}

func (ptr *QLocale) ToString6(i uint16) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString6(ptr.Pointer(), C.ushort(i)))
	}
	return ""
}

func (ptr *QLocale) ToString7(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString7(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QLocale) ToString8(i uint) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString8(ptr.Pointer(), C.uint(uint32(i))))
	}
	return ""
}

func (ptr *QLocale) ToString9(i float64, ff string, prec int) string {
	if ptr.Pointer() != nil {
		var ffC *C.char
		if ff != "" {
			ffC = C.CString(ff)
			defer C.free(unsafe.Pointer(ffC))
		}
		return cGoUnpackString(C.QLocale_ToString9(ptr.Pointer(), C.double(i), ffC, C.int(int32(prec))))
	}
	return ""
}

func (ptr *QLocale) ToString10(i float32, ff string, prec int) string {
	if ptr.Pointer() != nil {
		var ffC *C.char
		if ff != "" {
			ffC = C.CString(ff)
			defer C.free(unsafe.Pointer(ffC))
		}
		return cGoUnpackString(C.QLocale_ToString10(ptr.Pointer(), C.float(i), ffC, C.int(int32(prec))))
	}
	return ""
}

func (ptr *QLocale) ToString11(date QDate_ITF, format string) string {
	if ptr.Pointer() != nil {
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		return cGoUnpackString(C.QLocale_ToString11(ptr.Pointer(), PointerFromQDate(date), C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	}
	return ""
}

func (ptr *QLocale) ToString12(ti QTime_ITF, format string) string {
	if ptr.Pointer() != nil {
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		return cGoUnpackString(C.QLocale_ToString12(ptr.Pointer(), PointerFromQTime(ti), C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	}
	return ""
}

func (ptr *QLocale) ToString13(dateTime QDateTime_ITF, format string) string {
	if ptr.Pointer() != nil {
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		return cGoUnpackString(C.QLocale_ToString13(ptr.Pointer(), PointerFromQDateTime(dateTime), C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	}
	return ""
}

func (ptr *QLocale) ToString14(date QDate_ITF, format QStringView_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString14(ptr.Pointer(), PointerFromQDate(date), PointerFromQStringView(format)))
	}
	return ""
}

func (ptr *QLocale) ToString15(ti QTime_ITF, format QStringView_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString15(ptr.Pointer(), PointerFromQTime(ti), PointerFromQStringView(format)))
	}
	return ""
}

func (ptr *QLocale) ToString16(dateTime QDateTime_ITF, format QStringView_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString16(ptr.Pointer(), PointerFromQDateTime(dateTime), PointerFromQStringView(format)))
	}
	return ""
}

func (ptr *QLocale) ToString17(date QDate_ITF, format QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString17(ptr.Pointer(), PointerFromQDate(date), C.longlong(format)))
	}
	return ""
}

func (ptr *QLocale) ToString18(ti QTime_ITF, format QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString18(ptr.Pointer(), PointerFromQTime(ti), C.longlong(format)))
	}
	return ""
}

func (ptr *QLocale) ToString19(dateTime QDateTime_ITF, format QLocale__FormatType) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLocale_ToString19(ptr.Pointer(), PointerFromQDateTime(dateTime), C.longlong(format)))
	}
	return ""
}

func (ptr *QLocale) ToTime(stri string, format QLocale__FormatType) *QTime {
	if ptr.Pointer() != nil {
		var striC *C.char
		if stri != "" {
			striC = C.CString(stri)
			defer C.free(unsafe.Pointer(striC))
		}
		tmpValue := NewQTimeFromPointer(C.QLocale_ToTime(ptr.Pointer(), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(format)))
		runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) ToTime2(stri string, format string) *QTime {
	if ptr.Pointer() != nil {
		var striC *C.char
		if stri != "" {
			striC = C.CString(stri)
			defer C.free(unsafe.Pointer(striC))
		}
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		tmpValue := NewQTimeFromPointer(C.QLocale_ToTime2(ptr.Pointer(), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
		runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) ToUInt(s string, ok *bool) uint {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QLocale_ToUInt(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC)))
	}
	return 0
}

func (ptr *QLocale) ToUInt2(s QStringRef_ITF, ok *bool) uint {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QLocale_ToUInt2(ptr.Pointer(), PointerFromQStringRef(s), &okC)))
	}
	return 0
}

func (ptr *QLocale) ToUInt3(s QStringView_ITF, ok *bool) uint {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QLocale_ToUInt3(ptr.Pointer(), PointerFromQStringView(s), &okC)))
	}
	return 0
}

func (ptr *QLocale) ToULong(s string, ok *bool) uint {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QLocale_ToULong(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC)))
	}
	return 0
}

func (ptr *QLocale) ToULong2(s QStringRef_ITF, ok *bool) uint {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QLocale_ToULong2(ptr.Pointer(), PointerFromQStringRef(s), &okC)))
	}
	return 0
}

func (ptr *QLocale) ToULong3(s QStringView_ITF, ok *bool) uint {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QLocale_ToULong3(ptr.Pointer(), PointerFromQStringView(s), &okC)))
	}
	return 0
}

func (ptr *QLocale) ToULongLong(s string, ok *bool) uint64 {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint64(C.QLocale_ToULongLong(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC))
	}
	return 0
}

func (ptr *QLocale) ToULongLong2(s QStringRef_ITF, ok *bool) uint64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint64(C.QLocale_ToULongLong2(ptr.Pointer(), PointerFromQStringRef(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToULongLong3(s QStringView_ITF, ok *bool) uint64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint64(C.QLocale_ToULongLong3(ptr.Pointer(), PointerFromQStringView(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToUShort(s string, ok *bool) uint16 {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint16(C.QLocale_ToUShort(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))}, &okC))
	}
	return 0
}

func (ptr *QLocale) ToUShort2(s QStringRef_ITF, ok *bool) uint16 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint16(C.QLocale_ToUShort2(ptr.Pointer(), PointerFromQStringRef(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToUShort3(s QStringView_ITF, ok *bool) uint16 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint16(C.QLocale_ToUShort3(ptr.Pointer(), PointerFromQStringView(s), &okC))
	}
	return 0
}

func (ptr *QLocale) ToUpper(str string) string {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return cGoUnpackString(C.QLocale_ToUpper(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
	}
	return ""
}

func (ptr *QLocale) UiLanguages() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QLocale_UiLanguages(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QLocale) Weekdays() []Qt__DayOfWeek {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []Qt__DayOfWeek {
			out := make([]Qt__DayOfWeek, int(l.len))
			tmpList := NewQLocaleFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__weekdays_atList(i)
			}
			return out
		}(C.QLocale_Weekdays(ptr.Pointer()))
	}
	return make([]Qt__DayOfWeek, 0)
}

func (ptr *QLocale) ZeroDigit() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QLocale_ZeroDigit(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) DestroyQLocale() {
	if ptr.Pointer() != nil {
		C.QLocale_DestroyQLocale(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLocale) __matchingLocales_atList(i int) *QLocale {
	if ptr.Pointer() != nil {
		tmpValue := NewQLocaleFromPointer(C.QLocale___matchingLocales_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
		return tmpValue
	}
	return nil
}

func (ptr *QLocale) __matchingLocales_setList(i QLocale_ITF) {
	if ptr.Pointer() != nil {
		C.QLocale___matchingLocales_setList(ptr.Pointer(), PointerFromQLocale(i))
	}
}

func (ptr *QLocale) __matchingLocales_newList() unsafe.Pointer {
	return C.QLocale___matchingLocales_newList(ptr.Pointer())
}

func (ptr *QLocale) __weekdays_atList(i int) Qt__DayOfWeek {
	if ptr.Pointer() != nil {
		return Qt__DayOfWeek(C.QLocale___weekdays_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return 0
}

func (ptr *QLocale) __weekdays_setList(i Qt__DayOfWeek) {
	if ptr.Pointer() != nil {
		C.QLocale___weekdays_setList(ptr.Pointer(), C.longlong(i))
	}
}

func (ptr *QLocale) __weekdays_newList() unsafe.Pointer {
	return C.QLocale___weekdays_newList(ptr.Pointer())
}

type QLockFile struct {
	ptr unsafe.Pointer
}

type QLockFile_ITF interface {
	QLockFile_PTR() *QLockFile
}

func (ptr *QLockFile) QLockFile_PTR() *QLockFile {
	return ptr
}

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

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

func PointerFromQLockFile(ptr QLockFile_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLockFile_PTR().Pointer()
	}
	return nil
}

func NewQLockFileFromPointer(ptr unsafe.Pointer) (n *QLockFile) {
	n = new(QLockFile)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QLockFile__LockError
//QLockFile::LockError
type QLockFile__LockError int64

const (
	QLockFile__NoError         QLockFile__LockError = QLockFile__LockError(0)
	QLockFile__LockFailedError QLockFile__LockError = QLockFile__LockError(1)
	QLockFile__PermissionError QLockFile__LockError = QLockFile__LockError(2)
	QLockFile__UnknownError    QLockFile__LockError = QLockFile__LockError(3)
)

func NewQLockFile(fileName string) *QLockFile {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	tmpValue := NewQLockFileFromPointer(C.QLockFile_NewQLockFile(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	runtime.SetFinalizer(tmpValue, (*QLockFile).DestroyQLockFile)
	return tmpValue
}

func (ptr *QLockFile) Error() QLockFile__LockError {
	if ptr.Pointer() != nil {
		return QLockFile__LockError(C.QLockFile_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLockFile) GetLockInfo(pid int64, hostname string, appname string) bool {
	if ptr.Pointer() != nil {
		var hostnameC *C.char
		if hostname != "" {
			hostnameC = C.CString(hostname)
			defer C.free(unsafe.Pointer(hostnameC))
		}
		var appnameC *C.char
		if appname != "" {
			appnameC = C.CString(appname)
			defer C.free(unsafe.Pointer(appnameC))
		}
		return int8(C.QLockFile_GetLockInfo(ptr.Pointer(), C.longlong(pid), C.struct_QtCore_PackedString{data: hostnameC, len: C.longlong(len(hostname))}, C.struct_QtCore_PackedString{data: appnameC, len: C.longlong(len(appname))})) != 0
	}
	return false
}

func (ptr *QLockFile) IsLocked() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLockFile_IsLocked(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLockFile) Lock() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLockFile_Lock(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLockFile) RemoveStaleLockFile() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLockFile_RemoveStaleLockFile(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLockFile) SetStaleLockTime(staleLockTime int) {
	if ptr.Pointer() != nil {
		C.QLockFile_SetStaleLockTime(ptr.Pointer(), C.int(int32(staleLockTime)))
	}
}

func (ptr *QLockFile) StaleLockTime() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLockFile_StaleLockTime(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLockFile) TryLock(timeout int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLockFile_TryLock(ptr.Pointer(), C.int(int32(timeout)))) != 0
	}
	return false
}

func (ptr *QLockFile) Unlock() {
	if ptr.Pointer() != nil {
		C.QLockFile_Unlock(ptr.Pointer())
	}
}

func (ptr *QLockFile) DestroyQLockFile() {
	if ptr.Pointer() != nil {
		C.QLockFile_DestroyQLockFile(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QLoggingCategory struct {
	ptr unsafe.Pointer
}

type QLoggingCategory_ITF interface {
	QLoggingCategory_PTR() *QLoggingCategory
}

func (ptr *QLoggingCategory) QLoggingCategory_PTR() *QLoggingCategory {
	return ptr
}

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

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

func PointerFromQLoggingCategory(ptr QLoggingCategory_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLoggingCategory_PTR().Pointer()
	}
	return nil
}

func NewQLoggingCategoryFromPointer(ptr unsafe.Pointer) (n *QLoggingCategory) {
	n = new(QLoggingCategory)
	n.SetPointer(ptr)
	return
}
func NewQLoggingCategory2(category string) *QLoggingCategory {
	var categoryC *C.char
	if category != "" {
		categoryC = C.CString(category)
		defer C.free(unsafe.Pointer(categoryC))
	}
	tmpValue := NewQLoggingCategoryFromPointer(C.QLoggingCategory_NewQLoggingCategory2(categoryC))
	runtime.SetFinalizer(tmpValue, (*QLoggingCategory).DestroyQLoggingCategory)
	return tmpValue
}

func (ptr *QLoggingCategory) CategoryName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLoggingCategory_CategoryName(ptr.Pointer()))
	}
	return ""
}

func QLoggingCategory_DefaultCategory() *QLoggingCategory {
	return NewQLoggingCategoryFromPointer(C.QLoggingCategory_QLoggingCategory_DefaultCategory())
}

func (ptr *QLoggingCategory) DefaultCategory() *QLoggingCategory {
	return NewQLoggingCategoryFromPointer(C.QLoggingCategory_QLoggingCategory_DefaultCategory())
}

func (ptr *QLoggingCategory) IsCriticalEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLoggingCategory_IsCriticalEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLoggingCategory) IsDebugEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLoggingCategory_IsDebugEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLoggingCategory) IsInfoEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLoggingCategory_IsInfoEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLoggingCategory) IsWarningEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLoggingCategory_IsWarningEnabled(ptr.Pointer())) != 0
	}
	return false
}

func QLoggingCategory_SetFilterRules(rules string) {
	var rulesC *C.char
	if rules != "" {
		rulesC = C.CString(rules)
		defer C.free(unsafe.Pointer(rulesC))
	}
	C.QLoggingCategory_QLoggingCategory_SetFilterRules(C.struct_QtCore_PackedString{data: rulesC, len: C.longlong(len(rules))})
}

func (ptr *QLoggingCategory) SetFilterRules(rules string) {
	var rulesC *C.char
	if rules != "" {
		rulesC = C.CString(rules)
		defer C.free(unsafe.Pointer(rulesC))
	}
	C.QLoggingCategory_QLoggingCategory_SetFilterRules(C.struct_QtCore_PackedString{data: rulesC, len: C.longlong(len(rules))})
}

func (ptr *QLoggingCategory) DestroyQLoggingCategory() {
	if ptr.Pointer() != nil {
		C.QLoggingCategory_DestroyQLoggingCategory(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMap struct {
	ptr unsafe.Pointer
}

type QMap_ITF interface {
	QMap_PTR() *QMap
}

func (ptr *QMap) QMap_PTR() *QMap {
	return ptr
}

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

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

func PointerFromQMap(ptr QMap_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMap_PTR().Pointer()
	}
	return nil
}

func NewQMapFromPointer(ptr unsafe.Pointer) (n *QMap) {
	n = new(QMap)
	n.SetPointer(ptr)
	return
}

type QMapData struct {
	ptr unsafe.Pointer
}

type QMapData_ITF interface {
	QMapData_PTR() *QMapData
}

func (ptr *QMapData) QMapData_PTR() *QMapData {
	return ptr
}

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

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

func PointerFromQMapData(ptr QMapData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMapData_PTR().Pointer()
	}
	return nil
}

func NewQMapDataFromPointer(ptr unsafe.Pointer) (n *QMapData) {
	n = new(QMapData)
	n.SetPointer(ptr)
	return
}

func (ptr *QMapData) DestroyQMapData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMapDataBase struct {
	ptr unsafe.Pointer
}

type QMapDataBase_ITF interface {
	QMapDataBase_PTR() *QMapDataBase
}

func (ptr *QMapDataBase) QMapDataBase_PTR() *QMapDataBase {
	return ptr
}

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

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

func PointerFromQMapDataBase(ptr QMapDataBase_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMapDataBase_PTR().Pointer()
	}
	return nil
}

func NewQMapDataBaseFromPointer(ptr unsafe.Pointer) (n *QMapDataBase) {
	n = new(QMapDataBase)
	n.SetPointer(ptr)
	return
}

func (ptr *QMapDataBase) DestroyQMapDataBase() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMapIterator struct {
	ptr unsafe.Pointer
}

type QMapIterator_ITF interface {
	QMapIterator_PTR() *QMapIterator
}

func (ptr *QMapIterator) QMapIterator_PTR() *QMapIterator {
	return ptr
}

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

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

func PointerFromQMapIterator(ptr QMapIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMapIterator_PTR().Pointer()
	}
	return nil
}

func NewQMapIteratorFromPointer(ptr unsafe.Pointer) (n *QMapIterator) {
	n = new(QMapIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QMapIterator) DestroyQMapIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMapNode struct {
	ptr unsafe.Pointer
}

type QMapNode_ITF interface {
	QMapNode_PTR() *QMapNode
}

func (ptr *QMapNode) QMapNode_PTR() *QMapNode {
	return ptr
}

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

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

func PointerFromQMapNode(ptr QMapNode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMapNode_PTR().Pointer()
	}
	return nil
}

func NewQMapNodeFromPointer(ptr unsafe.Pointer) (n *QMapNode) {
	n = new(QMapNode)
	n.SetPointer(ptr)
	return
}

func (ptr *QMapNode) DestroyQMapNode() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMapNodeBase struct {
	ptr unsafe.Pointer
}

type QMapNodeBase_ITF interface {
	QMapNodeBase_PTR() *QMapNodeBase
}

func (ptr *QMapNodeBase) QMapNodeBase_PTR() *QMapNodeBase {
	return ptr
}

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

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

func PointerFromQMapNodeBase(ptr QMapNodeBase_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMapNodeBase_PTR().Pointer()
	}
	return nil
}

func NewQMapNodeBaseFromPointer(ptr unsafe.Pointer) (n *QMapNodeBase) {
	n = new(QMapNodeBase)
	n.SetPointer(ptr)
	return
}

func (ptr *QMapNodeBase) DestroyQMapNodeBase() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMargins struct {
	ptr unsafe.Pointer
}

type QMargins_ITF interface {
	QMargins_PTR() *QMargins
}

func (ptr *QMargins) QMargins_PTR() *QMargins {
	return ptr
}

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

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

func PointerFromQMargins(ptr QMargins_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMargins_PTR().Pointer()
	}
	return nil
}

func NewQMarginsFromPointer(ptr unsafe.Pointer) (n *QMargins) {
	n = new(QMargins)
	n.SetPointer(ptr)
	return
}

func (ptr *QMargins) DestroyQMargins() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQMargins() *QMargins {
	tmpValue := NewQMarginsFromPointer(C.QMargins_NewQMargins())
	runtime.SetFinalizer(tmpValue, (*QMargins).DestroyQMargins)
	return tmpValue
}

func NewQMargins2(left int, top int, right int, bottom int) *QMargins {
	tmpValue := NewQMarginsFromPointer(C.QMargins_NewQMargins2(C.int(int32(left)), C.int(int32(top)), C.int(int32(right)), C.int(int32(bottom))))
	runtime.SetFinalizer(tmpValue, (*QMargins).DestroyQMargins)
	return tmpValue
}

func (ptr *QMargins) Bottom() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMargins_Bottom(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMargins) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMargins_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMargins) Left() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMargins_Left(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMargins) Right() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMargins_Right(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMargins) SetBottom(bottom int) {
	if ptr.Pointer() != nil {
		C.QMargins_SetBottom(ptr.Pointer(), C.int(int32(bottom)))
	}
}

func (ptr *QMargins) SetLeft(left int) {
	if ptr.Pointer() != nil {
		C.QMargins_SetLeft(ptr.Pointer(), C.int(int32(left)))
	}
}

func (ptr *QMargins) SetRight(right int) {
	if ptr.Pointer() != nil {
		C.QMargins_SetRight(ptr.Pointer(), C.int(int32(right)))
	}
}

func (ptr *QMargins) SetTop(Top int) {
	if ptr.Pointer() != nil {
		C.QMargins_SetTop(ptr.Pointer(), C.int(int32(Top)))
	}
}

func (ptr *QMargins) Top() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMargins_Top(ptr.Pointer())))
	}
	return 0
}

type QMarginsF struct {
	ptr unsafe.Pointer
}

type QMarginsF_ITF interface {
	QMarginsF_PTR() *QMarginsF
}

func (ptr *QMarginsF) QMarginsF_PTR() *QMarginsF {
	return ptr
}

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

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

func PointerFromQMarginsF(ptr QMarginsF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMarginsF_PTR().Pointer()
	}
	return nil
}

func NewQMarginsFFromPointer(ptr unsafe.Pointer) (n *QMarginsF) {
	n = new(QMarginsF)
	n.SetPointer(ptr)
	return
}

func (ptr *QMarginsF) DestroyQMarginsF() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQMarginsF() *QMarginsF {
	tmpValue := NewQMarginsFFromPointer(C.QMarginsF_NewQMarginsF())
	runtime.SetFinalizer(tmpValue, (*QMarginsF).DestroyQMarginsF)
	return tmpValue
}

func NewQMarginsF2(left float64, top float64, right float64, bottom float64) *QMarginsF {
	tmpValue := NewQMarginsFFromPointer(C.QMarginsF_NewQMarginsF2(C.double(left), C.double(top), C.double(right), C.double(bottom)))
	runtime.SetFinalizer(tmpValue, (*QMarginsF).DestroyQMarginsF)
	return tmpValue
}

func NewQMarginsF3(margins QMargins_ITF) *QMarginsF {
	tmpValue := NewQMarginsFFromPointer(C.QMarginsF_NewQMarginsF3(PointerFromQMargins(margins)))
	runtime.SetFinalizer(tmpValue, (*QMarginsF).DestroyQMarginsF)
	return tmpValue
}

func (ptr *QMarginsF) Bottom() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QMarginsF_Bottom(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMarginsF) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMarginsF_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMarginsF) Left() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QMarginsF_Left(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMarginsF) Right() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QMarginsF_Right(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMarginsF) SetBottom(bottom float64) {
	if ptr.Pointer() != nil {
		C.QMarginsF_SetBottom(ptr.Pointer(), C.double(bottom))
	}
}

func (ptr *QMarginsF) SetLeft(left float64) {
	if ptr.Pointer() != nil {
		C.QMarginsF_SetLeft(ptr.Pointer(), C.double(left))
	}
}

func (ptr *QMarginsF) SetRight(right float64) {
	if ptr.Pointer() != nil {
		C.QMarginsF_SetRight(ptr.Pointer(), C.double(right))
	}
}

func (ptr *QMarginsF) SetTop(Top float64) {
	if ptr.Pointer() != nil {
		C.QMarginsF_SetTop(ptr.Pointer(), C.double(Top))
	}
}

func (ptr *QMarginsF) ToMargins() *QMargins {
	if ptr.Pointer() != nil {
		tmpValue := NewQMarginsFromPointer(C.QMarginsF_ToMargins(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QMargins).DestroyQMargins)
		return tmpValue
	}
	return nil
}

func (ptr *QMarginsF) Top() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QMarginsF_Top(ptr.Pointer()))
	}
	return 0
}

type QMessageAuthenticationCode struct {
	ptr unsafe.Pointer
}

type QMessageAuthenticationCode_ITF interface {
	QMessageAuthenticationCode_PTR() *QMessageAuthenticationCode
}

func (ptr *QMessageAuthenticationCode) QMessageAuthenticationCode_PTR() *QMessageAuthenticationCode {
	return ptr
}

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

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

func PointerFromQMessageAuthenticationCode(ptr QMessageAuthenticationCode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMessageAuthenticationCode_PTR().Pointer()
	}
	return nil
}

func NewQMessageAuthenticationCodeFromPointer(ptr unsafe.Pointer) (n *QMessageAuthenticationCode) {
	n = new(QMessageAuthenticationCode)
	n.SetPointer(ptr)
	return
}
func NewQMessageAuthenticationCode(method QCryptographicHash__Algorithm, key QByteArray_ITF) *QMessageAuthenticationCode {
	tmpValue := NewQMessageAuthenticationCodeFromPointer(C.QMessageAuthenticationCode_NewQMessageAuthenticationCode(C.longlong(method), PointerFromQByteArray(key)))
	runtime.SetFinalizer(tmpValue, (*QMessageAuthenticationCode).DestroyQMessageAuthenticationCode)
	return tmpValue
}

func (ptr *QMessageAuthenticationCode) AddData(data []byte, length int) {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		C.QMessageAuthenticationCode_AddData(ptr.Pointer(), dataC, C.int(int32(length)))
	}
}

func (ptr *QMessageAuthenticationCode) AddData2(data QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QMessageAuthenticationCode_AddData2(ptr.Pointer(), PointerFromQByteArray(data))
	}
}

func (ptr *QMessageAuthenticationCode) AddData3(device QIODevice_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMessageAuthenticationCode_AddData3(ptr.Pointer(), PointerFromQIODevice(device))) != 0
	}
	return false
}

func QMessageAuthenticationCode_Hash(message QByteArray_ITF, key QByteArray_ITF, method QCryptographicHash__Algorithm) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QMessageAuthenticationCode_QMessageAuthenticationCode_Hash(PointerFromQByteArray(message), PointerFromQByteArray(key), C.longlong(method)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QMessageAuthenticationCode) Hash(message QByteArray_ITF, key QByteArray_ITF, method QCryptographicHash__Algorithm) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QMessageAuthenticationCode_QMessageAuthenticationCode_Hash(PointerFromQByteArray(message), PointerFromQByteArray(key), C.longlong(method)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QMessageAuthenticationCode) Reset() {
	if ptr.Pointer() != nil {
		C.QMessageAuthenticationCode_Reset(ptr.Pointer())
	}
}

func (ptr *QMessageAuthenticationCode) Result() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QMessageAuthenticationCode_Result(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QMessageAuthenticationCode) SetKey(key QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QMessageAuthenticationCode_SetKey(ptr.Pointer(), PointerFromQByteArray(key))
	}
}

func (ptr *QMessageAuthenticationCode) DestroyQMessageAuthenticationCode() {
	if ptr.Pointer() != nil {
		C.QMessageAuthenticationCode_DestroyQMessageAuthenticationCode(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMessageLogContext struct {
	ptr unsafe.Pointer
}

type QMessageLogContext_ITF interface {
	QMessageLogContext_PTR() *QMessageLogContext
}

func (ptr *QMessageLogContext) QMessageLogContext_PTR() *QMessageLogContext {
	return ptr
}

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

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

func PointerFromQMessageLogContext(ptr QMessageLogContext_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMessageLogContext_PTR().Pointer()
	}
	return nil
}

func NewQMessageLogContextFromPointer(ptr unsafe.Pointer) (n *QMessageLogContext) {
	n = new(QMessageLogContext)
	n.SetPointer(ptr)
	return
}

func (ptr *QMessageLogContext) DestroyQMessageLogContext() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMessageLogger struct {
	ptr unsafe.Pointer
}

type QMessageLogger_ITF interface {
	QMessageLogger_PTR() *QMessageLogger
}

func (ptr *QMessageLogger) QMessageLogger_PTR() *QMessageLogger {
	return ptr
}

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

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

func PointerFromQMessageLogger(ptr QMessageLogger_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMessageLogger_PTR().Pointer()
	}
	return nil
}

func NewQMessageLoggerFromPointer(ptr unsafe.Pointer) (n *QMessageLogger) {
	n = new(QMessageLogger)
	n.SetPointer(ptr)
	return
}

func (ptr *QMessageLogger) DestroyQMessageLogger() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQMessageLogger2() *QMessageLogger {
	tmpValue := NewQMessageLoggerFromPointer(C.QMessageLogger_NewQMessageLogger2())
	runtime.SetFinalizer(tmpValue, (*QMessageLogger).DestroyQMessageLogger)
	return tmpValue
}

func NewQMessageLogger3(file string, line int, function string) *QMessageLogger {
	var fileC *C.char
	if file != "" {
		fileC = C.CString(file)
		defer C.free(unsafe.Pointer(fileC))
	}
	var functionC *C.char
	if function != "" {
		functionC = C.CString(function)
		defer C.free(unsafe.Pointer(functionC))
	}
	tmpValue := NewQMessageLoggerFromPointer(C.QMessageLogger_NewQMessageLogger3(fileC, C.int(int32(line)), functionC))
	runtime.SetFinalizer(tmpValue, (*QMessageLogger).DestroyQMessageLogger)
	return tmpValue
}

func NewQMessageLogger4(file string, line int, function string, category string) *QMessageLogger {
	var fileC *C.char
	if file != "" {
		fileC = C.CString(file)
		defer C.free(unsafe.Pointer(fileC))
	}
	var functionC *C.char
	if function != "" {
		functionC = C.CString(function)
		defer C.free(unsafe.Pointer(functionC))
	}
	var categoryC *C.char
	if category != "" {
		categoryC = C.CString(category)
		defer C.free(unsafe.Pointer(categoryC))
	}
	tmpValue := NewQMessageLoggerFromPointer(C.QMessageLogger_NewQMessageLogger4(fileC, C.int(int32(line)), functionC, categoryC))
	runtime.SetFinalizer(tmpValue, (*QMessageLogger).DestroyQMessageLogger)
	return tmpValue
}

func (ptr *QMessageLogger) Critical4() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QMessageLogger_Critical4(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QMessageLogger) Critical5(cat QLoggingCategory_ITF) *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QMessageLogger_Critical5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QMessageLogger) Debug4() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QMessageLogger_Debug4(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QMessageLogger) Debug5(cat QLoggingCategory_ITF) *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QMessageLogger_Debug5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QMessageLogger) Info4() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QMessageLogger_Info4(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QMessageLogger) Info5(cat QLoggingCategory_ITF) *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QMessageLogger_Info5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QMessageLogger) Warning4() *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QMessageLogger_Warning4(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

func (ptr *QMessageLogger) Warning5(cat QLoggingCategory_ITF) *QDebug {
	if ptr.Pointer() != nil {
		tmpValue := NewQDebugFromPointer(C.QMessageLogger_Warning5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
		runtime.SetFinalizer(tmpValue, (*QDebug).DestroyQDebug)
		return tmpValue
	}
	return nil
}

type QMetaClassInfo struct {
	ptr unsafe.Pointer
}

type QMetaClassInfo_ITF interface {
	QMetaClassInfo_PTR() *QMetaClassInfo
}

func (ptr *QMetaClassInfo) QMetaClassInfo_PTR() *QMetaClassInfo {
	return ptr
}

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

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

func PointerFromQMetaClassInfo(ptr QMetaClassInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaClassInfo_PTR().Pointer()
	}
	return nil
}

func NewQMetaClassInfoFromPointer(ptr unsafe.Pointer) (n *QMetaClassInfo) {
	n = new(QMetaClassInfo)
	n.SetPointer(ptr)
	return
}

func (ptr *QMetaClassInfo) DestroyQMetaClassInfo() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMetaClassInfo) Name() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaClassInfo_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaClassInfo) Value() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaClassInfo_Value(ptr.Pointer()))
	}
	return ""
}

type QMetaEnum struct {
	ptr unsafe.Pointer
}

type QMetaEnum_ITF interface {
	QMetaEnum_PTR() *QMetaEnum
}

func (ptr *QMetaEnum) QMetaEnum_PTR() *QMetaEnum {
	return ptr
}

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

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

func PointerFromQMetaEnum(ptr QMetaEnum_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaEnum_PTR().Pointer()
	}
	return nil
}

func NewQMetaEnumFromPointer(ptr unsafe.Pointer) (n *QMetaEnum) {
	n = new(QMetaEnum)
	n.SetPointer(ptr)
	return
}

func (ptr *QMetaEnum) DestroyQMetaEnum() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMetaEnum) EnumName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaEnum_EnumName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaEnum) IsFlag() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaEnum_IsFlag(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaEnum) IsScoped() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaEnum_IsScoped(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaEnum) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaEnum_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaEnum) Key(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaEnum_Key(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QMetaEnum) KeyCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaEnum_KeyCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaEnum) KeyToValue(key string, ok *bool) int {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QMetaEnum_KeyToValue(ptr.Pointer(), keyC, &okC)))
	}
	return 0
}

func (ptr *QMetaEnum) KeysToValue(keys string, ok *bool) int {
	if ptr.Pointer() != nil {
		var keysC *C.char
		if keys != "" {
			keysC = C.CString(keys)
			defer C.free(unsafe.Pointer(keysC))
		}
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QMetaEnum_KeysToValue(ptr.Pointer(), keysC, &okC)))
	}
	return 0
}

func (ptr *QMetaEnum) Name() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaEnum_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaEnum) Scope() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaEnum_Scope(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaEnum) Value(index int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaEnum_Value(ptr.Pointer(), C.int(int32(index)))))
	}
	return 0
}

func (ptr *QMetaEnum) ValueToKey(value int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaEnum_ValueToKey(ptr.Pointer(), C.int(int32(value))))
	}
	return ""
}

func (ptr *QMetaEnum) ValueToKeys(value int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QMetaEnum_ValueToKeys(ptr.Pointer(), C.int(int32(value))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

type QMetaMethod struct {
	ptr unsafe.Pointer
}

type QMetaMethod_ITF interface {
	QMetaMethod_PTR() *QMetaMethod
}

func (ptr *QMetaMethod) QMetaMethod_PTR() *QMetaMethod {
	return ptr
}

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

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

func PointerFromQMetaMethod(ptr QMetaMethod_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaMethod_PTR().Pointer()
	}
	return nil
}

func NewQMetaMethodFromPointer(ptr unsafe.Pointer) (n *QMetaMethod) {
	n = new(QMetaMethod)
	n.SetPointer(ptr)
	return
}

func (ptr *QMetaMethod) DestroyQMetaMethod() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QMetaMethod__Access
//QMetaMethod::Access
type QMetaMethod__Access int64

const (
	QMetaMethod__Private   QMetaMethod__Access = QMetaMethod__Access(0)
	QMetaMethod__Protected QMetaMethod__Access = QMetaMethod__Access(1)
	QMetaMethod__Public    QMetaMethod__Access = QMetaMethod__Access(2)
)

//go:generate stringer -type=QMetaMethod__MethodType
//QMetaMethod::MethodType
type QMetaMethod__MethodType int64

const (
	QMetaMethod__Method      QMetaMethod__MethodType = QMetaMethod__MethodType(0)
	QMetaMethod__Signal      QMetaMethod__MethodType = QMetaMethod__MethodType(1)
	QMetaMethod__Slot        QMetaMethod__MethodType = QMetaMethod__MethodType(2)
	QMetaMethod__Constructor QMetaMethod__MethodType = QMetaMethod__MethodType(3)
)

func (ptr *QMetaMethod) Access() QMetaMethod__Access {
	if ptr.Pointer() != nil {
		return QMetaMethod__Access(C.QMetaMethod_Access(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaMethod) Invoke(object QObject_ITF, connectionType Qt__ConnectionType, returnValue QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaMethod_Invoke(ptr.Pointer(), PointerFromQObject(object), C.longlong(connectionType), PointerFromQGenericReturnArgument(returnValue), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
	}
	return false
}

func (ptr *QMetaMethod) Invoke2(object QObject_ITF, returnValue QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaMethod_Invoke2(ptr.Pointer(), PointerFromQObject(object), PointerFromQGenericReturnArgument(returnValue), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
	}
	return false
}

func (ptr *QMetaMethod) Invoke3(object QObject_ITF, connectionType Qt__ConnectionType, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaMethod_Invoke3(ptr.Pointer(), PointerFromQObject(object), C.longlong(connectionType), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
	}
	return false
}

func (ptr *QMetaMethod) Invoke4(object QObject_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaMethod_Invoke4(ptr.Pointer(), PointerFromQObject(object), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
	}
	return false
}

func (ptr *QMetaMethod) InvokeOnGadget(gadget unsafe.Pointer, returnValue QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaMethod_InvokeOnGadget(ptr.Pointer(), gadget, PointerFromQGenericReturnArgument(returnValue), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
	}
	return false
}

func (ptr *QMetaMethod) InvokeOnGadget2(gadget unsafe.Pointer, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaMethod_InvokeOnGadget2(ptr.Pointer(), gadget, PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
	}
	return false
}

func (ptr *QMetaMethod) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaMethod_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaMethod) MethodIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaMethod_MethodIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaMethod) MethodSignature() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QMetaMethod_MethodSignature(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QMetaMethod) MethodType() QMetaMethod__MethodType {
	if ptr.Pointer() != nil {
		return QMetaMethod__MethodType(C.QMetaMethod_MethodType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaMethod) Name() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QMetaMethod_Name(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QMetaMethod) ParameterCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaMethod_ParameterCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaMethod) ParameterNames() []*QByteArray {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QByteArray {
			out := make([]*QByteArray, int(l.len))
			tmpList := NewQMetaMethodFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__parameterNames_atList(i)
			}
			return out
		}(C.QMetaMethod_ParameterNames(ptr.Pointer()))
	}
	return make([]*QByteArray, 0)
}

func (ptr *QMetaMethod) ParameterType(index int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaMethod_ParameterType(ptr.Pointer(), C.int(int32(index)))))
	}
	return 0
}

func (ptr *QMetaMethod) ParameterTypes() []*QByteArray {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QByteArray {
			out := make([]*QByteArray, int(l.len))
			tmpList := NewQMetaMethodFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__parameterTypes_atList(i)
			}
			return out
		}(C.QMetaMethod_ParameterTypes(ptr.Pointer()))
	}
	return make([]*QByteArray, 0)
}

func (ptr *QMetaMethod) ReturnType() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaMethod_ReturnType(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaMethod) Revision() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaMethod_Revision(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaMethod) Tag() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaMethod_Tag(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaMethod) TypeName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaMethod_TypeName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaMethod) __parameterNames_atList(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QMetaMethod___parameterNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QMetaMethod) __parameterNames_setList(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QMetaMethod___parameterNames_setList(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QMetaMethod) __parameterNames_newList() unsafe.Pointer {
	return C.QMetaMethod___parameterNames_newList(ptr.Pointer())
}

func (ptr *QMetaMethod) __parameterTypes_atList(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QMetaMethod___parameterTypes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QMetaMethod) __parameterTypes_setList(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QMetaMethod___parameterTypes_setList(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QMetaMethod) __parameterTypes_newList() unsafe.Pointer {
	return C.QMetaMethod___parameterTypes_newList(ptr.Pointer())
}

type QMetaObject struct {
	ptr unsafe.Pointer
}

type QMetaObject_ITF interface {
	QMetaObject_PTR() *QMetaObject
}

func (ptr *QMetaObject) QMetaObject_PTR() *QMetaObject {
	return ptr
}

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

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

func PointerFromQMetaObject(ptr QMetaObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaObject_PTR().Pointer()
	}
	return nil
}

func NewQMetaObjectFromPointer(ptr unsafe.Pointer) (n *QMetaObject) {
	n = new(QMetaObject)
	n.SetPointer(ptr)
	return
}

func (ptr *QMetaObject) DestroyQMetaObject() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func QMetaObject_CheckConnectArgs(sign string, method string) bool {
	var signC *C.char
	if sign != "" {
		signC = C.CString(sign)
		defer C.free(unsafe.Pointer(signC))
	}
	var methodC *C.char
	if method != "" {
		methodC = C.CString(method)
		defer C.free(unsafe.Pointer(methodC))
	}
	return int8(C.QMetaObject_QMetaObject_CheckConnectArgs(signC, methodC)) != 0
}

func (ptr *QMetaObject) CheckConnectArgs(sign string, method string) bool {
	var signC *C.char
	if sign != "" {
		signC = C.CString(sign)
		defer C.free(unsafe.Pointer(signC))
	}
	var methodC *C.char
	if method != "" {
		methodC = C.CString(method)
		defer C.free(unsafe.Pointer(methodC))
	}
	return int8(C.QMetaObject_QMetaObject_CheckConnectArgs(signC, methodC)) != 0
}

func QMetaObject_CheckConnectArgs2(sign QMetaMethod_ITF, method QMetaMethod_ITF) bool {
	return int8(C.QMetaObject_QMetaObject_CheckConnectArgs2(PointerFromQMetaMethod(sign), PointerFromQMetaMethod(method))) != 0
}

func (ptr *QMetaObject) CheckConnectArgs2(sign QMetaMethod_ITF, method QMetaMethod_ITF) bool {
	return int8(C.QMetaObject_QMetaObject_CheckConnectArgs2(PointerFromQMetaMethod(sign), PointerFromQMetaMethod(method))) != 0
}

func (ptr *QMetaObject) ClassInfoCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaObject_ClassInfoCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaObject) ClassInfoOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaObject_ClassInfoOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaObject) ClassName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaObject_ClassName(ptr.Pointer()))
	}
	return ""
}

func QMetaObject_ConnectSlotsByName(object QObject_ITF) {
	C.QMetaObject_QMetaObject_ConnectSlotsByName(PointerFromQObject(object))
}

func (ptr *QMetaObject) ConnectSlotsByName(object QObject_ITF) {
	C.QMetaObject_QMetaObject_ConnectSlotsByName(PointerFromQObject(object))
}

func (ptr *QMetaObject) Constructor(index int) *QMetaMethod {
	if ptr.Pointer() != nil {
		tmpValue := NewQMetaMethodFromPointer(C.QMetaObject_Constructor(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*QMetaMethod).DestroyQMetaMethod)
		return tmpValue
	}
	return nil
}

func (ptr *QMetaObject) ConstructorCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaObject_ConstructorCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaObject) EnumeratorCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaObject_EnumeratorCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaObject) EnumeratorOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaObject_EnumeratorOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfClassInfo(name string) int {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int(int32(C.QMetaObject_IndexOfClassInfo(ptr.Pointer(), nameC)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfConstructor(constructor string) int {
	if ptr.Pointer() != nil {
		var constructorC *C.char
		if constructor != "" {
			constructorC = C.CString(constructor)
			defer C.free(unsafe.Pointer(constructorC))
		}
		return int(int32(C.QMetaObject_IndexOfConstructor(ptr.Pointer(), constructorC)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfEnumerator(name string) int {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int(int32(C.QMetaObject_IndexOfEnumerator(ptr.Pointer(), nameC)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfMethod(method string) int {
	if ptr.Pointer() != nil {
		var methodC *C.char
		if method != "" {
			methodC = C.CString(method)
			defer C.free(unsafe.Pointer(methodC))
		}
		return int(int32(C.QMetaObject_IndexOfMethod(ptr.Pointer(), methodC)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfProperty(name string) int {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int(int32(C.QMetaObject_IndexOfProperty(ptr.Pointer(), nameC)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfSignal(sign string) int {
	if ptr.Pointer() != nil {
		var signC *C.char
		if sign != "" {
			signC = C.CString(sign)
			defer C.free(unsafe.Pointer(signC))
		}
		return int(int32(C.QMetaObject_IndexOfSignal(ptr.Pointer(), signC)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfSlot(slot string) int {
	if ptr.Pointer() != nil {
		var slotC *C.char
		if slot != "" {
			slotC = C.CString(slot)
			defer C.free(unsafe.Pointer(slotC))
		}
		return int(int32(C.QMetaObject_IndexOfSlot(ptr.Pointer(), slotC)))
	}
	return 0
}

func (ptr *QMetaObject) Inherits(metaObject QMetaObject_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaObject_Inherits(ptr.Pointer(), PointerFromQMetaObject(metaObject))) != 0
	}
	return false
}

func QMetaObject_InvokeMethod(obj QObject_ITF, member string, ty Qt__ConnectionType, ret QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	return int8(C.QMetaObject_QMetaObject_InvokeMethod(PointerFromQObject(obj), memberC, C.longlong(ty), PointerFromQGenericReturnArgument(ret), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
}

func (ptr *QMetaObject) InvokeMethod(obj QObject_ITF, member string, ty Qt__ConnectionType, ret QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	return int8(C.QMetaObject_QMetaObject_InvokeMethod(PointerFromQObject(obj), memberC, C.longlong(ty), PointerFromQGenericReturnArgument(ret), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
}

func QMetaObject_InvokeMethod2(obj QObject_ITF, member string, ret QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	return int8(C.QMetaObject_QMetaObject_InvokeMethod2(PointerFromQObject(obj), memberC, PointerFromQGenericReturnArgument(ret), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
}

func (ptr *QMetaObject) InvokeMethod2(obj QObject_ITF, member string, ret QGenericReturnArgument_ITF, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	return int8(C.QMetaObject_QMetaObject_InvokeMethod2(PointerFromQObject(obj), memberC, PointerFromQGenericReturnArgument(ret), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
}

func QMetaObject_InvokeMethod3(obj QObject_ITF, member string, ty Qt__ConnectionType, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	return int8(C.QMetaObject_QMetaObject_InvokeMethod3(PointerFromQObject(obj), memberC, C.longlong(ty), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
}

func (ptr *QMetaObject) InvokeMethod3(obj QObject_ITF, member string, ty Qt__ConnectionType, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	return int8(C.QMetaObject_QMetaObject_InvokeMethod3(PointerFromQObject(obj), memberC, C.longlong(ty), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
}

func QMetaObject_InvokeMethod4(obj QObject_ITF, member string, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	return int8(C.QMetaObject_QMetaObject_InvokeMethod4(PointerFromQObject(obj), memberC, PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
}

func (ptr *QMetaObject) InvokeMethod4(obj QObject_ITF, member string, val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) bool {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	return int8(C.QMetaObject_QMetaObject_InvokeMethod4(PointerFromQObject(obj), memberC, PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9))) != 0
}

func (ptr *QMetaObject) Method(index int) *QMetaMethod {
	if ptr.Pointer() != nil {
		tmpValue := NewQMetaMethodFromPointer(C.QMetaObject_Method(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*QMetaMethod).DestroyQMetaMethod)
		return tmpValue
	}
	return nil
}

func (ptr *QMetaObject) MethodCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaObject_MethodCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaObject) MethodOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaObject_MethodOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaObject) NewInstance(val0 QGenericArgument_ITF, val1 QGenericArgument_ITF, val2 QGenericArgument_ITF, val3 QGenericArgument_ITF, val4 QGenericArgument_ITF, val5 QGenericArgument_ITF, val6 QGenericArgument_ITF, val7 QGenericArgument_ITF, val8 QGenericArgument_ITF, val9 QGenericArgument_ITF) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QMetaObject_NewInstance(ptr.Pointer(), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func QMetaObject_NormalizedSignature(method string) *QByteArray {
	var methodC *C.char
	if method != "" {
		methodC = C.CString(method)
		defer C.free(unsafe.Pointer(methodC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QMetaObject_QMetaObject_NormalizedSignature(methodC))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QMetaObject) NormalizedSignature(method string) *QByteArray {
	var methodC *C.char
	if method != "" {
		methodC = C.CString(method)
		defer C.free(unsafe.Pointer(methodC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QMetaObject_QMetaObject_NormalizedSignature(methodC))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QMetaObject_NormalizedType(ty string) *QByteArray {
	var tyC *C.char
	if ty != "" {
		tyC = C.CString(ty)
		defer C.free(unsafe.Pointer(tyC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QMetaObject_QMetaObject_NormalizedType(tyC))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QMetaObject) NormalizedType(ty string) *QByteArray {
	var tyC *C.char
	if ty != "" {
		tyC = C.CString(ty)
		defer C.free(unsafe.Pointer(tyC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QMetaObject_QMetaObject_NormalizedType(tyC))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QMetaObject) PropertyCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaObject_PropertyCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaObject) PropertyOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaObject_PropertyOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaObject) SuperClass() *QMetaObject {
	if ptr.Pointer() != nil {
		return NewQMetaObjectFromPointer(C.QMetaObject_SuperClass(ptr.Pointer()))
	}
	return nil
}

type QMetaProperty struct {
	ptr unsafe.Pointer
}

type QMetaProperty_ITF interface {
	QMetaProperty_PTR() *QMetaProperty
}

func (ptr *QMetaProperty) QMetaProperty_PTR() *QMetaProperty {
	return ptr
}

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

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

func PointerFromQMetaProperty(ptr QMetaProperty_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaProperty_PTR().Pointer()
	}
	return nil
}

func NewQMetaPropertyFromPointer(ptr unsafe.Pointer) (n *QMetaProperty) {
	n = new(QMetaProperty)
	n.SetPointer(ptr)
	return
}

func (ptr *QMetaProperty) DestroyQMetaProperty() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMetaProperty) HasNotifySignal() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_HasNotifySignal(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsConstant() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsConstant(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsDesignable(object QObject_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsDesignable(ptr.Pointer(), PointerFromQObject(object))) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsEnumType() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsEnumType(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsFinal() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsFinal(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsFlagType() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsFlagType(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsReadable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsReadable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsResettable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsResettable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsScriptable(object QObject_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsScriptable(ptr.Pointer(), PointerFromQObject(object))) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsStored(object QObject_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsStored(ptr.Pointer(), PointerFromQObject(object))) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsUser(object QObject_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsUser(ptr.Pointer(), PointerFromQObject(object))) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsWritable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_IsWritable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaProperty) Name() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaProperty_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaProperty) NotifySignal() *QMetaMethod {
	if ptr.Pointer() != nil {
		tmpValue := NewQMetaMethodFromPointer(C.QMetaProperty_NotifySignal(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QMetaMethod).DestroyQMetaMethod)
		return tmpValue
	}
	return nil
}

func (ptr *QMetaProperty) NotifySignalIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaProperty_NotifySignalIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaProperty) PropertyIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaProperty_PropertyIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaProperty) Read(object QObject_ITF) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QMetaProperty_Read(ptr.Pointer(), PointerFromQObject(object)))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QMetaProperty) ReadOnGadget(gadget unsafe.Pointer) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QMetaProperty_ReadOnGadget(ptr.Pointer(), gadget))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QMetaProperty) Reset(object QObject_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_Reset(ptr.Pointer(), PointerFromQObject(object))) != 0
	}
	return false
}

func (ptr *QMetaProperty) ResetOnGadget(gadget unsafe.Pointer) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_ResetOnGadget(ptr.Pointer(), gadget)) != 0
	}
	return false
}

func (ptr *QMetaProperty) Revision() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaProperty_Revision(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaProperty) Type() QVariant__Type {
	if ptr.Pointer() != nil {
		return QVariant__Type(C.QMetaProperty_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaProperty) TypeName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMetaProperty_TypeName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaProperty) UserType() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaProperty_UserType(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMetaProperty) Write(object QObject_ITF, value QVariant_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_Write(ptr.Pointer(), PointerFromQObject(object), PointerFromQVariant(value))) != 0
	}
	return false
}

func (ptr *QMetaProperty) WriteOnGadget(gadget unsafe.Pointer, value QVariant_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaProperty_WriteOnGadget(ptr.Pointer(), gadget, PointerFromQVariant(value))) != 0
	}
	return false
}

type QMetaType struct {
	ptr unsafe.Pointer
}

type QMetaType_ITF interface {
	QMetaType_PTR() *QMetaType
}

func (ptr *QMetaType) QMetaType_PTR() *QMetaType {
	return ptr
}

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

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

func PointerFromQMetaType(ptr QMetaType_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaType_PTR().Pointer()
	}
	return nil
}

func NewQMetaTypeFromPointer(ptr unsafe.Pointer) (n *QMetaType) {
	n = new(QMetaType)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QMetaType__Type
//QMetaType::Type
type QMetaType__Type int64

const (
	QMetaType__UnknownType           QMetaType__Type = QMetaType__Type(0)
	QMetaType__Bool                  QMetaType__Type = QMetaType__Type(1)
	QMetaType__Int                   QMetaType__Type = QMetaType__Type(2)
	QMetaType__UInt                  QMetaType__Type = QMetaType__Type(3)
	QMetaType__LongLong              QMetaType__Type = QMetaType__Type(4)
	QMetaType__ULongLong             QMetaType__Type = QMetaType__Type(5)
	QMetaType__Double                QMetaType__Type = QMetaType__Type(6)
	QMetaType__Long                  QMetaType__Type = QMetaType__Type(32)
	QMetaType__Short                 QMetaType__Type = QMetaType__Type(33)
	QMetaType__Char                  QMetaType__Type = QMetaType__Type(34)
	QMetaType__ULong                 QMetaType__Type = QMetaType__Type(35)
	QMetaType__UShort                QMetaType__Type = QMetaType__Type(36)
	QMetaType__UChar                 QMetaType__Type = QMetaType__Type(37)
	QMetaType__Float                 QMetaType__Type = QMetaType__Type(38)
	QMetaType__VoidStar              QMetaType__Type = QMetaType__Type(31)
	QMetaType__QChar                 QMetaType__Type = QMetaType__Type(7)
	QMetaType__QString               QMetaType__Type = QMetaType__Type(10)
	QMetaType__QStringList           QMetaType__Type = QMetaType__Type(11)
	QMetaType__QByteArray            QMetaType__Type = QMetaType__Type(12)
	QMetaType__QBitArray             QMetaType__Type = QMetaType__Type(13)
	QMetaType__QDate                 QMetaType__Type = QMetaType__Type(14)
	QMetaType__QTime                 QMetaType__Type = QMetaType__Type(15)
	QMetaType__QDateTime             QMetaType__Type = QMetaType__Type(16)
	QMetaType__QUrl                  QMetaType__Type = QMetaType__Type(17)
	QMetaType__QLocale               QMetaType__Type = QMetaType__Type(18)
	QMetaType__QRect                 QMetaType__Type = QMetaType__Type(19)
	QMetaType__QRectF                QMetaType__Type = QMetaType__Type(20)
	QMetaType__QSize                 QMetaType__Type = QMetaType__Type(21)
	QMetaType__QSizeF                QMetaType__Type = QMetaType__Type(22)
	QMetaType__QLine                 QMetaType__Type = QMetaType__Type(23)
	QMetaType__QLineF                QMetaType__Type = QMetaType__Type(24)
	QMetaType__QPoint                QMetaType__Type = QMetaType__Type(25)
	QMetaType__QPointF               QMetaType__Type = QMetaType__Type(26)
	QMetaType__QRegExp               QMetaType__Type = QMetaType__Type(27)
	QMetaType__QEasingCurve          QMetaType__Type = QMetaType__Type(29)
	QMetaType__QUuid                 QMetaType__Type = QMetaType__Type(30)
	QMetaType__QVariant              QMetaType__Type = QMetaType__Type(41)
	QMetaType__QModelIndex           QMetaType__Type = QMetaType__Type(42)
	QMetaType__QPersistentModelIndex QMetaType__Type = QMetaType__Type(50)
	QMetaType__QRegularExpression    QMetaType__Type = QMetaType__Type(44)
	QMetaType__QJsonValue            QMetaType__Type = QMetaType__Type(45)
	QMetaType__QJsonObject           QMetaType__Type = QMetaType__Type(46)
	QMetaType__QJsonArray            QMetaType__Type = QMetaType__Type(47)
	QMetaType__QJsonDocument         QMetaType__Type = QMetaType__Type(48)
	QMetaType__QByteArrayList        QMetaType__Type = QMetaType__Type(49)
	QMetaType__QObjectStar           QMetaType__Type = QMetaType__Type(39)
	QMetaType__SChar                 QMetaType__Type = QMetaType__Type(40)
	QMetaType__Void                  QMetaType__Type = QMetaType__Type(43)
	QMetaType__Nullptr               QMetaType__Type = QMetaType__Type(51)
	QMetaType__QVariantMap           QMetaType__Type = QMetaType__Type(8)
	QMetaType__QVariantList          QMetaType__Type = QMetaType__Type(9)
	QMetaType__QVariantHash          QMetaType__Type = QMetaType__Type(28)
	QMetaType__QCborSimpleType       QMetaType__Type = QMetaType__Type(52)
	QMetaType__QCborValue            QMetaType__Type = QMetaType__Type(53)
	QMetaType__QCborArray            QMetaType__Type = QMetaType__Type(54)
	QMetaType__QCborMap              QMetaType__Type = QMetaType__Type(55)
	QMetaType__QFont                 QMetaType__Type = QMetaType__Type(64)
	QMetaType__QPixmap               QMetaType__Type = QMetaType__Type(65)
	QMetaType__QBrush                QMetaType__Type = QMetaType__Type(66)
	QMetaType__QColor                QMetaType__Type = QMetaType__Type(67)
	QMetaType__QPalette              QMetaType__Type = QMetaType__Type(68)
	QMetaType__QIcon                 QMetaType__Type = QMetaType__Type(69)
	QMetaType__QImage                QMetaType__Type = QMetaType__Type(70)
	QMetaType__QPolygon              QMetaType__Type = QMetaType__Type(71)
	QMetaType__QRegion               QMetaType__Type = QMetaType__Type(72)
	QMetaType__QBitmap               QMetaType__Type = QMetaType__Type(73)
	QMetaType__QCursor               QMetaType__Type = QMetaType__Type(74)
	QMetaType__QKeySequence          QMetaType__Type = QMetaType__Type(75)
	QMetaType__QPen                  QMetaType__Type = QMetaType__Type(76)
	QMetaType__QTextLength           QMetaType__Type = QMetaType__Type(77)
	QMetaType__QTextFormat           QMetaType__Type = QMetaType__Type(78)
	QMetaType__QMatrix               QMetaType__Type = QMetaType__Type(79)
	QMetaType__QTransform            QMetaType__Type = QMetaType__Type(80)
	QMetaType__QMatrix4x4            QMetaType__Type = QMetaType__Type(81)
	QMetaType__QVector2D             QMetaType__Type = QMetaType__Type(82)
	QMetaType__QVector3D             QMetaType__Type = QMetaType__Type(83)
	QMetaType__QVector4D             QMetaType__Type = QMetaType__Type(84)
	QMetaType__QQuaternion           QMetaType__Type = QMetaType__Type(85)
	QMetaType__QPolygonF             QMetaType__Type = QMetaType__Type(86)
	QMetaType__QSizePolicy           QMetaType__Type = QMetaType__Type(121)
	QMetaType__LastCoreType          QMetaType__Type = QMetaType__Type(QMetaType__QCborMap)
	QMetaType__LastGuiType           QMetaType__Type = QMetaType__Type(QMetaType__QPolygonF)
	QMetaType__User                  QMetaType__Type = QMetaType__Type(1024)
)

//go:generate stringer -type=QMetaType__TypeFlag
//QMetaType::TypeFlag
type QMetaType__TypeFlag int64

const (
	QMetaType__NeedsConstruction        QMetaType__TypeFlag = QMetaType__TypeFlag(0x1)
	QMetaType__NeedsDestruction         QMetaType__TypeFlag = QMetaType__TypeFlag(0x2)
	QMetaType__MovableType              QMetaType__TypeFlag = QMetaType__TypeFlag(0x4)
	QMetaType__PointerToQObject         QMetaType__TypeFlag = QMetaType__TypeFlag(0x8)
	QMetaType__IsEnumeration            QMetaType__TypeFlag = QMetaType__TypeFlag(0x10)
	QMetaType__SharedPointerToQObject   QMetaType__TypeFlag = QMetaType__TypeFlag(0x20)
	QMetaType__WeakPointerToQObject     QMetaType__TypeFlag = QMetaType__TypeFlag(0x40)
	QMetaType__TrackingPointerToQObject QMetaType__TypeFlag = QMetaType__TypeFlag(0x80)
	QMetaType__WasDeclaredAsMetaType    QMetaType__TypeFlag = QMetaType__TypeFlag(0x100)
	QMetaType__IsGadget                 QMetaType__TypeFlag = QMetaType__TypeFlag(0x200)
	QMetaType__PointerToGadget          QMetaType__TypeFlag = QMetaType__TypeFlag(0x400)
)

func NewQMetaType(typeId int) *QMetaType {
	tmpValue := NewQMetaTypeFromPointer(C.QMetaType_NewQMetaType(C.int(int32(typeId))))
	runtime.SetFinalizer(tmpValue, (*QMetaType).DestroyQMetaType)
	return tmpValue
}

func QMetaType_Compare(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
	return int8(C.QMetaType_QMetaType_Compare(lhs, rhs, C.int(int32(typeId)), C.int(int32(result)))) != 0
}

func (ptr *QMetaType) Compare(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
	return int8(C.QMetaType_QMetaType_Compare(lhs, rhs, C.int(int32(typeId)), C.int(int32(result)))) != 0
}

func QMetaType_Construct2(ty int, where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
	return C.QMetaType_QMetaType_Construct2(C.int(int32(ty)), where, copy)
}

func (ptr *QMetaType) Construct2(ty int, where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
	return C.QMetaType_QMetaType_Construct2(C.int(int32(ty)), where, copy)
}

func (ptr *QMetaType) Construct3(where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QMetaType_Construct3(ptr.Pointer(), where, copy)
	}
	return nil
}

func QMetaType_Convert(from unsafe.Pointer, fromTypeId int, to unsafe.Pointer, toTypeId int) bool {
	return int8(C.QMetaType_QMetaType_Convert(from, C.int(int32(fromTypeId)), to, C.int(int32(toTypeId)))) != 0
}

func (ptr *QMetaType) Convert(from unsafe.Pointer, fromTypeId int, to unsafe.Pointer, toTypeId int) bool {
	return int8(C.QMetaType_QMetaType_Convert(from, C.int(int32(fromTypeId)), to, C.int(int32(toTypeId)))) != 0
}

func QMetaType_Create(ty int, copy unsafe.Pointer) unsafe.Pointer {
	return C.QMetaType_QMetaType_Create(C.int(int32(ty)), copy)
}

func (ptr *QMetaType) Create(ty int, copy unsafe.Pointer) unsafe.Pointer {
	return C.QMetaType_QMetaType_Create(C.int(int32(ty)), copy)
}

func (ptr *QMetaType) Create2(copy unsafe.Pointer) unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QMetaType_Create2(ptr.Pointer(), copy)
	}
	return nil
}

func QMetaType_DebugStream(dbg QDebug_ITF, rhs unsafe.Pointer, typeId int) bool {
	return int8(C.QMetaType_QMetaType_DebugStream(PointerFromQDebug(dbg), rhs, C.int(int32(typeId)))) != 0
}

func (ptr *QMetaType) DebugStream(dbg QDebug_ITF, rhs unsafe.Pointer, typeId int) bool {
	return int8(C.QMetaType_QMetaType_DebugStream(PointerFromQDebug(dbg), rhs, C.int(int32(typeId)))) != 0
}

func QMetaType_Destroy(ty int, data unsafe.Pointer) {
	C.QMetaType_QMetaType_Destroy(C.int(int32(ty)), data)
}

func (ptr *QMetaType) Destroy(ty int, data unsafe.Pointer) {
	C.QMetaType_QMetaType_Destroy(C.int(int32(ty)), data)
}

func (ptr *QMetaType) Destroy2(data unsafe.Pointer) {
	if ptr.Pointer() != nil {
		C.QMetaType_Destroy2(ptr.Pointer(), data)
	}
}

func QMetaType_Destruct(ty int, where unsafe.Pointer) {
	C.QMetaType_QMetaType_Destruct(C.int(int32(ty)), where)
}

func (ptr *QMetaType) Destruct(ty int, where unsafe.Pointer) {
	C.QMetaType_QMetaType_Destruct(C.int(int32(ty)), where)
}

func (ptr *QMetaType) Destruct2(data unsafe.Pointer) {
	if ptr.Pointer() != nil {
		C.QMetaType_Destruct2(ptr.Pointer(), data)
	}
}

func QMetaType_Equals(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
	return int8(C.QMetaType_QMetaType_Equals(lhs, rhs, C.int(int32(typeId)), C.int(int32(result)))) != 0
}

func (ptr *QMetaType) Equals(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
	return int8(C.QMetaType_QMetaType_Equals(lhs, rhs, C.int(int32(typeId)), C.int(int32(result)))) != 0
}

func (ptr *QMetaType) Flags() QMetaType__TypeFlag {
	if ptr.Pointer() != nil {
		return QMetaType__TypeFlag(C.QMetaType_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaType) Id() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaType_Id(ptr.Pointer())))
	}
	return 0
}

func QMetaType_IsRegistered(ty int) bool {
	return int8(C.QMetaType_QMetaType_IsRegistered(C.int(int32(ty)))) != 0
}

func (ptr *QMetaType) IsRegistered(ty int) bool {
	return int8(C.QMetaType_QMetaType_IsRegistered(C.int(int32(ty)))) != 0
}

func (ptr *QMetaType) IsRegistered2() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaType_IsRegistered2(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMetaType) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMetaType_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func QMetaType_Load(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
	return int8(C.QMetaType_QMetaType_Load(PointerFromQDataStream(stream), C.int(int32(ty)), data)) != 0
}

func (ptr *QMetaType) Load(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
	return int8(C.QMetaType_QMetaType_Load(PointerFromQDataStream(stream), C.int(int32(ty)), data)) != 0
}

func (ptr *QMetaType) MetaObject() *QMetaObject {
	if ptr.Pointer() != nil {
		return NewQMetaObjectFromPointer(C.QMetaType_MetaObject(ptr.Pointer()))
	}
	return nil
}

func QMetaType_MetaObjectForType(ty int) *QMetaObject {
	return NewQMetaObjectFromPointer(C.QMetaType_QMetaType_MetaObjectForType(C.int(int32(ty))))
}

func (ptr *QMetaType) MetaObjectForType(ty int) *QMetaObject {
	return NewQMetaObjectFromPointer(C.QMetaType_QMetaType_MetaObjectForType(C.int(int32(ty))))
}

func QMetaType_Save(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
	return int8(C.QMetaType_QMetaType_Save(PointerFromQDataStream(stream), C.int(int32(ty)), data)) != 0
}

func (ptr *QMetaType) Save(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
	return int8(C.QMetaType_QMetaType_Save(PointerFromQDataStream(stream), C.int(int32(ty)), data)) != 0
}

func QMetaType_SizeOf(ty int) int {
	return int(int32(C.QMetaType_QMetaType_SizeOf(C.int(int32(ty)))))
}

func (ptr *QMetaType) SizeOf(ty int) int {
	return int(int32(C.QMetaType_QMetaType_SizeOf(C.int(int32(ty)))))
}

func (ptr *QMetaType) SizeOf2() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMetaType_SizeOf2(ptr.Pointer())))
	}
	return 0
}

func QMetaType_Type(typeName string) int {
	var typeNameC *C.char
	if typeName != "" {
		typeNameC = C.CString(typeName)
		defer C.free(unsafe.Pointer(typeNameC))
	}
	return int(int32(C.QMetaType_QMetaType_Type(typeNameC)))
}

func (ptr *QMetaType) Type(typeName string) int {
	var typeNameC *C.char
	if typeName != "" {
		typeNameC = C.CString(typeName)
		defer C.free(unsafe.Pointer(typeNameC))
	}
	return int(int32(C.QMetaType_QMetaType_Type(typeNameC)))
}

func QMetaType_Type2(typeName QByteArray_ITF) int {
	return int(int32(C.QMetaType_QMetaType_Type2(PointerFromQByteArray(typeName))))
}

func (ptr *QMetaType) Type2(typeName QByteArray_ITF) int {
	return int(int32(C.QMetaType_QMetaType_Type2(PointerFromQByteArray(typeName))))
}

func QMetaType_TypeFlags(ty int) QMetaType__TypeFlag {
	return QMetaType__TypeFlag(C.QMetaType_QMetaType_TypeFlags(C.int(int32(ty))))
}

func (ptr *QMetaType) TypeFlags(ty int) QMetaType__TypeFlag {
	return QMetaType__TypeFlag(C.QMetaType_QMetaType_TypeFlags(C.int(int32(ty))))
}

func QMetaType_TypeName(typeId int) string {
	return cGoUnpackString(C.QMetaType_QMetaType_TypeName(C.int(int32(typeId))))
}

func (ptr *QMetaType) TypeName(typeId int) string {
	return cGoUnpackString(C.QMetaType_QMetaType_TypeName(C.int(int32(typeId))))
}

func (ptr *QMetaType) DestroyQMetaType() {
	if ptr.Pointer() != nil {
		C.QMetaType_DestroyQMetaType(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMimeData struct {
	QObject
}

type QMimeData_ITF interface {
	QObject_ITF
	QMimeData_PTR() *QMimeData
}

func (ptr *QMimeData) QMimeData_PTR() *QMimeData {
	return ptr
}

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

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

func PointerFromQMimeData(ptr QMimeData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMimeData_PTR().Pointer()
	}
	return nil
}

func NewQMimeDataFromPointer(ptr unsafe.Pointer) (n *QMimeData) {
	n = new(QMimeData)
	n.SetPointer(ptr)
	return
}
func NewQMimeData() *QMimeData {
	tmpValue := NewQMimeDataFromPointer(C.QMimeData_NewQMimeData())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QMimeData) Clear() {
	if ptr.Pointer() != nil {
		C.QMimeData_Clear(ptr.Pointer())
	}
}

func (ptr *QMimeData) ColorData() *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QMimeData_ColorData(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeData) Data(mimeType string) *QByteArray {
	if ptr.Pointer() != nil {
		var mimeTypeC *C.char
		if mimeType != "" {
			mimeTypeC = C.CString(mimeType)
			defer C.free(unsafe.Pointer(mimeTypeC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QMimeData_Data(ptr.Pointer(), C.struct_QtCore_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

//export callbackQMimeData_Formats
func callbackQMimeData_Formats(ptr unsafe.Pointer) C.struct_QtCore_PackedString {
	if signal := qt.GetSignal(ptr, "formats"); signal != nil {
		tempVal := (*(*func() []string)(signal))()
		return C.struct_QtCore_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
	}
	tempVal := NewQMimeDataFromPointer(ptr).FormatsDefault()
	return C.struct_QtCore_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
}

func (ptr *QMimeData) ConnectFormats(f func() []string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "formats"); signal != nil {
			f := func() []string {
				(*(*func() []string)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "formats", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "formats", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMimeData) DisconnectFormats() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "formats")
	}
}

func (ptr *QMimeData) Formats() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QMimeData_Formats(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QMimeData) FormatsDefault() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QMimeData_FormatsDefault(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QMimeData) HasColor() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMimeData_HasColor(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQMimeData_HasFormat
func callbackQMimeData_HasFormat(ptr unsafe.Pointer, mimeType C.struct_QtCore_PackedString) C.char {
	if signal := qt.GetSignal(ptr, "hasFormat"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(string) bool)(signal))(cGoUnpackString(mimeType)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQMimeDataFromPointer(ptr).HasFormatDefault(cGoUnpackString(mimeType)))))
}

func (ptr *QMimeData) ConnectHasFormat(f func(mimeType string) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hasFormat"); signal != nil {
			f := func(mimeType string) bool {
				(*(*func(string) bool)(signal))(mimeType)
				return f(mimeType)
			}
			qt.ConnectSignal(ptr.Pointer(), "hasFormat", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hasFormat", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMimeData) DisconnectHasFormat() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hasFormat")
	}
}

func (ptr *QMimeData) HasFormat(mimeType string) bool {
	if ptr.Pointer() != nil {
		var mimeTypeC *C.char
		if mimeType != "" {
			mimeTypeC = C.CString(mimeType)
			defer C.free(unsafe.Pointer(mimeTypeC))
		}
		return int8(C.QMimeData_HasFormat(ptr.Pointer(), C.struct_QtCore_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))})) != 0
	}
	return false
}

func (ptr *QMimeData) HasFormatDefault(mimeType string) bool {
	if ptr.Pointer() != nil {
		var mimeTypeC *C.char
		if mimeType != "" {
			mimeTypeC = C.CString(mimeType)
			defer C.free(unsafe.Pointer(mimeTypeC))
		}
		return int8(C.QMimeData_HasFormatDefault(ptr.Pointer(), C.struct_QtCore_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))})) != 0
	}
	return false
}

func (ptr *QMimeData) HasHtml() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMimeData_HasHtml(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMimeData) HasImage() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMimeData_HasImage(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMimeData) HasText() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMimeData_HasText(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMimeData) HasUrls() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMimeData_HasUrls(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMimeData) Html() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMimeData_Html(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeData) ImageData() *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QMimeData_ImageData(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeData) RemoveFormat(mimeType string) {
	if ptr.Pointer() != nil {
		var mimeTypeC *C.char
		if mimeType != "" {
			mimeTypeC = C.CString(mimeType)
			defer C.free(unsafe.Pointer(mimeTypeC))
		}
		C.QMimeData_RemoveFormat(ptr.Pointer(), C.struct_QtCore_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))})
	}
}

//export callbackQMimeData_RetrieveData
func callbackQMimeData_RetrieveData(ptr unsafe.Pointer, mimeType C.struct_QtCore_PackedString, ty C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "retrieveData"); signal != nil {
		return PointerFromQVariant((*(*func(string, QVariant__Type) *QVariant)(signal))(cGoUnpackString(mimeType), QVariant__Type(ty)))
	}

	return PointerFromQVariant(NewQMimeDataFromPointer(ptr).RetrieveDataDefault(cGoUnpackString(mimeType), QVariant__Type(ty)))
}

func (ptr *QMimeData) ConnectRetrieveData(f func(mimeType string, ty QVariant__Type) *QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "retrieveData"); signal != nil {
			f := func(mimeType string, ty QVariant__Type) *QVariant {
				(*(*func(string, QVariant__Type) *QVariant)(signal))(mimeType, ty)
				return f(mimeType, ty)
			}
			qt.ConnectSignal(ptr.Pointer(), "retrieveData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "retrieveData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMimeData) DisconnectRetrieveData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "retrieveData")
	}
}

func (ptr *QMimeData) RetrieveData(mimeType string, ty QVariant__Type) *QVariant {
	if ptr.Pointer() != nil {
		var mimeTypeC *C.char
		if mimeType != "" {
			mimeTypeC = C.CString(mimeType)
			defer C.free(unsafe.Pointer(mimeTypeC))
		}
		tmpValue := NewQVariantFromPointer(C.QMimeData_RetrieveData(ptr.Pointer(), C.struct_QtCore_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}, C.longlong(ty)))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeData) RetrieveDataDefault(mimeType string, ty QVariant__Type) *QVariant {
	if ptr.Pointer() != nil {
		var mimeTypeC *C.char
		if mimeType != "" {
			mimeTypeC = C.CString(mimeType)
			defer C.free(unsafe.Pointer(mimeTypeC))
		}
		tmpValue := NewQVariantFromPointer(C.QMimeData_RetrieveDataDefault(ptr.Pointer(), C.struct_QtCore_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}, C.longlong(ty)))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeData) SetColorData(color QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QMimeData_SetColorData(ptr.Pointer(), PointerFromQVariant(color))
	}
}

func (ptr *QMimeData) SetData(mimeType string, data QByteArray_ITF) {
	if ptr.Pointer() != nil {
		var mimeTypeC *C.char
		if mimeType != "" {
			mimeTypeC = C.CString(mimeType)
			defer C.free(unsafe.Pointer(mimeTypeC))
		}
		C.QMimeData_SetData(ptr.Pointer(), C.struct_QtCore_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}, PointerFromQByteArray(data))
	}
}

func (ptr *QMimeData) SetHtml(html string) {
	if ptr.Pointer() != nil {
		var htmlC *C.char
		if html != "" {
			htmlC = C.CString(html)
			defer C.free(unsafe.Pointer(htmlC))
		}
		C.QMimeData_SetHtml(ptr.Pointer(), C.struct_QtCore_PackedString{data: htmlC, len: C.longlong(len(html))})
	}
}

func (ptr *QMimeData) SetImageData(image QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QMimeData_SetImageData(ptr.Pointer(), PointerFromQVariant(image))
	}
}

func (ptr *QMimeData) SetText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QMimeData_SetText(ptr.Pointer(), C.struct_QtCore_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QMimeData) SetUrls(urls []*QUrl) {
	if ptr.Pointer() != nil {
		C.QMimeData_SetUrls(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQMimeDataFromPointer(NewQMimeDataFromPointer(nil).__setUrls_urls_newList())
			for _, v := range urls {
				tmpList.__setUrls_urls_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QMimeData) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMimeData_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeData) Urls() []*QUrl {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QUrl {
			out := make([]*QUrl, int(l.len))
			tmpList := NewQMimeDataFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__urls_atList(i)
			}
			return out
		}(C.QMimeData_Urls(ptr.Pointer()))
	}
	return make([]*QUrl, 0)
}

//export callbackQMimeData_DestroyQMimeData
func callbackQMimeData_DestroyQMimeData(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QMimeData"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMimeDataFromPointer(ptr).DestroyQMimeDataDefault()
	}
}

func (ptr *QMimeData) ConnectDestroyQMimeData(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QMimeData"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMimeData) DisconnectDestroyQMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QMimeData")
	}
}

func (ptr *QMimeData) DestroyQMimeData() {
	if ptr.Pointer() != nil {
		C.QMimeData_DestroyQMimeData(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMimeData) DestroyQMimeDataDefault() {
	if ptr.Pointer() != nil {
		C.QMimeData_DestroyQMimeDataDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMimeData) __setUrls_urls_atList(i int) *QUrl {
	if ptr.Pointer() != nil {
		tmpValue := NewQUrlFromPointer(C.QMimeData___setUrls_urls_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeData) __setUrls_urls_setList(i QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QMimeData___setUrls_urls_setList(ptr.Pointer(), PointerFromQUrl(i))
	}
}

func (ptr *QMimeData) __setUrls_urls_newList() unsafe.Pointer {
	return C.QMimeData___setUrls_urls_newList(ptr.Pointer())
}

func (ptr *QMimeData) __urls_atList(i int) *QUrl {
	if ptr.Pointer() != nil {
		tmpValue := NewQUrlFromPointer(C.QMimeData___urls_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeData) __urls_setList(i QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QMimeData___urls_setList(ptr.Pointer(), PointerFromQUrl(i))
	}
}

func (ptr *QMimeData) __urls_newList() unsafe.Pointer {
	return C.QMimeData___urls_newList(ptr.Pointer())
}

type QMimeDatabase struct {
	ptr unsafe.Pointer
}

type QMimeDatabase_ITF interface {
	QMimeDatabase_PTR() *QMimeDatabase
}

func (ptr *QMimeDatabase) QMimeDatabase_PTR() *QMimeDatabase {
	return ptr
}

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

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

func PointerFromQMimeDatabase(ptr QMimeDatabase_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMimeDatabase_PTR().Pointer()
	}
	return nil
}

func NewQMimeDatabaseFromPointer(ptr unsafe.Pointer) (n *QMimeDatabase) {
	n = new(QMimeDatabase)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QMimeDatabase__MatchMode
//QMimeDatabase::MatchMode
type QMimeDatabase__MatchMode int64

const (
	QMimeDatabase__MatchDefault   QMimeDatabase__MatchMode = QMimeDatabase__MatchMode(0x0)
	QMimeDatabase__MatchExtension QMimeDatabase__MatchMode = QMimeDatabase__MatchMode(0x1)
	QMimeDatabase__MatchContent   QMimeDatabase__MatchMode = QMimeDatabase__MatchMode(0x2)
)

func NewQMimeDatabase2() *QMimeDatabase {
	tmpValue := NewQMimeDatabaseFromPointer(C.QMimeDatabase_NewQMimeDatabase2())
	runtime.SetFinalizer(tmpValue, (*QMimeDatabase).DestroyQMimeDatabase)
	return tmpValue
}

func (ptr *QMimeDatabase) AllMimeTypes() []*QMimeType {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QMimeType {
			out := make([]*QMimeType, int(l.len))
			tmpList := NewQMimeDatabaseFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__allMimeTypes_atList(i)
			}
			return out
		}(C.QMimeDatabase_AllMimeTypes(ptr.Pointer()))
	}
	return make([]*QMimeType, 0)
}

func (ptr *QMimeDatabase) MimeTypeForData(data QByteArray_ITF) *QMimeType {
	if ptr.Pointer() != nil {
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForData(ptr.Pointer(), PointerFromQByteArray(data)))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForData2(device QIODevice_ITF) *QMimeType {
	if ptr.Pointer() != nil {
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForData2(ptr.Pointer(), PointerFromQIODevice(device)))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForFile(fileInfo QFileInfo_ITF, mode QMimeDatabase__MatchMode) *QMimeType {
	if ptr.Pointer() != nil {
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFile(ptr.Pointer(), PointerFromQFileInfo(fileInfo), C.longlong(mode)))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForFile2(fileName string, mode QMimeDatabase__MatchMode) *QMimeType {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFile2(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(mode)))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForFileNameAndData(fileName string, device QIODevice_ITF) *QMimeType {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFileNameAndData(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, PointerFromQIODevice(device)))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForFileNameAndData2(fileName string, data QByteArray_ITF) *QMimeType {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFileNameAndData2(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, PointerFromQByteArray(data)))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForName(nameOrAlias string) *QMimeType {
	if ptr.Pointer() != nil {
		var nameOrAliasC *C.char
		if nameOrAlias != "" {
			nameOrAliasC = C.CString(nameOrAlias)
			defer C.free(unsafe.Pointer(nameOrAliasC))
		}
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForName(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameOrAliasC, len: C.longlong(len(nameOrAlias))}))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForUrl(url QUrl_ITF) *QMimeType {
	if ptr.Pointer() != nil {
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForUrl(ptr.Pointer(), PointerFromQUrl(url)))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypesForFileName(fileName string) []*QMimeType {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		return func(l C.struct_QtCore_PackedList) []*QMimeType {
			out := make([]*QMimeType, int(l.len))
			tmpList := NewQMimeDatabaseFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__mimeTypesForFileName_atList(i)
			}
			return out
		}(C.QMimeDatabase_MimeTypesForFileName(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	}
	return make([]*QMimeType, 0)
}

func (ptr *QMimeDatabase) SuffixForFileName(fileName string) string {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		return cGoUnpackString(C.QMimeDatabase_SuffixForFileName(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	}
	return ""
}

func (ptr *QMimeDatabase) DestroyQMimeDatabase() {
	if ptr.Pointer() != nil {
		C.QMimeDatabase_DestroyQMimeDatabase(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMimeDatabase) __allMimeTypes_atList(i int) *QMimeType {
	if ptr.Pointer() != nil {
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase___allMimeTypes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) __allMimeTypes_setList(i QMimeType_ITF) {
	if ptr.Pointer() != nil {
		C.QMimeDatabase___allMimeTypes_setList(ptr.Pointer(), PointerFromQMimeType(i))
	}
}

func (ptr *QMimeDatabase) __allMimeTypes_newList() unsafe.Pointer {
	return C.QMimeDatabase___allMimeTypes_newList(ptr.Pointer())
}

func (ptr *QMimeDatabase) __mimeTypesForFileName_atList(i int) *QMimeType {
	if ptr.Pointer() != nil {
		tmpValue := NewQMimeTypeFromPointer(C.QMimeDatabase___mimeTypesForFileName_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
		return tmpValue
	}
	return nil
}

func (ptr *QMimeDatabase) __mimeTypesForFileName_setList(i QMimeType_ITF) {
	if ptr.Pointer() != nil {
		C.QMimeDatabase___mimeTypesForFileName_setList(ptr.Pointer(), PointerFromQMimeType(i))
	}
}

func (ptr *QMimeDatabase) __mimeTypesForFileName_newList() unsafe.Pointer {
	return C.QMimeDatabase___mimeTypesForFileName_newList(ptr.Pointer())
}

type QMimeType struct {
	ptr unsafe.Pointer
}

type QMimeType_ITF interface {
	QMimeType_PTR() *QMimeType
}

func (ptr *QMimeType) QMimeType_PTR() *QMimeType {
	return ptr
}

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

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

func PointerFromQMimeType(ptr QMimeType_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMimeType_PTR().Pointer()
	}
	return nil
}

func NewQMimeTypeFromPointer(ptr unsafe.Pointer) (n *QMimeType) {
	n = new(QMimeType)
	n.SetPointer(ptr)
	return
}
func NewQMimeType() *QMimeType {
	tmpValue := NewQMimeTypeFromPointer(C.QMimeType_NewQMimeType())
	runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
	return tmpValue
}

func NewQMimeType2(other QMimeType_ITF) *QMimeType {
	tmpValue := NewQMimeTypeFromPointer(C.QMimeType_NewQMimeType2(PointerFromQMimeType(other)))
	runtime.SetFinalizer(tmpValue, (*QMimeType).DestroyQMimeType)
	return tmpValue
}

func (ptr *QMimeType) Aliases() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QMimeType_Aliases(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QMimeType) AllAncestors() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QMimeType_AllAncestors(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QMimeType) Comment() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMimeType_Comment(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) FilterString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMimeType_FilterString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) GenericIconName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMimeType_GenericIconName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) GlobPatterns() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QMimeType_GlobPatterns(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QMimeType) IconName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMimeType_IconName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) Inherits(mimeTypeName string) bool {
	if ptr.Pointer() != nil {
		var mimeTypeNameC *C.char
		if mimeTypeName != "" {
			mimeTypeNameC = C.CString(mimeTypeName)
			defer C.free(unsafe.Pointer(mimeTypeNameC))
		}
		return int8(C.QMimeType_Inherits(ptr.Pointer(), C.struct_QtCore_PackedString{data: mimeTypeNameC, len: C.longlong(len(mimeTypeName))})) != 0
	}
	return false
}

func (ptr *QMimeType) IsDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMimeType_IsDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMimeType) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMimeType_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMimeType) Name() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMimeType_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) ParentMimeTypes() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QMimeType_ParentMimeTypes(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QMimeType) PreferredSuffix() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMimeType_PreferredSuffix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) Suffixes() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QMimeType_Suffixes(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QMimeType) Swap(other QMimeType_ITF) {
	if ptr.Pointer() != nil {
		C.QMimeType_Swap(ptr.Pointer(), PointerFromQMimeType(other))
	}
}

func (ptr *QMimeType) DestroyQMimeType() {
	if ptr.Pointer() != nil {
		C.QMimeType_DestroyQMimeType(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QModelIndex struct {
	ptr unsafe.Pointer
}

type QModelIndex_ITF interface {
	QModelIndex_PTR() *QModelIndex
}

func (ptr *QModelIndex) QModelIndex_PTR() *QModelIndex {
	return ptr
}

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

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

func PointerFromQModelIndex(ptr QModelIndex_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QModelIndex_PTR().Pointer()
	}
	return nil
}

func NewQModelIndexFromPointer(ptr unsafe.Pointer) (n *QModelIndex) {
	n = new(QModelIndex)
	n.SetPointer(ptr)
	return
}

func (ptr *QModelIndex) DestroyQModelIndex() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQModelIndex() *QModelIndex {
	tmpValue := NewQModelIndexFromPointer(C.QModelIndex_NewQModelIndex())
	runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
	return tmpValue
}

func (ptr *QModelIndex) Column() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QModelIndex_Column(ptr.Pointer())))
	}
	return 0
}

func (ptr *QModelIndex) Data(role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QModelIndex_Data(ptr.Pointer(), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QModelIndex) Flags() Qt__ItemFlag {
	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QModelIndex_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QModelIndex) InternalId() uintptr {
	if ptr.Pointer() != nil {
		return uintptr(C.QModelIndex_InternalId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QModelIndex) InternalPointer() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QModelIndex_InternalPointer(ptr.Pointer())
	}
	return nil
}

func (ptr *QModelIndex) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QModelIndex_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QModelIndex) Model() *QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemModelFromPointer(C.QModelIndex_Model(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QModelIndex) Parent() *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QModelIndex_Parent(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QModelIndex) Row() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QModelIndex_Row(ptr.Pointer())))
	}
	return 0
}

func (ptr *QModelIndex) Sibling(row int, column int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QModelIndex_Sibling(ptr.Pointer(), C.int(int32(row)), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QModelIndex) SiblingAtColumn(column int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QModelIndex_SiblingAtColumn(ptr.Pointer(), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QModelIndex) SiblingAtRow(row int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QModelIndex_SiblingAtRow(ptr.Pointer(), C.int(int32(row))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

type QMultiHash struct {
	QHash
}

type QMultiHash_ITF interface {
	QHash_ITF
	QMultiHash_PTR() *QMultiHash
}

func (ptr *QMultiHash) QMultiHash_PTR() *QMultiHash {
	return ptr
}

func (ptr *QMultiHash) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QHash_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQMultiHash(ptr QMultiHash_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMultiHash_PTR().Pointer()
	}
	return nil
}

func NewQMultiHashFromPointer(ptr unsafe.Pointer) (n *QMultiHash) {
	n = new(QMultiHash)
	n.SetPointer(ptr)
	return
}

func (ptr *QMultiHash) DestroyQMultiHash() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMultiMap struct {
	QMap
}

type QMultiMap_ITF interface {
	QMap_ITF
	QMultiMap_PTR() *QMultiMap
}

func (ptr *QMultiMap) QMultiMap_PTR() *QMultiMap {
	return ptr
}

func (ptr *QMultiMap) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QMap_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQMultiMap(ptr QMultiMap_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMultiMap_PTR().Pointer()
	}
	return nil
}

func NewQMultiMapFromPointer(ptr unsafe.Pointer) (n *QMultiMap) {
	n = new(QMultiMap)
	n.SetPointer(ptr)
	return
}

func (ptr *QMultiMap) DestroyQMultiMap() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMutableHashIterator struct {
	ptr unsafe.Pointer
}

type QMutableHashIterator_ITF interface {
	QMutableHashIterator_PTR() *QMutableHashIterator
}

func (ptr *QMutableHashIterator) QMutableHashIterator_PTR() *QMutableHashIterator {
	return ptr
}

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

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

func PointerFromQMutableHashIterator(ptr QMutableHashIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableHashIterator_PTR().Pointer()
	}
	return nil
}

func NewQMutableHashIteratorFromPointer(ptr unsafe.Pointer) (n *QMutableHashIterator) {
	n = new(QMutableHashIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QMutableHashIterator) DestroyQMutableHashIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMutableLinkedListIterator struct {
	ptr unsafe.Pointer
}

type QMutableLinkedListIterator_ITF interface {
	QMutableLinkedListIterator_PTR() *QMutableLinkedListIterator
}

func (ptr *QMutableLinkedListIterator) QMutableLinkedListIterator_PTR() *QMutableLinkedListIterator {
	return ptr
}

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

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

func PointerFromQMutableLinkedListIterator(ptr QMutableLinkedListIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableLinkedListIterator_PTR().Pointer()
	}
	return nil
}

func NewQMutableLinkedListIteratorFromPointer(ptr unsafe.Pointer) (n *QMutableLinkedListIterator) {
	n = new(QMutableLinkedListIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QMutableLinkedListIterator) DestroyQMutableLinkedListIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMutableListIterator struct {
	ptr unsafe.Pointer
}

type QMutableListIterator_ITF interface {
	QMutableListIterator_PTR() *QMutableListIterator
}

func (ptr *QMutableListIterator) QMutableListIterator_PTR() *QMutableListIterator {
	return ptr
}

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

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

func PointerFromQMutableListIterator(ptr QMutableListIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableListIterator_PTR().Pointer()
	}
	return nil
}

func NewQMutableListIteratorFromPointer(ptr unsafe.Pointer) (n *QMutableListIterator) {
	n = new(QMutableListIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QMutableListIterator) DestroyQMutableListIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMutableMapIterator struct {
	ptr unsafe.Pointer
}

type QMutableMapIterator_ITF interface {
	QMutableMapIterator_PTR() *QMutableMapIterator
}

func (ptr *QMutableMapIterator) QMutableMapIterator_PTR() *QMutableMapIterator {
	return ptr
}

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

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

func PointerFromQMutableMapIterator(ptr QMutableMapIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableMapIterator_PTR().Pointer()
	}
	return nil
}

func NewQMutableMapIteratorFromPointer(ptr unsafe.Pointer) (n *QMutableMapIterator) {
	n = new(QMutableMapIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QMutableMapIterator) DestroyQMutableMapIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMutableSetIterator struct {
	ptr unsafe.Pointer
}

type QMutableSetIterator_ITF interface {
	QMutableSetIterator_PTR() *QMutableSetIterator
}

func (ptr *QMutableSetIterator) QMutableSetIterator_PTR() *QMutableSetIterator {
	return ptr
}

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

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

func PointerFromQMutableSetIterator(ptr QMutableSetIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableSetIterator_PTR().Pointer()
	}
	return nil
}

func NewQMutableSetIteratorFromPointer(ptr unsafe.Pointer) (n *QMutableSetIterator) {
	n = new(QMutableSetIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QMutableSetIterator) DestroyQMutableSetIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMutableVectorIterator struct {
	ptr unsafe.Pointer
}

type QMutableVectorIterator_ITF interface {
	QMutableVectorIterator_PTR() *QMutableVectorIterator
}

func (ptr *QMutableVectorIterator) QMutableVectorIterator_PTR() *QMutableVectorIterator {
	return ptr
}

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

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

func PointerFromQMutableVectorIterator(ptr QMutableVectorIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableVectorIterator_PTR().Pointer()
	}
	return nil
}

func NewQMutableVectorIteratorFromPointer(ptr unsafe.Pointer) (n *QMutableVectorIterator) {
	n = new(QMutableVectorIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QMutableVectorIterator) DestroyQMutableVectorIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMutex struct {
	QBasicMutex
}

type QMutex_ITF interface {
	QBasicMutex_ITF
	QMutex_PTR() *QMutex
}

func (ptr *QMutex) QMutex_PTR() *QMutex {
	return ptr
}

func (ptr *QMutex) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QBasicMutex_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQMutex(ptr QMutex_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutex_PTR().Pointer()
	}
	return nil
}

func NewQMutexFromPointer(ptr unsafe.Pointer) (n *QMutex) {
	n = new(QMutex)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QMutex__RecursionMode
//QMutex::RecursionMode
type QMutex__RecursionMode int64

const (
	QMutex__NonRecursive QMutex__RecursionMode = QMutex__RecursionMode(0)
	QMutex__Recursive    QMutex__RecursionMode = QMutex__RecursionMode(1)
)

func NewQMutex(mode QMutex__RecursionMode) *QMutex {
	tmpValue := NewQMutexFromPointer(C.QMutex_NewQMutex(C.longlong(mode)))
	runtime.SetFinalizer(tmpValue, (*QMutex).DestroyQMutex)
	return tmpValue
}

func (ptr *QMutex) Lock() {
	if ptr.Pointer() != nil {
		C.QMutex_Lock(ptr.Pointer())
	}
}

func (ptr *QMutex) TryLock(timeout int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMutex_TryLock(ptr.Pointer(), C.int(int32(timeout)))) != 0
	}
	return false
}

func (ptr *QMutex) Try_lock() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMutex_Try_lock(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMutex) Unlock() {
	if ptr.Pointer() != nil {
		C.QMutex_Unlock(ptr.Pointer())
	}
}

func (ptr *QMutex) DestroyQMutex() {
	if ptr.Pointer() != nil {
		C.QMutex_DestroyQMutex(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QMutexLocker struct {
	ptr unsafe.Pointer
}

type QMutexLocker_ITF interface {
	QMutexLocker_PTR() *QMutexLocker
}

func (ptr *QMutexLocker) QMutexLocker_PTR() *QMutexLocker {
	return ptr
}

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

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

func PointerFromQMutexLocker(ptr QMutexLocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutexLocker_PTR().Pointer()
	}
	return nil
}

func NewQMutexLockerFromPointer(ptr unsafe.Pointer) (n *QMutexLocker) {
	n = new(QMutexLocker)
	n.SetPointer(ptr)
	return
}
func NewQMutexLocker(mutex QMutex_ITF) *QMutexLocker {
	tmpValue := NewQMutexLockerFromPointer(C.QMutexLocker_NewQMutexLocker(PointerFromQMutex(mutex)))
	runtime.SetFinalizer(tmpValue, (*QMutexLocker).DestroyQMutexLocker)
	return tmpValue
}

func (ptr *QMutexLocker) Mutex() *QMutex {
	if ptr.Pointer() != nil {
		return NewQMutexFromPointer(C.QMutexLocker_Mutex(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMutexLocker) Relock() {
	if ptr.Pointer() != nil {
		C.QMutexLocker_Relock(ptr.Pointer())
	}
}

func (ptr *QMutexLocker) Unlock() {
	if ptr.Pointer() != nil {
		C.QMutexLocker_Unlock(ptr.Pointer())
	}
}

func (ptr *QMutexLocker) DestroyQMutexLocker() {
	if ptr.Pointer() != nil {
		C.QMutexLocker_DestroyQMutexLocker(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QNoDebug struct {
	ptr unsafe.Pointer
}

type QNoDebug_ITF interface {
	QNoDebug_PTR() *QNoDebug
}

func (ptr *QNoDebug) QNoDebug_PTR() *QNoDebug {
	return ptr
}

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

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

func PointerFromQNoDebug(ptr QNoDebug_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QNoDebug_PTR().Pointer()
	}
	return nil
}

func NewQNoDebugFromPointer(ptr unsafe.Pointer) (n *QNoDebug) {
	n = new(QNoDebug)
	n.SetPointer(ptr)
	return
}

func (ptr *QNoDebug) DestroyQNoDebug() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QObject struct {
	ptr unsafe.Pointer
}

type QObject_ITF interface {
	QObject_PTR() *QObject
}

func (ptr *QObject) QObject_PTR() *QObject {
	return ptr
}

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

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

func PointerFromQObject(ptr QObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func NewQObjectFromPointer(ptr unsafe.Pointer) (n *QObject) {
	n = new(QObject)
	n.SetPointer(ptr)
	return
}

func (o *QObject) ConnectSignal(f, a interface{}, t Qt__ConnectionType) {
	fn := strings.TrimSuffix(strings.Split(runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name(), ".Connect")[1], "-fm")
	qt.RegisterConnectionType(o.Pointer(), strings.ToLower(fn[:1])+fn[1:], int64(t))
	reflect.ValueOf(f).Call([]reflect.Value{reflect.ValueOf(a)})
}

func NewQObject(parent QObject_ITF) *QObject {
	tmpValue := NewQObjectFromPointer(C.QObject_NewQObject(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QObject) BlockSignals(block bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QObject_BlockSignals(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(block))))) != 0
	}
	return false
}

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

func (ptr *QObject) ConnectChildEvent(f func(event *QChildEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "childEvent"); signal != nil {
			f := func(event *QChildEvent) {
				(*(*func(*QChildEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "childEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "childEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectChildEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "childEvent")
	}
}

func (ptr *QObject) ChildEvent(event QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QObject) ChildEventDefault(event QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QObject) Children() []*QObject {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QObject {
			out := make([]*QObject, int(l.len))
			tmpList := NewQObjectFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__children_atList(i)
			}
			return out
		}(C.QObject_Children(ptr.Pointer()))
	}
	return make([]*QObject, 0)
}

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

func (ptr *QObject) ConnectConnectNotify(f func(sign *QMetaMethod)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "connectNotify"); signal != nil {
			f := func(sign *QMetaMethod) {
				(*(*func(*QMetaMethod))(signal))(sign)
				f(sign)
			}
			qt.ConnectSignal(ptr.Pointer(), "connectNotify", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "connectNotify", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectConnectNotify() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "connectNotify")
	}
}

func (ptr *QObject) ConnectNotify(sign QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_ConnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
	}
}

func (ptr *QObject) ConnectNotifyDefault(sign QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_ConnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
	}
}

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

func (ptr *QObject) ConnectCustomEvent(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "customEvent"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "customEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "customEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectCustomEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "customEvent")
	}
}

func (ptr *QObject) CustomEvent(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QObject) CustomEventDefault(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

//export callbackQObject_DeleteLater
func callbackQObject_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQObjectFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QObject) ConnectDeleteLater(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "deleteLater"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "deleteLater", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "deleteLater", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectDeleteLater() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "deleteLater")
	}
}

func (ptr *QObject) DeleteLater() {
	if ptr.Pointer() != nil {
		C.QObject_DeleteLater(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QObject) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QObject_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

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

}

func (ptr *QObject) ConnectDestroyed(f func(obj *QObject)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "destroyed") {
			C.QObject_ConnectDestroyed(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "destroyed")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "destroyed"); signal != nil {
			f := func(obj *QObject) {
				(*(*func(*QObject))(signal))(obj)
				f(obj)
			}
			qt.ConnectSignal(ptr.Pointer(), "destroyed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "destroyed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectDestroyed() {
	if ptr.Pointer() != nil {
		C.QObject_DisconnectDestroyed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "destroyed")
	}
}

func (ptr *QObject) Destroyed(obj QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_Destroyed(ptr.Pointer(), PointerFromQObject(obj))
	}
}

func QObject_Disconnect(sender QObject_ITF, sign string, receiver QObject_ITF, method string) bool {
	var signC *C.char
	if sign != "" {
		signC = C.CString(sign)
		defer C.free(unsafe.Pointer(signC))
	}
	var methodC *C.char
	if method != "" {
		methodC = C.CString(method)
		defer C.free(unsafe.Pointer(methodC))
	}
	return int8(C.QObject_QObject_Disconnect(PointerFromQObject(sender), signC, PointerFromQObject(receiver), methodC)) != 0
}

func (ptr *QObject) Disconnect(sender QObject_ITF, sign string, receiver QObject_ITF, method string) bool {
	var signC *C.char
	if sign != "" {
		signC = C.CString(sign)
		defer C.free(unsafe.Pointer(signC))
	}
	var methodC *C.char
	if method != "" {
		methodC = C.CString(method)
		defer C.free(unsafe.Pointer(methodC))
	}
	return int8(C.QObject_QObject_Disconnect(PointerFromQObject(sender), signC, PointerFromQObject(receiver), methodC)) != 0
}

func QObject_Disconnect2(sender QObject_ITF, sign QMetaMethod_ITF, receiver QObject_ITF, method QMetaMethod_ITF) bool {
	return int8(C.QObject_QObject_Disconnect2(PointerFromQObject(sender), PointerFromQMetaMethod(sign), PointerFromQObject(receiver), PointerFromQMetaMethod(method))) != 0
}

func (ptr *QObject) Disconnect2(sender QObject_ITF, sign QMetaMethod_ITF, receiver QObject_ITF, method QMetaMethod_ITF) bool {
	return int8(C.QObject_QObject_Disconnect2(PointerFromQObject(sender), PointerFromQMetaMethod(sign), PointerFromQObject(receiver), PointerFromQMetaMethod(method))) != 0
}

func (ptr *QObject) Disconnect3(sign string, receiver QObject_ITF, method string) bool {
	if ptr.Pointer() != nil {
		var signC *C.char
		if sign != "" {
			signC = C.CString(sign)
			defer C.free(unsafe.Pointer(signC))
		}
		var methodC *C.char
		if method != "" {
			methodC = C.CString(method)
			defer C.free(unsafe.Pointer(methodC))
		}
		return int8(C.QObject_Disconnect3(ptr.Pointer(), signC, PointerFromQObject(receiver), methodC)) != 0
	}
	return false
}

func (ptr *QObject) Disconnect4(receiver QObject_ITF, method string) bool {
	if ptr.Pointer() != nil {
		var methodC *C.char
		if method != "" {
			methodC = C.CString(method)
			defer C.free(unsafe.Pointer(methodC))
		}
		return int8(C.QObject_Disconnect4(ptr.Pointer(), PointerFromQObject(receiver), methodC)) != 0
	}
	return false
}

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

func (ptr *QObject) ConnectDisconnectNotify(f func(sign *QMetaMethod)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "disconnectNotify"); signal != nil {
			f := func(sign *QMetaMethod) {
				(*(*func(*QMetaMethod))(signal))(sign)
				f(sign)
			}
			qt.ConnectSignal(ptr.Pointer(), "disconnectNotify", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "disconnectNotify", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectDisconnectNotify() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "disconnectNotify")
	}
}

func (ptr *QObject) DisconnectNotify(sign QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_DisconnectNotify(ptr.Pointer(), PointerFromQMetaMethod(sign))
	}
}

func (ptr *QObject) DisconnectNotifyDefault(sign QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_DisconnectNotifyDefault(ptr.Pointer(), PointerFromQMetaMethod(sign))
	}
}

func (ptr *QObject) DumpObjectInfo() {
	if ptr.Pointer() != nil {
		C.QObject_DumpObjectInfo(ptr.Pointer())
	}
}

func (ptr *QObject) DumpObjectTree() {
	if ptr.Pointer() != nil {
		C.QObject_DumpObjectTree(ptr.Pointer())
	}
}

func (ptr *QObject) DynamicPropertyNames() []*QByteArray {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QByteArray {
			out := make([]*QByteArray, int(l.len))
			tmpList := NewQObjectFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__dynamicPropertyNames_atList(i)
			}
			return out
		}(C.QObject_DynamicPropertyNames(ptr.Pointer()))
	}
	return make([]*QByteArray, 0)
}

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

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

func (ptr *QObject) ConnectEvent(f func(e *QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "event"); signal != nil {
			f := func(e *QEvent) bool {
				(*(*func(*QEvent) bool)(signal))(e)
				return f(e)
			}
			qt.ConnectSignal(ptr.Pointer(), "event", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "event", unsafe.Pointer(&f))
		}
	}
}

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

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

func (ptr *QObject) Event(e QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QObject_Event(ptr.Pointer(), PointerFromQEvent(e))) != 0
	}
	return false
}

func (ptr *QObject) EventDefault(e QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QObject_EventDefault(ptr.Pointer(), PointerFromQEvent(e))) != 0
	}
	return false
}

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

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

func (ptr *QObject) ConnectEventFilter(f func(watched *QObject, event *QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "eventFilter"); signal != nil {
			f := func(watched *QObject, event *QEvent) bool {
				(*(*func(*QObject, *QEvent) bool)(signal))(watched, event)
				return f(watched, event)
			}
			qt.ConnectSignal(ptr.Pointer(), "eventFilter", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "eventFilter", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectEventFilter() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "eventFilter")
	}
}

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

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

func (ptr *QObject) FindChild(name string, options Qt__FindChildOption) *QObject {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		tmpValue := NewQObjectFromPointer(C.QObject_FindChild(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.longlong(options)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObject) FindChildren(name string, options Qt__FindChildOption) []*QObject {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return func(l C.struct_QtCore_PackedList) []*QObject {
			out := make([]*QObject, int(l.len))
			tmpList := NewQObjectFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__findChildren_atList(i)
			}
			return out
		}(C.QObject_FindChildren(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.longlong(options)))
	}
	return make([]*QObject, 0)
}

func (ptr *QObject) FindChildren3(re QRegularExpression_ITF, options Qt__FindChildOption) []*QObject {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QObject {
			out := make([]*QObject, int(l.len))
			tmpList := NewQObjectFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__findChildren_atList3(i)
			}
			return out
		}(C.QObject_FindChildren3(ptr.Pointer(), PointerFromQRegularExpression(re), C.longlong(options)))
	}
	return make([]*QObject, 0)
}

func (ptr *QObject) Inherits(className string) bool {
	if ptr.Pointer() != nil {
		var classNameC *C.char
		if className != "" {
			classNameC = C.CString(className)
			defer C.free(unsafe.Pointer(classNameC))
		}
		return int8(C.QObject_Inherits(ptr.Pointer(), classNameC)) != 0
	}
	return false
}

func (ptr *QObject) InstallEventFilter(filterObj QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_InstallEventFilter(ptr.Pointer(), PointerFromQObject(filterObj))
	}
}

func (ptr *QObject) IsSignalConnected(sign QMetaMethod_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QObject_IsSignalConnected(ptr.Pointer(), PointerFromQMetaMethod(sign))) != 0
	}
	return false
}

func (ptr *QObject) IsWidgetType() bool {
	if ptr.Pointer() != nil {
		return int8(C.QObject_IsWidgetType(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QObject) IsWindowType() bool {
	if ptr.Pointer() != nil {
		return int8(C.QObject_IsWindowType(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QObject) KillTimer(id int) {
	if ptr.Pointer() != nil {
		C.QObject_KillTimer(ptr.Pointer(), C.int(int32(id)))
	}
}

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

	return PointerFromQMetaObject(NewQObjectFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QObject) ConnectMetaObject(f func() *QMetaObject) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "metaObject"); signal != nil {
			f := func() *QMetaObject {
				(*(*func() *QMetaObject)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "metaObject", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "metaObject", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectMetaObject() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "metaObject")
	}
}

func (ptr *QObject) MetaObject() *QMetaObject {
	if ptr.Pointer() != nil {
		return NewQMetaObjectFromPointer(C.QObject_MetaObject(ptr.Pointer()))
	}
	return nil
}

func (ptr *QObject) MetaObjectDefault() *QMetaObject {
	if ptr.Pointer() != nil {
		return NewQMetaObjectFromPointer(C.QObject_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QObject) MoveToThread(targetThread QThread_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_MoveToThread(ptr.Pointer(), PointerFromQThread(targetThread))
	}
}

func (ptr *QObject) ObjectName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QObject_ObjectName(ptr.Pointer()))
	}
	return ""
}

//export callbackQObject_ObjectNameChanged
func callbackQObject_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtCore_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

func (ptr *QObject) ConnectObjectNameChanged(f func(objectName string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "objectNameChanged") {
			C.QObject_ConnectObjectNameChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "objectNameChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "objectNameChanged"); signal != nil {
			f := func(objectName string) {
				(*(*func(string))(signal))(objectName)
				f(objectName)
			}
			qt.ConnectSignal(ptr.Pointer(), "objectNameChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "objectNameChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectObjectNameChanged() {
	if ptr.Pointer() != nil {
		C.QObject_DisconnectObjectNameChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "objectNameChanged")
	}
}

func (ptr *QObject) Parent() *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QObject_Parent(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObject) Property(name string) *QVariant {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		tmpValue := NewQVariantFromPointer(C.QObject_Property(ptr.Pointer(), nameC))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QObject) Receivers(sign string) int {
	if ptr.Pointer() != nil {
		var signC *C.char
		if sign != "" {
			signC = C.CString(sign)
			defer C.free(unsafe.Pointer(signC))
		}
		return int(int32(C.QObject_Receivers(ptr.Pointer(), signC)))
	}
	return 0
}

func (ptr *QObject) RemoveEventFilter(obj QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_RemoveEventFilter(ptr.Pointer(), PointerFromQObject(obj))
	}
}

func (ptr *QObject) Sender() *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QObject_Sender(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObject) SenderSignalIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QObject_SenderSignalIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QObject) SetObjectName(name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QObject_SetObjectName(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

func (ptr *QObject) SetParent(parent QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_SetParent(ptr.Pointer(), PointerFromQObject(parent))
	}
}

func (ptr *QObject) SetProperty(name string, value QVariant_ITF) bool {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int8(C.QObject_SetProperty(ptr.Pointer(), nameC, PointerFromQVariant(value))) != 0
	}
	return false
}

func (ptr *QObject) SignalsBlocked() bool {
	if ptr.Pointer() != nil {
		return int8(C.QObject_SignalsBlocked(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QObject) StartTimer(interval int, timerType Qt__TimerType) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QObject_StartTimer(ptr.Pointer(), C.int(int32(interval)), C.longlong(timerType))))
	}
	return 0
}

func (ptr *QObject) Thread() *QThread {
	if ptr.Pointer() != nil {
		tmpValue := NewQThreadFromPointer(C.QObject_Thread(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

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

func (ptr *QObject) ConnectTimerEvent(f func(event *QTimerEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "timerEvent"); signal != nil {
			f := func(event *QTimerEvent) {
				(*(*func(*QTimerEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "timerEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "timerEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectTimerEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "timerEvent")
	}
}

func (ptr *QObject) TimerEvent(event QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QObject) TimerEventDefault(event QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QObject_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func QObject_Tr(sourceText string, disambiguation string, n int) string {
	var sourceTextC *C.char
	if sourceText != "" {
		sourceTextC = C.CString(sourceText)
		defer C.free(unsafe.Pointer(sourceTextC))
	}
	var disambiguationC *C.char
	if disambiguation != "" {
		disambiguationC = C.CString(disambiguation)
		defer C.free(unsafe.Pointer(disambiguationC))
	}
	return cGoUnpackString(C.QObject_QObject_Tr(sourceTextC, disambiguationC, C.int(int32(n))))
}

func (ptr *QObject) Tr(sourceText string, disambiguation string, n int) string {
	var sourceTextC *C.char
	if sourceText != "" {
		sourceTextC = C.CString(sourceText)
		defer C.free(unsafe.Pointer(sourceTextC))
	}
	var disambiguationC *C.char
	if disambiguation != "" {
		disambiguationC = C.CString(disambiguation)
		defer C.free(unsafe.Pointer(disambiguationC))
	}
	return cGoUnpackString(C.QObject_QObject_Tr(sourceTextC, disambiguationC, C.int(int32(n))))
}

//export callbackQObject_DestroyQObject
func callbackQObject_DestroyQObject(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QObject"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQObjectFromPointer(ptr).DestroyQObjectDefault()
	}
}

func (ptr *QObject) ConnectDestroyQObject(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QObject"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QObject", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QObject", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObject) DisconnectDestroyQObject() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QObject")
	}
}

func (ptr *QObject) DestroyQObject() {
	if ptr.Pointer() != nil {
		C.QObject_DestroyQObject(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QObject) DestroyQObjectDefault() {
	if ptr.Pointer() != nil {
		C.QObject_DestroyQObjectDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QObject) InvokeMethod(name string, arg QVariant_ITF) *QVariant {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return NewQVariantFromPointer(C.QObject_InvokeMethod(ptr.Pointer(), nameC, PointerFromQVariant(arg)))
	}
	return nil
}

func (ptr *QObject) ToVariant() *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QObject_ToVariant(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

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

func (ptr *QObject) __children_setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject___children_setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObject) __children_newList() unsafe.Pointer {
	return C.QObject___children_newList(ptr.Pointer())
}

func (ptr *QObject) __dynamicPropertyNames_atList(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QObject___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QObject) __dynamicPropertyNames_setList(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QObject___dynamicPropertyNames_setList(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QObject) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QObject___dynamicPropertyNames_newList(ptr.Pointer())
}

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

func (ptr *QObject) __findChildren_setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject___findChildren_setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObject) __findChildren_newList() unsafe.Pointer {
	return C.QObject___findChildren_newList(ptr.Pointer())
}

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

func (ptr *QObject) __findChildren_setList2(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject___findChildren_setList2(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObject) __findChildren_newList2() unsafe.Pointer {
	return C.QObject___findChildren_newList2(ptr.Pointer())
}

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

func (ptr *QObject) __findChildren_setList3(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject___findChildren_setList3(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObject) __findChildren_newList3() unsafe.Pointer {
	return C.QObject___findChildren_newList3(ptr.Pointer())
}

func (ptr *QObject) __qFindChildren_atList(i int) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QObject___qFindChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObject) __qFindChildren_setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject___qFindChildren_setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObject) __qFindChildren_newList() unsafe.Pointer {
	return C.QObject___qFindChildren_newList(ptr.Pointer())
}

func (ptr *QObject) __qFindChildren_atList2(i int) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QObject___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObject) __qFindChildren_setList2(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObject___qFindChildren_setList2(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObject) __qFindChildren_newList2() unsafe.Pointer {
	return C.QObject___qFindChildren_newList2(ptr.Pointer())
}

type QObjectCleanupHandler struct {
	QObject
}

type QObjectCleanupHandler_ITF interface {
	QObject_ITF
	QObjectCleanupHandler_PTR() *QObjectCleanupHandler
}

func (ptr *QObjectCleanupHandler) QObjectCleanupHandler_PTR() *QObjectCleanupHandler {
	return ptr
}

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

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

func PointerFromQObjectCleanupHandler(ptr QObjectCleanupHandler_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QObjectCleanupHandler_PTR().Pointer()
	}
	return nil
}

func NewQObjectCleanupHandlerFromPointer(ptr unsafe.Pointer) (n *QObjectCleanupHandler) {
	n = new(QObjectCleanupHandler)
	n.SetPointer(ptr)
	return
}
func NewQObjectCleanupHandler() *QObjectCleanupHandler {
	tmpValue := NewQObjectCleanupHandlerFromPointer(C.QObjectCleanupHandler_NewQObjectCleanupHandler())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QObjectCleanupHandler) Add(object QObject_ITF) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QObjectCleanupHandler_Add(ptr.Pointer(), PointerFromQObject(object)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObjectCleanupHandler) Clear() {
	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_Clear(ptr.Pointer())
	}
}

func (ptr *QObjectCleanupHandler) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QObjectCleanupHandler_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QObjectCleanupHandler) Remove(object QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_Remove(ptr.Pointer(), PointerFromQObject(object))
	}
}

//export callbackQObjectCleanupHandler_DestroyQObjectCleanupHandler
func callbackQObjectCleanupHandler_DestroyQObjectCleanupHandler(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QObjectCleanupHandler"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQObjectCleanupHandlerFromPointer(ptr).DestroyQObjectCleanupHandlerDefault()
	}
}

func (ptr *QObjectCleanupHandler) ConnectDestroyQObjectCleanupHandler(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QObjectCleanupHandler"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QObjectCleanupHandler", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QObjectCleanupHandler", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QObjectCleanupHandler) DisconnectDestroyQObjectCleanupHandler() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QObjectCleanupHandler")
	}
}

func (ptr *QObjectCleanupHandler) DestroyQObjectCleanupHandler() {
	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_DestroyQObjectCleanupHandler(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QObjectCleanupHandler) DestroyQObjectCleanupHandlerDefault() {
	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_DestroyQObjectCleanupHandlerDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QObjectCleanupHandler) __cleanupObjects_atList(i int) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QObjectCleanupHandler___cleanupObjects_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObjectCleanupHandler) __cleanupObjects_setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler___cleanupObjects_setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObjectCleanupHandler) __cleanupObjects_newList() unsafe.Pointer {
	return C.QObjectCleanupHandler___cleanupObjects_newList(ptr.Pointer())
}

func (ptr *QObjectCleanupHandler) __setCleanupObjects__atList(i int) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QObjectCleanupHandler___setCleanupObjects__atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObjectCleanupHandler) __setCleanupObjects__setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler___setCleanupObjects__setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObjectCleanupHandler) __setCleanupObjects__newList() unsafe.Pointer {
	return C.QObjectCleanupHandler___setCleanupObjects__newList(ptr.Pointer())
}

type QObjectData struct {
	ptr unsafe.Pointer
}

type QObjectData_ITF interface {
	QObjectData_PTR() *QObjectData
}

func (ptr *QObjectData) QObjectData_PTR() *QObjectData {
	return ptr
}

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

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

func PointerFromQObjectData(ptr QObjectData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QObjectData_PTR().Pointer()
	}
	return nil
}

func NewQObjectDataFromPointer(ptr unsafe.Pointer) (n *QObjectData) {
	n = new(QObjectData)
	n.SetPointer(ptr)
	return
}

func (ptr *QObjectData) DestroyQObjectData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QObjectData) __children_atList(i int) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QObjectData___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObjectData) __children_setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObjectData___children_setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObjectData) __children_newList() unsafe.Pointer {
	return C.QObjectData___children_newList(ptr.Pointer())
}

func (ptr *QObjectData) __setChildren__atList(i int) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QObjectData___setChildren__atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QObjectData) __setChildren__setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QObjectData___setChildren__setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QObjectData) __setChildren__newList() unsafe.Pointer {
	return C.QObjectData___setChildren__newList(ptr.Pointer())
}

type QObjectUserData struct {
	ptr unsafe.Pointer
}

type QObjectUserData_ITF interface {
	QObjectUserData_PTR() *QObjectUserData
}

func (ptr *QObjectUserData) QObjectUserData_PTR() *QObjectUserData {
	return ptr
}

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

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

func PointerFromQObjectUserData(ptr QObjectUserData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QObjectUserData_PTR().Pointer()
	}
	return nil
}

func NewQObjectUserDataFromPointer(ptr unsafe.Pointer) (n *QObjectUserData) {
	n = new(QObjectUserData)
	n.SetPointer(ptr)
	return
}

func (ptr *QObjectUserData) DestroyQObjectUserData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QOperatingSystemVersion struct {
	ptr unsafe.Pointer
}

type QOperatingSystemVersion_ITF interface {
	QOperatingSystemVersion_PTR() *QOperatingSystemVersion
}

func (ptr *QOperatingSystemVersion) QOperatingSystemVersion_PTR() *QOperatingSystemVersion {
	return ptr
}

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

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

func PointerFromQOperatingSystemVersion(ptr QOperatingSystemVersion_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOperatingSystemVersion_PTR().Pointer()
	}
	return nil
}

func NewQOperatingSystemVersionFromPointer(ptr unsafe.Pointer) (n *QOperatingSystemVersion) {
	n = new(QOperatingSystemVersion)
	n.SetPointer(ptr)
	return
}

func (ptr *QOperatingSystemVersion) DestroyQOperatingSystemVersion() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QOperatingSystemVersion__OSType
//QOperatingSystemVersion::OSType
type QOperatingSystemVersion__OSType int64

const (
	QOperatingSystemVersion__Unknown QOperatingSystemVersion__OSType = QOperatingSystemVersion__OSType(0)
	QOperatingSystemVersion__Windows QOperatingSystemVersion__OSType = QOperatingSystemVersion__OSType(1)
	QOperatingSystemVersion__MacOS   QOperatingSystemVersion__OSType = QOperatingSystemVersion__OSType(2)
	QOperatingSystemVersion__IOS     QOperatingSystemVersion__OSType = QOperatingSystemVersion__OSType(3)
	QOperatingSystemVersion__TvOS    QOperatingSystemVersion__OSType = QOperatingSystemVersion__OSType(4)
	QOperatingSystemVersion__WatchOS QOperatingSystemVersion__OSType = QOperatingSystemVersion__OSType(5)
	QOperatingSystemVersion__Android QOperatingSystemVersion__OSType = QOperatingSystemVersion__OSType(6)
)

func NewQOperatingSystemVersion2(osType QOperatingSystemVersion__OSType, vmajor int, vminor int, vmicro int) *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_NewQOperatingSystemVersion2(C.longlong(osType), C.int(int32(vmajor)), C.int(int32(vminor)), C.int(int32(vmicro))))
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_Current() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Current())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) Current() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Current())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_CurrentType() QOperatingSystemVersion__OSType {
	return QOperatingSystemVersion__OSType(C.QOperatingSystemVersion_QOperatingSystemVersion_CurrentType())
}

func (ptr *QOperatingSystemVersion) CurrentType() QOperatingSystemVersion__OSType {
	return QOperatingSystemVersion__OSType(C.QOperatingSystemVersion_QOperatingSystemVersion_CurrentType())
}

func (ptr *QOperatingSystemVersion) MajorVersion() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QOperatingSystemVersion_MajorVersion(ptr.Pointer())))
	}
	return 0
}

func (ptr *QOperatingSystemVersion) MicroVersion() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QOperatingSystemVersion_MicroVersion(ptr.Pointer())))
	}
	return 0
}

func (ptr *QOperatingSystemVersion) MinorVersion() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QOperatingSystemVersion_MinorVersion(ptr.Pointer())))
	}
	return 0
}

func (ptr *QOperatingSystemVersion) Name() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QOperatingSystemVersion_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QOperatingSystemVersion) SegmentCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QOperatingSystemVersion_SegmentCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QOperatingSystemVersion) Type() QOperatingSystemVersion__OSType {
	if ptr.Pointer() != nil {
		return QOperatingSystemVersion__OSType(C.QOperatingSystemVersion_Type(ptr.Pointer()))
	}
	return 0
}

func QOperatingSystemVersion_Windows7() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Windows7())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) Windows7() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Windows7())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_Windows8() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Windows8())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) Windows8() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Windows8())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_Windows8_1() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Windows8_1())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) Windows8_1() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Windows8_1())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_Windows10() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Windows10())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) Windows10() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_Windows10())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_OSXMavericks() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_OSXMavericks())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) OSXMavericks() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_OSXMavericks())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_OSXYosemite() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_OSXYosemite())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) OSXYosemite() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_OSXYosemite())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_OSXElCapitan() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_OSXElCapitan())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) OSXElCapitan() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_OSXElCapitan())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_MacOSSierra() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_MacOSSierra())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) MacOSSierra() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_MacOSSierra())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_MacOSHighSierra() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_MacOSHighSierra())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) MacOSHighSierra() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_MacOSHighSierra())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_MacOSMojave() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_MacOSMojave())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) MacOSMojave() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_MacOSMojave())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidJellyBean() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidJellyBean())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidJellyBean() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidJellyBean())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidJellyBean_MR1() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidJellyBean_MR1())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidJellyBean_MR1() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidJellyBean_MR1())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidJellyBean_MR2() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidJellyBean_MR2())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidJellyBean_MR2() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidJellyBean_MR2())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidKitKat() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidKitKat())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidKitKat() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidKitKat())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidLollipop() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidLollipop())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidLollipop() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidLollipop())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidLollipop_MR1() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidLollipop_MR1())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidLollipop_MR1() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidLollipop_MR1())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidMarshmallow() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidMarshmallow())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidMarshmallow() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidMarshmallow())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidNougat() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidNougat())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidNougat() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidNougat())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidNougat_MR1() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidNougat_MR1())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidNougat_MR1() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidNougat_MR1())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func QOperatingSystemVersion_AndroidOreo() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidOreo())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func (ptr *QOperatingSystemVersion) AndroidOreo() *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_QOperatingSystemVersion_AndroidOreo())
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

func NewQOperatingSystemVersion(other QOperatingSystemVersion_ITF) *QOperatingSystemVersion {
	tmpValue := NewQOperatingSystemVersionFromPointer(C.QOperatingSystemVersion_NewQOperatingSystemVersion(PointerFromQOperatingSystemVersion(other)))
	runtime.SetFinalizer(tmpValue, (*QOperatingSystemVersion).DestroyQOperatingSystemVersion)
	return tmpValue
}

type QPair struct {
	ptr unsafe.Pointer
}

type QPair_ITF interface {
	QPair_PTR() *QPair
}

func (ptr *QPair) QPair_PTR() *QPair {
	return ptr
}

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

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

func PointerFromQPair(ptr QPair_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPair_PTR().Pointer()
	}
	return nil
}

func NewQPairFromPointer(ptr unsafe.Pointer) (n *QPair) {
	n = new(QPair)
	n.SetPointer(ptr)
	return
}

func (ptr *QPair) DestroyQPair() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QParallelAnimationGroup struct {
	QAnimationGroup
}

type QParallelAnimationGroup_ITF interface {
	QAnimationGroup_ITF
	QParallelAnimationGroup_PTR() *QParallelAnimationGroup
}

func (ptr *QParallelAnimationGroup) QParallelAnimationGroup_PTR() *QParallelAnimationGroup {
	return ptr
}

func (ptr *QParallelAnimationGroup) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAnimationGroup_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQParallelAnimationGroup(ptr QParallelAnimationGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QParallelAnimationGroup_PTR().Pointer()
	}
	return nil
}

func NewQParallelAnimationGroupFromPointer(ptr unsafe.Pointer) (n *QParallelAnimationGroup) {
	n = new(QParallelAnimationGroup)
	n.SetPointer(ptr)
	return
}
func NewQParallelAnimationGroup(parent QObject_ITF) *QParallelAnimationGroup {
	tmpValue := NewQParallelAnimationGroupFromPointer(C.QParallelAnimationGroup_NewQParallelAnimationGroup(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQParallelAnimationGroup_Duration
func callbackQParallelAnimationGroup_Duration(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "duration"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQParallelAnimationGroupFromPointer(ptr).DurationDefault()))
}

func (ptr *QParallelAnimationGroup) ConnectDuration(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "duration"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QParallelAnimationGroup) DisconnectDuration() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "duration")
	}
}

func (ptr *QParallelAnimationGroup) Duration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QParallelAnimationGroup_Duration(ptr.Pointer())))
	}
	return 0
}

func (ptr *QParallelAnimationGroup) DurationDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QParallelAnimationGroup_DurationDefault(ptr.Pointer())))
	}
	return 0
}

//export callbackQParallelAnimationGroup_UpdateCurrentTime
func callbackQParallelAnimationGroup_UpdateCurrentTime(ptr unsafe.Pointer, currentTime C.int) {
	if signal := qt.GetSignal(ptr, "updateCurrentTime"); signal != nil {
		(*(*func(int))(signal))(int(int32(currentTime)))
	} else {
		NewQParallelAnimationGroupFromPointer(ptr).UpdateCurrentTimeDefault(int(int32(currentTime)))
	}
}

func (ptr *QParallelAnimationGroup) ConnectUpdateCurrentTime(f func(currentTime int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateCurrentTime"); signal != nil {
			f := func(currentTime int) {
				(*(*func(int))(signal))(currentTime)
				f(currentTime)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QParallelAnimationGroup) DisconnectUpdateCurrentTime() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateCurrentTime")
	}
}

func (ptr *QParallelAnimationGroup) UpdateCurrentTime(currentTime int) {
	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_UpdateCurrentTime(ptr.Pointer(), C.int(int32(currentTime)))
	}
}

func (ptr *QParallelAnimationGroup) UpdateCurrentTimeDefault(currentTime int) {
	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(int32(currentTime)))
	}
}

//export callbackQParallelAnimationGroup_DestroyQParallelAnimationGroup
func callbackQParallelAnimationGroup_DestroyQParallelAnimationGroup(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QParallelAnimationGroup"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQParallelAnimationGroupFromPointer(ptr).DestroyQParallelAnimationGroupDefault()
	}
}

func (ptr *QParallelAnimationGroup) ConnectDestroyQParallelAnimationGroup(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QParallelAnimationGroup"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QParallelAnimationGroup", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QParallelAnimationGroup", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QParallelAnimationGroup) DisconnectDestroyQParallelAnimationGroup() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QParallelAnimationGroup")
	}
}

func (ptr *QParallelAnimationGroup) DestroyQParallelAnimationGroup() {
	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_DestroyQParallelAnimationGroup(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QParallelAnimationGroup) DestroyQParallelAnimationGroupDefault() {
	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_DestroyQParallelAnimationGroupDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QPauseAnimation struct {
	QAbstractAnimation
}

type QPauseAnimation_ITF interface {
	QAbstractAnimation_ITF
	QPauseAnimation_PTR() *QPauseAnimation
}

func (ptr *QPauseAnimation) QPauseAnimation_PTR() *QPauseAnimation {
	return ptr
}

func (ptr *QPauseAnimation) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractAnimation_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQPauseAnimation(ptr QPauseAnimation_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPauseAnimation_PTR().Pointer()
	}
	return nil
}

func NewQPauseAnimationFromPointer(ptr unsafe.Pointer) (n *QPauseAnimation) {
	n = new(QPauseAnimation)
	n.SetPointer(ptr)
	return
}
func NewQPauseAnimation(parent QObject_ITF) *QPauseAnimation {
	tmpValue := NewQPauseAnimationFromPointer(C.QPauseAnimation_NewQPauseAnimation(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQPauseAnimation2(msecs int, parent QObject_ITF) *QPauseAnimation {
	tmpValue := NewQPauseAnimationFromPointer(C.QPauseAnimation_NewQPauseAnimation2(C.int(int32(msecs)), PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQPauseAnimation_Duration
func callbackQPauseAnimation_Duration(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "duration"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQPauseAnimationFromPointer(ptr).DurationDefault()))
}

func (ptr *QPauseAnimation) ConnectDuration(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "duration"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPauseAnimation) DisconnectDuration() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "duration")
	}
}

func (ptr *QPauseAnimation) Duration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPauseAnimation_Duration(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPauseAnimation) DurationDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPauseAnimation_DurationDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPauseAnimation) SetDuration(msecs int) {
	if ptr.Pointer() != nil {
		C.QPauseAnimation_SetDuration(ptr.Pointer(), C.int(int32(msecs)))
	}
}

//export callbackQPauseAnimation_UpdateCurrentTime
func callbackQPauseAnimation_UpdateCurrentTime(ptr unsafe.Pointer, vin C.int) {
	if signal := qt.GetSignal(ptr, "updateCurrentTime"); signal != nil {
		(*(*func(int))(signal))(int(int32(vin)))
	} else {
		NewQPauseAnimationFromPointer(ptr).UpdateCurrentTimeDefault(int(int32(vin)))
	}
}

func (ptr *QPauseAnimation) ConnectUpdateCurrentTime(f func(vin int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateCurrentTime"); signal != nil {
			f := func(vin int) {
				(*(*func(int))(signal))(vin)
				f(vin)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPauseAnimation) DisconnectUpdateCurrentTime() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateCurrentTime")
	}
}

func (ptr *QPauseAnimation) UpdateCurrentTime(vin int) {
	if ptr.Pointer() != nil {
		C.QPauseAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QPauseAnimation) UpdateCurrentTimeDefault(vin int) {
	if ptr.Pointer() != nil {
		C.QPauseAnimation_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(int32(vin)))
	}
}

//export callbackQPauseAnimation_DestroyQPauseAnimation
func callbackQPauseAnimation_DestroyQPauseAnimation(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QPauseAnimation"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPauseAnimationFromPointer(ptr).DestroyQPauseAnimationDefault()
	}
}

func (ptr *QPauseAnimation) ConnectDestroyQPauseAnimation(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QPauseAnimation"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QPauseAnimation", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QPauseAnimation", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPauseAnimation) DisconnectDestroyQPauseAnimation() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QPauseAnimation")
	}
}

func (ptr *QPauseAnimation) DestroyQPauseAnimation() {
	if ptr.Pointer() != nil {
		C.QPauseAnimation_DestroyQPauseAnimation(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPauseAnimation) DestroyQPauseAnimationDefault() {
	if ptr.Pointer() != nil {
		C.QPauseAnimation_DestroyQPauseAnimationDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QPersistentModelIndex struct {
	ptr unsafe.Pointer
}

type QPersistentModelIndex_ITF interface {
	QPersistentModelIndex_PTR() *QPersistentModelIndex
}

func (ptr *QPersistentModelIndex) QPersistentModelIndex_PTR() *QPersistentModelIndex {
	return ptr
}

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

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

func PointerFromQPersistentModelIndex(ptr QPersistentModelIndex_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPersistentModelIndex_PTR().Pointer()
	}
	return nil
}

func NewQPersistentModelIndexFromPointer(ptr unsafe.Pointer) (n *QPersistentModelIndex) {
	n = new(QPersistentModelIndex)
	n.SetPointer(ptr)
	return
}

func (ptr *QPersistentModelIndex) DestroyQPersistentModelIndex() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQPersistentModelIndex2(index QModelIndex_ITF) *QPersistentModelIndex {
	tmpValue := NewQPersistentModelIndexFromPointer(C.QPersistentModelIndex_NewQPersistentModelIndex2(PointerFromQModelIndex(index)))
	runtime.SetFinalizer(tmpValue, (*QPersistentModelIndex).DestroyQPersistentModelIndex)
	return tmpValue
}

func NewQPersistentModelIndex3(other QPersistentModelIndex_ITF) *QPersistentModelIndex {
	tmpValue := NewQPersistentModelIndexFromPointer(C.QPersistentModelIndex_NewQPersistentModelIndex3(PointerFromQPersistentModelIndex(other)))
	runtime.SetFinalizer(tmpValue, (*QPersistentModelIndex).DestroyQPersistentModelIndex)
	return tmpValue
}

func NewQPersistentModelIndex4(other QPersistentModelIndex_ITF) *QPersistentModelIndex {
	tmpValue := NewQPersistentModelIndexFromPointer(C.QPersistentModelIndex_NewQPersistentModelIndex4(PointerFromQPersistentModelIndex(other)))
	runtime.SetFinalizer(tmpValue, (*QPersistentModelIndex).DestroyQPersistentModelIndex)
	return tmpValue
}

func (ptr *QPersistentModelIndex) Column() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPersistentModelIndex_Column(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPersistentModelIndex) Data(role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QPersistentModelIndex_Data(ptr.Pointer(), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QPersistentModelIndex) Flags() Qt__ItemFlag {
	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QPersistentModelIndex_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPersistentModelIndex) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPersistentModelIndex_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPersistentModelIndex) Model() *QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemModelFromPointer(C.QPersistentModelIndex_Model(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPersistentModelIndex) Parent() *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QPersistentModelIndex_Parent(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QPersistentModelIndex) Row() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPersistentModelIndex_Row(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPersistentModelIndex) Sibling(row int, column int) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QPersistentModelIndex_Sibling(ptr.Pointer(), C.int(int32(row)), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QPersistentModelIndex) Swap(other QPersistentModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QPersistentModelIndex_Swap(ptr.Pointer(), PointerFromQPersistentModelIndex(other))
	}
}

type QPluginLoader struct {
	QObject
}

type QPluginLoader_ITF interface {
	QObject_ITF
	QPluginLoader_PTR() *QPluginLoader
}

func (ptr *QPluginLoader) QPluginLoader_PTR() *QPluginLoader {
	return ptr
}

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

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

func PointerFromQPluginLoader(ptr QPluginLoader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPluginLoader_PTR().Pointer()
	}
	return nil
}

func NewQPluginLoaderFromPointer(ptr unsafe.Pointer) (n *QPluginLoader) {
	n = new(QPluginLoader)
	n.SetPointer(ptr)
	return
}
func NewQPluginLoader(parent QObject_ITF) *QPluginLoader {
	tmpValue := NewQPluginLoaderFromPointer(C.QPluginLoader_NewQPluginLoader(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQPluginLoader2(fileName string, parent QObject_ITF) *QPluginLoader {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	tmpValue := NewQPluginLoaderFromPointer(C.QPluginLoader_NewQPluginLoader2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

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

func (ptr *QPluginLoader) FileName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QPluginLoader_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPluginLoader) Instance() *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QPluginLoader_Instance(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPluginLoader) IsLoaded() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPluginLoader_IsLoaded(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPluginLoader) Load() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPluginLoader_Load(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPluginLoader) LoadHints() QLibrary__LoadHint {
	if ptr.Pointer() != nil {
		return QLibrary__LoadHint(C.QPluginLoader_LoadHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPluginLoader) MetaData() *QJsonObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonObjectFromPointer(C.QPluginLoader_MetaData(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
		return tmpValue
	}
	return nil
}

func (ptr *QPluginLoader) SetFileName(fileName string) {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		C.QPluginLoader_SetFileName(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})
	}
}

func (ptr *QPluginLoader) SetLoadHints(loadHints QLibrary__LoadHint) {
	if ptr.Pointer() != nil {
		C.QPluginLoader_SetLoadHints(ptr.Pointer(), C.longlong(loadHints))
	}
}

func QPluginLoader_StaticInstances() []*QObject {
	return func(l C.struct_QtCore_PackedList) []*QObject {
		out := make([]*QObject, int(l.len))
		tmpList := NewQPluginLoaderFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__staticInstances_atList(i)
		}
		return out
	}(C.QPluginLoader_QPluginLoader_StaticInstances())
}

func (ptr *QPluginLoader) StaticInstances() []*QObject {
	return func(l C.struct_QtCore_PackedList) []*QObject {
		out := make([]*QObject, int(l.len))
		tmpList := NewQPluginLoaderFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__staticInstances_atList(i)
		}
		return out
	}(C.QPluginLoader_QPluginLoader_StaticInstances())
}

func (ptr *QPluginLoader) Unload() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPluginLoader_Unload(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQPluginLoader_DestroyQPluginLoader
func callbackQPluginLoader_DestroyQPluginLoader(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QPluginLoader"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPluginLoaderFromPointer(ptr).DestroyQPluginLoaderDefault()
	}
}

func (ptr *QPluginLoader) ConnectDestroyQPluginLoader(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QPluginLoader"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QPluginLoader", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QPluginLoader", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPluginLoader) DisconnectDestroyQPluginLoader() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QPluginLoader")
	}
}

func (ptr *QPluginLoader) DestroyQPluginLoader() {
	if ptr.Pointer() != nil {
		C.QPluginLoader_DestroyQPluginLoader(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPluginLoader) DestroyQPluginLoaderDefault() {
	if ptr.Pointer() != nil {
		C.QPluginLoader_DestroyQPluginLoaderDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPluginLoader) __staticInstances_atList(i int) *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QPluginLoader___staticInstances_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPluginLoader) __staticInstances_setList(i QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QPluginLoader___staticInstances_setList(ptr.Pointer(), PointerFromQObject(i))
	}
}

func (ptr *QPluginLoader) __staticInstances_newList() unsafe.Pointer {
	return C.QPluginLoader___staticInstances_newList(ptr.Pointer())
}

func (ptr *QPluginLoader) __staticPlugins_setList(i QStaticPlugin_ITF) {
	if ptr.Pointer() != nil {
		C.QPluginLoader___staticPlugins_setList(ptr.Pointer(), PointerFromQStaticPlugin(i))
	}
}

func (ptr *QPluginLoader) __staticPlugins_newList() unsafe.Pointer {
	return C.QPluginLoader___staticPlugins_newList(ptr.Pointer())
}

type QPoint struct {
	ptr unsafe.Pointer
}

type QPoint_ITF interface {
	QPoint_PTR() *QPoint
}

func (ptr *QPoint) QPoint_PTR() *QPoint {
	return ptr
}

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

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

func PointerFromQPoint(ptr QPoint_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPoint_PTR().Pointer()
	}
	return nil
}

func NewQPointFromPointer(ptr unsafe.Pointer) (n *QPoint) {
	n = new(QPoint)
	n.SetPointer(ptr)
	return
}

func (ptr *QPoint) DestroyQPoint() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQPoint() *QPoint {
	tmpValue := NewQPointFromPointer(C.QPoint_NewQPoint())
	runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
	return tmpValue
}

func NewQPoint2(xpos int, ypos int) *QPoint {
	tmpValue := NewQPointFromPointer(C.QPoint_NewQPoint2(C.int(int32(xpos)), C.int(int32(ypos))))
	runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
	return tmpValue
}

func QPoint_DotProduct(p1 QPoint_ITF, p2 QPoint_ITF) int {
	return int(int32(C.QPoint_QPoint_DotProduct(PointerFromQPoint(p1), PointerFromQPoint(p2))))
}

func (ptr *QPoint) DotProduct(p1 QPoint_ITF, p2 QPoint_ITF) int {
	return int(int32(C.QPoint_QPoint_DotProduct(PointerFromQPoint(p1), PointerFromQPoint(p2))))
}

func (ptr *QPoint) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPoint_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPoint) ManhattanLength() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPoint_ManhattanLength(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPoint) Rx() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPoint_Rx(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPoint) Ry() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPoint_Ry(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPoint) SetX(x int) {
	if ptr.Pointer() != nil {
		C.QPoint_SetX(ptr.Pointer(), C.int(int32(x)))
	}
}

func (ptr *QPoint) SetY(y int) {
	if ptr.Pointer() != nil {
		C.QPoint_SetY(ptr.Pointer(), C.int(int32(y)))
	}
}

func (ptr *QPoint) X() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPoint_X(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPoint) Y() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPoint_Y(ptr.Pointer())))
	}
	return 0
}

type QPointF struct {
	ptr unsafe.Pointer
}

type QPointF_ITF interface {
	QPointF_PTR() *QPointF
}

func (ptr *QPointF) QPointF_PTR() *QPointF {
	return ptr
}

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

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

func PointerFromQPointF(ptr QPointF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPointF_PTR().Pointer()
	}
	return nil
}

func NewQPointFFromPointer(ptr unsafe.Pointer) (n *QPointF) {
	n = new(QPointF)
	n.SetPointer(ptr)
	return
}

func (ptr *QPointF) DestroyQPointF() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQPointF() *QPointF {
	tmpValue := NewQPointFFromPointer(C.QPointF_NewQPointF())
	runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
	return tmpValue
}

func NewQPointF2(point QPoint_ITF) *QPointF {
	tmpValue := NewQPointFFromPointer(C.QPointF_NewQPointF2(PointerFromQPoint(point)))
	runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
	return tmpValue
}

func NewQPointF3(xpos float64, ypos float64) *QPointF {
	tmpValue := NewQPointFFromPointer(C.QPointF_NewQPointF3(C.double(xpos), C.double(ypos)))
	runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
	return tmpValue
}

func QPointF_DotProduct(p1 QPointF_ITF, p2 QPointF_ITF) float64 {
	return float64(C.QPointF_QPointF_DotProduct(PointerFromQPointF(p1), PointerFromQPointF(p2)))
}

func (ptr *QPointF) DotProduct(p1 QPointF_ITF, p2 QPointF_ITF) float64 {
	return float64(C.QPointF_QPointF_DotProduct(PointerFromQPointF(p1), PointerFromQPointF(p2)))
}

func (ptr *QPointF) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPointF_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPointF) ManhattanLength() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPointF_ManhattanLength(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPointF) Rx() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPointF_Rx(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPointF) Ry() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPointF_Ry(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPointF) SetX(x float64) {
	if ptr.Pointer() != nil {
		C.QPointF_SetX(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QPointF) SetY(y float64) {
	if ptr.Pointer() != nil {
		C.QPointF_SetY(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QPointF) ToPoint() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QPointF_ToPoint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

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

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

type QPointer struct {
	ptr unsafe.Pointer
}

type QPointer_ITF interface {
	QPointer_PTR() *QPointer
}

func (ptr *QPointer) QPointer_PTR() *QPointer {
	return ptr
}

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

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

func PointerFromQPointer(ptr QPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPointer_PTR().Pointer()
	}
	return nil
}

func NewQPointerFromPointer(ptr unsafe.Pointer) (n *QPointer) {
	n = new(QPointer)
	n.SetPointer(ptr)
	return
}

type QProcess struct {
	QIODevice
}

type QProcess_ITF interface {
	QIODevice_ITF
	QProcess_PTR() *QProcess
}

func (ptr *QProcess) QProcess_PTR() *QProcess {
	return ptr
}

func (ptr *QProcess) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QIODevice_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQProcess(ptr QProcess_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QProcess_PTR().Pointer()
	}
	return nil
}

func NewQProcessFromPointer(ptr unsafe.Pointer) (n *QProcess) {
	n = new(QProcess)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QProcess__ProcessError
//QProcess::ProcessError
type QProcess__ProcessError int64

const (
	QProcess__FailedToStart QProcess__ProcessError = QProcess__ProcessError(0)
	QProcess__Crashed       QProcess__ProcessError = QProcess__ProcessError(1)
	QProcess__Timedout      QProcess__ProcessError = QProcess__ProcessError(2)
	QProcess__ReadError     QProcess__ProcessError = QProcess__ProcessError(3)
	QProcess__WriteError    QProcess__ProcessError = QProcess__ProcessError(4)
	QProcess__UnknownError  QProcess__ProcessError = QProcess__ProcessError(5)
)

//go:generate stringer -type=QProcess__ProcessState
//QProcess::ProcessState
type QProcess__ProcessState int64

const (
	QProcess__NotRunning QProcess__ProcessState = QProcess__ProcessState(0)
	QProcess__Starting   QProcess__ProcessState = QProcess__ProcessState(1)
	QProcess__Running    QProcess__ProcessState = QProcess__ProcessState(2)
)

//go:generate stringer -type=QProcess__ProcessChannel
//QProcess::ProcessChannel
type QProcess__ProcessChannel int64

const (
	QProcess__StandardOutput QProcess__ProcessChannel = QProcess__ProcessChannel(0)
	QProcess__StandardError  QProcess__ProcessChannel = QProcess__ProcessChannel(1)
)

//go:generate stringer -type=QProcess__ProcessChannelMode
//QProcess::ProcessChannelMode
type QProcess__ProcessChannelMode int64

const (
	QProcess__SeparateChannels       QProcess__ProcessChannelMode = QProcess__ProcessChannelMode(0)
	QProcess__MergedChannels         QProcess__ProcessChannelMode = QProcess__ProcessChannelMode(1)
	QProcess__ForwardedChannels      QProcess__ProcessChannelMode = QProcess__ProcessChannelMode(2)
	QProcess__ForwardedOutputChannel QProcess__ProcessChannelMode = QProcess__ProcessChannelMode(3)
	QProcess__ForwardedErrorChannel  QProcess__ProcessChannelMode = QProcess__ProcessChannelMode(4)
)

//go:generate stringer -type=QProcess__InputChannelMode
//QProcess::InputChannelMode
type QProcess__InputChannelMode int64

const (
	QProcess__ManagedInputChannel   QProcess__InputChannelMode = QProcess__InputChannelMode(0)
	QProcess__ForwardedInputChannel QProcess__InputChannelMode = QProcess__InputChannelMode(1)
)

//go:generate stringer -type=QProcess__ExitStatus
//QProcess::ExitStatus
type QProcess__ExitStatus int64

const (
	QProcess__NormalExit QProcess__ExitStatus = QProcess__ExitStatus(0)
	QProcess__CrashExit  QProcess__ExitStatus = QProcess__ExitStatus(1)
)

func NewQProcess(parent QObject_ITF) *QProcess {
	tmpValue := NewQProcessFromPointer(C.QProcess_NewQProcess(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QProcess) Arguments() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QProcess_Arguments(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QProcess) CloseReadChannel(channel QProcess__ProcessChannel) {
	if ptr.Pointer() != nil {
		C.QProcess_CloseReadChannel(ptr.Pointer(), C.longlong(channel))
	}
}

func (ptr *QProcess) CloseWriteChannel() {
	if ptr.Pointer() != nil {
		C.QProcess_CloseWriteChannel(ptr.Pointer())
	}
}

func (ptr *QProcess) Error() QProcess__ProcessError {
	if ptr.Pointer() != nil {
		return QProcess__ProcessError(C.QProcess_Error(ptr.Pointer()))
	}
	return 0
}

//export callbackQProcess_ErrorOccurred
func callbackQProcess_ErrorOccurred(ptr unsafe.Pointer, error C.longlong) {
	if signal := qt.GetSignal(ptr, "errorOccurred"); signal != nil {
		(*(*func(QProcess__ProcessError))(signal))(QProcess__ProcessError(error))
	}

}

func (ptr *QProcess) ConnectErrorOccurred(f func(error QProcess__ProcessError)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "errorOccurred") {
			C.QProcess_ConnectErrorOccurred(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "errorOccurred")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "errorOccurred"); signal != nil {
			f := func(error QProcess__ProcessError) {
				(*(*func(QProcess__ProcessError))(signal))(error)
				f(error)
			}
			qt.ConnectSignal(ptr.Pointer(), "errorOccurred", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "errorOccurred", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectErrorOccurred() {
	if ptr.Pointer() != nil {
		C.QProcess_DisconnectErrorOccurred(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "errorOccurred")
	}
}

func (ptr *QProcess) ErrorOccurred(error QProcess__ProcessError) {
	if ptr.Pointer() != nil {
		C.QProcess_ErrorOccurred(ptr.Pointer(), C.longlong(error))
	}
}

func QProcess_Execute(program string, arguments []string) int {
	var programC *C.char
	if program != "" {
		programC = C.CString(program)
		defer C.free(unsafe.Pointer(programC))
	}
	argumentsC := C.CString(strings.Join(arguments, "¡¦!"))
	defer C.free(unsafe.Pointer(argumentsC))
	return int(int32(C.QProcess_QProcess_Execute(C.struct_QtCore_PackedString{data: programC, len: C.longlong(len(program))}, C.struct_QtCore_PackedString{data: argumentsC, len: C.longlong(len(strings.Join(arguments, "¡¦!")))})))
}

func (ptr *QProcess) Execute(program string, arguments []string) int {
	var programC *C.char
	if program != "" {
		programC = C.CString(program)
		defer C.free(unsafe.Pointer(programC))
	}
	argumentsC := C.CString(strings.Join(arguments, "¡¦!"))
	defer C.free(unsafe.Pointer(argumentsC))
	return int(int32(C.QProcess_QProcess_Execute(C.struct_QtCore_PackedString{data: programC, len: C.longlong(len(program))}, C.struct_QtCore_PackedString{data: argumentsC, len: C.longlong(len(strings.Join(arguments, "¡¦!")))})))
}

func QProcess_Execute2(command string) int {
	var commandC *C.char
	if command != "" {
		commandC = C.CString(command)
		defer C.free(unsafe.Pointer(commandC))
	}
	return int(int32(C.QProcess_QProcess_Execute2(C.struct_QtCore_PackedString{data: commandC, len: C.longlong(len(command))})))
}

func (ptr *QProcess) Execute2(command string) int {
	var commandC *C.char
	if command != "" {
		commandC = C.CString(command)
		defer C.free(unsafe.Pointer(commandC))
	}
	return int(int32(C.QProcess_QProcess_Execute2(C.struct_QtCore_PackedString{data: commandC, len: C.longlong(len(command))})))
}

func (ptr *QProcess) ExitCode() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QProcess_ExitCode(ptr.Pointer())))
	}
	return 0
}

func (ptr *QProcess) ExitStatus() QProcess__ExitStatus {
	if ptr.Pointer() != nil {
		return QProcess__ExitStatus(C.QProcess_ExitStatus(ptr.Pointer()))
	}
	return 0
}

//export callbackQProcess_Finished
func callbackQProcess_Finished(ptr unsafe.Pointer, exitCode C.int, exitStatus C.longlong) {
	if signal := qt.GetSignal(ptr, "finished"); signal != nil {
		(*(*func(int, QProcess__ExitStatus))(signal))(int(int32(exitCode)), QProcess__ExitStatus(exitStatus))
	}

}

func (ptr *QProcess) ConnectFinished(f func(exitCode int, exitStatus QProcess__ExitStatus)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "finished") {
			C.QProcess_ConnectFinished(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "finished")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "finished"); signal != nil {
			f := func(exitCode int, exitStatus QProcess__ExitStatus) {
				(*(*func(int, QProcess__ExitStatus))(signal))(exitCode, exitStatus)
				f(exitCode, exitStatus)
			}
			qt.ConnectSignal(ptr.Pointer(), "finished", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "finished", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectFinished() {
	if ptr.Pointer() != nil {
		C.QProcess_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "finished")
	}
}

func (ptr *QProcess) Finished(exitCode int, exitStatus QProcess__ExitStatus) {
	if ptr.Pointer() != nil {
		C.QProcess_Finished(ptr.Pointer(), C.int(int32(exitCode)), C.longlong(exitStatus))
	}
}

func (ptr *QProcess) InputChannelMode() QProcess__InputChannelMode {
	if ptr.Pointer() != nil {
		return QProcess__InputChannelMode(C.QProcess_InputChannelMode(ptr.Pointer()))
	}
	return 0
}

//export callbackQProcess_Kill
func callbackQProcess_Kill(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "kill"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProcessFromPointer(ptr).KillDefault()
	}
}

func (ptr *QProcess) ConnectKill(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "kill"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "kill", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "kill", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectKill() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "kill")
	}
}

func (ptr *QProcess) Kill() {
	if ptr.Pointer() != nil {
		C.QProcess_Kill(ptr.Pointer())
	}
}

func (ptr *QProcess) KillDefault() {
	if ptr.Pointer() != nil {
		C.QProcess_KillDefault(ptr.Pointer())
	}
}

func (ptr *QProcess) NativeArguments() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QProcess_NativeArguments(ptr.Pointer()))
	}
	return ""
}

func QProcess_NullDevice() string {
	return cGoUnpackString(C.QProcess_QProcess_NullDevice())
}

func (ptr *QProcess) NullDevice() string {
	return cGoUnpackString(C.QProcess_QProcess_NullDevice())
}

func (ptr *QProcess) ProcessChannelMode() QProcess__ProcessChannelMode {
	if ptr.Pointer() != nil {
		return QProcess__ProcessChannelMode(C.QProcess_ProcessChannelMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) ProcessEnvironment() *QProcessEnvironment {
	if ptr.Pointer() != nil {
		tmpValue := NewQProcessEnvironmentFromPointer(C.QProcess_ProcessEnvironment(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QProcessEnvironment).DestroyQProcessEnvironment)
		return tmpValue
	}
	return nil
}

func (ptr *QProcess) ProcessId() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QProcess_ProcessId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) Program() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QProcess_Program(ptr.Pointer()))
	}
	return ""
}

func (ptr *QProcess) ReadAllStandardError() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QProcess_ReadAllStandardError(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QProcess) ReadAllStandardOutput() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QProcess_ReadAllStandardOutput(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QProcess) ReadChannel() QProcess__ProcessChannel {
	if ptr.Pointer() != nil {
		return QProcess__ProcessChannel(C.QProcess_ReadChannel(ptr.Pointer()))
	}
	return 0
}

//export callbackQProcess_ReadData
func callbackQProcess_ReadData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, maxlen C.longlong) C.longlong {
	if signal := qt.GetSignal(ptr, "readData"); signal != nil {
		retS := cGoUnpackString(data)
		ret := C.longlong((*(*func(*string, int64) int64)(signal))(&retS, int64(maxlen)))
		if ret > 0 {
			C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&retS)).Data), C.size_t(ret))
		}
		return ret
	}
	retS := cGoUnpackString(data)
	ret := C.longlong(NewQProcessFromPointer(ptr).ReadDataDefault(&retS, int64(maxlen)))
	if ret > 0 {
		C.memcpy(unsafe.Pointer(data.data), unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&retS)).Data), C.size_t(ret))
	}
	return ret
}

func (ptr *QProcess) ConnectReadData(f func(data *string, maxlen int64) int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "readData"); signal != nil {
			f := func(data *string, maxlen int64) int64 {
				(*(*func(*string, int64) int64)(signal))(data, maxlen)
				return f(data, maxlen)
			}
			qt.ConnectSignal(ptr.Pointer(), "readData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "readData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectReadData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "readData")
	}
}

func (ptr *QProcess) ReadData(data *string, maxlen int64) int64 {
	if ptr.Pointer() != nil {
		dataC := C.CString(strings.Repeat("0", int(maxlen)))
		defer C.free(unsafe.Pointer(dataC))
		ret := int64(C.QProcess_ReadData(ptr.Pointer(), dataC, C.longlong(maxlen)))
		if ret > 0 {
			*data = C.GoStringN(dataC, C.int(ret))
		}
		return ret
	}
	return 0
}

func (ptr *QProcess) ReadDataDefault(data *string, maxlen int64) int64 {
	if ptr.Pointer() != nil {
		dataC := C.CString(strings.Repeat("0", int(maxlen)))
		defer C.free(unsafe.Pointer(dataC))
		ret := int64(C.QProcess_ReadDataDefault(ptr.Pointer(), dataC, C.longlong(maxlen)))
		if ret > 0 {
			*data = C.GoStringN(dataC, C.int(ret))
		}
		return ret
	}
	return 0
}

//export callbackQProcess_ReadyReadStandardError
func callbackQProcess_ReadyReadStandardError(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "readyReadStandardError"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QProcess) ConnectReadyReadStandardError(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "readyReadStandardError") {
			C.QProcess_ConnectReadyReadStandardError(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "readyReadStandardError")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "readyReadStandardError"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "readyReadStandardError", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "readyReadStandardError", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectReadyReadStandardError() {
	if ptr.Pointer() != nil {
		C.QProcess_DisconnectReadyReadStandardError(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "readyReadStandardError")
	}
}

//export callbackQProcess_ReadyReadStandardOutput
func callbackQProcess_ReadyReadStandardOutput(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "readyReadStandardOutput"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QProcess) ConnectReadyReadStandardOutput(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "readyReadStandardOutput") {
			C.QProcess_ConnectReadyReadStandardOutput(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "readyReadStandardOutput")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "readyReadStandardOutput"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "readyReadStandardOutput", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "readyReadStandardOutput", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectReadyReadStandardOutput() {
	if ptr.Pointer() != nil {
		C.QProcess_DisconnectReadyReadStandardOutput(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "readyReadStandardOutput")
	}
}

func (ptr *QProcess) SetArguments(arguments []string) {
	if ptr.Pointer() != nil {
		argumentsC := C.CString(strings.Join(arguments, "¡¦!"))
		defer C.free(unsafe.Pointer(argumentsC))
		C.QProcess_SetArguments(ptr.Pointer(), C.struct_QtCore_PackedString{data: argumentsC, len: C.longlong(len(strings.Join(arguments, "¡¦!")))})
	}
}

func (ptr *QProcess) SetInputChannelMode(mode QProcess__InputChannelMode) {
	if ptr.Pointer() != nil {
		C.QProcess_SetInputChannelMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QProcess) SetNativeArguments(arguments string) {
	if ptr.Pointer() != nil {
		var argumentsC *C.char
		if arguments != "" {
			argumentsC = C.CString(arguments)
			defer C.free(unsafe.Pointer(argumentsC))
		}
		C.QProcess_SetNativeArguments(ptr.Pointer(), C.struct_QtCore_PackedString{data: argumentsC, len: C.longlong(len(arguments))})
	}
}

func (ptr *QProcess) SetProcessChannelMode(mode QProcess__ProcessChannelMode) {
	if ptr.Pointer() != nil {
		C.QProcess_SetProcessChannelMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QProcess) SetProcessEnvironment(environment QProcessEnvironment_ITF) {
	if ptr.Pointer() != nil {
		C.QProcess_SetProcessEnvironment(ptr.Pointer(), PointerFromQProcessEnvironment(environment))
	}
}

func (ptr *QProcess) SetProcessState(state QProcess__ProcessState) {
	if ptr.Pointer() != nil {
		C.QProcess_SetProcessState(ptr.Pointer(), C.longlong(state))
	}
}

func (ptr *QProcess) SetProgram(program string) {
	if ptr.Pointer() != nil {
		var programC *C.char
		if program != "" {
			programC = C.CString(program)
			defer C.free(unsafe.Pointer(programC))
		}
		C.QProcess_SetProgram(ptr.Pointer(), C.struct_QtCore_PackedString{data: programC, len: C.longlong(len(program))})
	}
}

func (ptr *QProcess) SetReadChannel(channel QProcess__ProcessChannel) {
	if ptr.Pointer() != nil {
		C.QProcess_SetReadChannel(ptr.Pointer(), C.longlong(channel))
	}
}

func (ptr *QProcess) SetStandardErrorFile(fileName string, mode QIODevice__OpenModeFlag) {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		C.QProcess_SetStandardErrorFile(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(mode))
	}
}

func (ptr *QProcess) SetStandardInputFile(fileName string) {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		C.QProcess_SetStandardInputFile(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))})
	}
}

func (ptr *QProcess) SetStandardOutputFile(fileName string, mode QIODevice__OpenModeFlag) {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		C.QProcess_SetStandardOutputFile(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(mode))
	}
}

func (ptr *QProcess) SetStandardOutputProcess(destination QProcess_ITF) {
	if ptr.Pointer() != nil {
		C.QProcess_SetStandardOutputProcess(ptr.Pointer(), PointerFromQProcess(destination))
	}
}

func (ptr *QProcess) SetWorkingDirectory(dir string) {
	if ptr.Pointer() != nil {
		var dirC *C.char
		if dir != "" {
			dirC = C.CString(dir)
			defer C.free(unsafe.Pointer(dirC))
		}
		C.QProcess_SetWorkingDirectory(ptr.Pointer(), C.struct_QtCore_PackedString{data: dirC, len: C.longlong(len(dir))})
	}
}

//export callbackQProcess_SetupChildProcess
func callbackQProcess_SetupChildProcess(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setupChildProcess"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProcessFromPointer(ptr).SetupChildProcessDefault()
	}
}

func (ptr *QProcess) ConnectSetupChildProcess(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setupChildProcess"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "setupChildProcess", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setupChildProcess", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectSetupChildProcess() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setupChildProcess")
	}
}

func (ptr *QProcess) SetupChildProcess() {
	if ptr.Pointer() != nil {
		C.QProcess_SetupChildProcess(ptr.Pointer())
	}
}

func (ptr *QProcess) SetupChildProcessDefault() {
	if ptr.Pointer() != nil {
		C.QProcess_SetupChildProcessDefault(ptr.Pointer())
	}
}

func (ptr *QProcess) Start(program string, arguments []string, mode QIODevice__OpenModeFlag) {
	if ptr.Pointer() != nil {
		var programC *C.char
		if program != "" {
			programC = C.CString(program)
			defer C.free(unsafe.Pointer(programC))
		}
		argumentsC := C.CString(strings.Join(arguments, "¡¦!"))
		defer C.free(unsafe.Pointer(argumentsC))
		C.QProcess_Start(ptr.Pointer(), C.struct_QtCore_PackedString{data: programC, len: C.longlong(len(program))}, C.struct_QtCore_PackedString{data: argumentsC, len: C.longlong(len(strings.Join(arguments, "¡¦!")))}, C.longlong(mode))
	}
}

func (ptr *QProcess) Start2(command string, mode QIODevice__OpenModeFlag) {
	if ptr.Pointer() != nil {
		var commandC *C.char
		if command != "" {
			commandC = C.CString(command)
			defer C.free(unsafe.Pointer(commandC))
		}
		C.QProcess_Start2(ptr.Pointer(), C.struct_QtCore_PackedString{data: commandC, len: C.longlong(len(command))}, C.longlong(mode))
	}
}

func (ptr *QProcess) Start3(mode QIODevice__OpenModeFlag) {
	if ptr.Pointer() != nil {
		C.QProcess_Start3(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QProcess) StartDetached(pid int64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QProcess_StartDetached(ptr.Pointer(), C.longlong(pid))) != 0
	}
	return false
}

func QProcess_StartDetached2(program string, arguments []string, workingDirectory string, pid int64) bool {
	var programC *C.char
	if program != "" {
		programC = C.CString(program)
		defer C.free(unsafe.Pointer(programC))
	}
	argumentsC := C.CString(strings.Join(arguments, "¡¦!"))
	defer C.free(unsafe.Pointer(argumentsC))
	var workingDirectoryC *C.char
	if workingDirectory != "" {
		workingDirectoryC = C.CString(workingDirectory)
		defer C.free(unsafe.Pointer(workingDirectoryC))
	}
	return int8(C.QProcess_QProcess_StartDetached2(C.struct_QtCore_PackedString{data: programC, len: C.longlong(len(program))}, C.struct_QtCore_PackedString{data: argumentsC, len: C.longlong(len(strings.Join(arguments, "¡¦!")))}, C.struct_QtCore_PackedString{data: workingDirectoryC, len: C.longlong(len(workingDirectory))}, C.longlong(pid))) != 0
}

func (ptr *QProcess) StartDetached2(program string, arguments []string, workingDirectory string, pid int64) bool {
	var programC *C.char
	if program != "" {
		programC = C.CString(program)
		defer C.free(unsafe.Pointer(programC))
	}
	argumentsC := C.CString(strings.Join(arguments, "¡¦!"))
	defer C.free(unsafe.Pointer(argumentsC))
	var workingDirectoryC *C.char
	if workingDirectory != "" {
		workingDirectoryC = C.CString(workingDirectory)
		defer C.free(unsafe.Pointer(workingDirectoryC))
	}
	return int8(C.QProcess_QProcess_StartDetached2(C.struct_QtCore_PackedString{data: programC, len: C.longlong(len(program))}, C.struct_QtCore_PackedString{data: argumentsC, len: C.longlong(len(strings.Join(arguments, "¡¦!")))}, C.struct_QtCore_PackedString{data: workingDirectoryC, len: C.longlong(len(workingDirectory))}, C.longlong(pid))) != 0
}

func QProcess_StartDetached3(command string) bool {
	var commandC *C.char
	if command != "" {
		commandC = C.CString(command)
		defer C.free(unsafe.Pointer(commandC))
	}
	return int8(C.QProcess_QProcess_StartDetached3(C.struct_QtCore_PackedString{data: commandC, len: C.longlong(len(command))})) != 0
}

func (ptr *QProcess) StartDetached3(command string) bool {
	var commandC *C.char
	if command != "" {
		commandC = C.CString(command)
		defer C.free(unsafe.Pointer(commandC))
	}
	return int8(C.QProcess_QProcess_StartDetached3(C.struct_QtCore_PackedString{data: commandC, len: C.longlong(len(command))})) != 0
}

//export callbackQProcess_Started
func callbackQProcess_Started(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "started"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QProcess) ConnectStarted(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "started") {
			C.QProcess_ConnectStarted(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "started")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "started"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "started", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "started", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectStarted() {
	if ptr.Pointer() != nil {
		C.QProcess_DisconnectStarted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "started")
	}
}

func (ptr *QProcess) State() QProcess__ProcessState {
	if ptr.Pointer() != nil {
		return QProcess__ProcessState(C.QProcess_State(ptr.Pointer()))
	}
	return 0
}

//export callbackQProcess_StateChanged
func callbackQProcess_StateChanged(ptr unsafe.Pointer, newState C.longlong) {
	if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
		(*(*func(QProcess__ProcessState))(signal))(QProcess__ProcessState(newState))
	}

}

func (ptr *QProcess) ConnectStateChanged(f func(newState QProcess__ProcessState)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
			C.QProcess_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
			f := func(newState QProcess__ProcessState) {
				(*(*func(QProcess__ProcessState))(signal))(newState)
				f(newState)
			}
			qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectStateChanged() {
	if ptr.Pointer() != nil {
		C.QProcess_DisconnectStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
	}
}

func QProcess_SystemEnvironment() []string {
	return unpackStringList(cGoUnpackString(C.QProcess_QProcess_SystemEnvironment()))
}

func (ptr *QProcess) SystemEnvironment() []string {
	return unpackStringList(cGoUnpackString(C.QProcess_QProcess_SystemEnvironment()))
}

//export callbackQProcess_Terminate
func callbackQProcess_Terminate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "terminate"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProcessFromPointer(ptr).TerminateDefault()
	}
}

func (ptr *QProcess) ConnectTerminate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "terminate"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "terminate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "terminate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectTerminate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "terminate")
	}
}

func (ptr *QProcess) Terminate() {
	if ptr.Pointer() != nil {
		C.QProcess_Terminate(ptr.Pointer())
	}
}

func (ptr *QProcess) TerminateDefault() {
	if ptr.Pointer() != nil {
		C.QProcess_TerminateDefault(ptr.Pointer())
	}
}

func (ptr *QProcess) WaitForFinished(msecs int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QProcess_WaitForFinished(ptr.Pointer(), C.int(int32(msecs)))) != 0
	}
	return false
}

func (ptr *QProcess) WaitForStarted(msecs int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QProcess_WaitForStarted(ptr.Pointer(), C.int(int32(msecs)))) != 0
	}
	return false
}

func (ptr *QProcess) WorkingDirectory() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QProcess_WorkingDirectory(ptr.Pointer()))
	}
	return ""
}

//export callbackQProcess_WriteData
func callbackQProcess_WriteData(ptr unsafe.Pointer, data C.struct_QtCore_PackedString, l C.longlong) C.longlong {
	if signal := qt.GetSignal(ptr, "writeData"); signal != nil {
		return C.longlong((*(*func([]byte, int64) int64)(signal))(cGoUnpackBytes(data), int64(l)))
	}

	return C.longlong(NewQProcessFromPointer(ptr).WriteDataDefault(cGoUnpackBytes(data), int64(l)))
}

func (ptr *QProcess) ConnectWriteData(f func(data []byte, l int64) int64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "writeData"); signal != nil {
			f := func(data []byte, l int64) int64 {
				(*(*func([]byte, int64) int64)(signal))(data, l)
				return f(data, l)
			}
			qt.ConnectSignal(ptr.Pointer(), "writeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "writeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectWriteData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "writeData")
	}
}

func (ptr *QProcess) WriteData(data []byte, l int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QProcess_WriteData(ptr.Pointer(), dataC, C.longlong(l)))
	}
	return 0
}

func (ptr *QProcess) WriteDataDefault(data []byte, l int64) int64 {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if len(data) != 0 {
			dataC = (*C.char)(unsafe.Pointer(&data[0]))
		}
		return int64(C.QProcess_WriteDataDefault(ptr.Pointer(), dataC, C.longlong(l)))
	}
	return 0
}

//export callbackQProcess_DestroyQProcess
func callbackQProcess_DestroyQProcess(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QProcess"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProcessFromPointer(ptr).DestroyQProcessDefault()
	}
}

func (ptr *QProcess) ConnectDestroyQProcess(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QProcess"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QProcess", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QProcess", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProcess) DisconnectDestroyQProcess() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QProcess")
	}
}

func (ptr *QProcess) DestroyQProcess() {
	if ptr.Pointer() != nil {
		C.QProcess_DestroyQProcess(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QProcess) DestroyQProcessDefault() {
	if ptr.Pointer() != nil {
		C.QProcess_DestroyQProcessDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QProcessEnvironment struct {
	ptr unsafe.Pointer
}

type QProcessEnvironment_ITF interface {
	QProcessEnvironment_PTR() *QProcessEnvironment
}

func (ptr *QProcessEnvironment) QProcessEnvironment_PTR() *QProcessEnvironment {
	return ptr
}

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

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

func PointerFromQProcessEnvironment(ptr QProcessEnvironment_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QProcessEnvironment_PTR().Pointer()
	}
	return nil
}

func NewQProcessEnvironmentFromPointer(ptr unsafe.Pointer) (n *QProcessEnvironment) {
	n = new(QProcessEnvironment)
	n.SetPointer(ptr)
	return
}
func NewQProcessEnvironment() *QProcessEnvironment {
	tmpValue := NewQProcessEnvironmentFromPointer(C.QProcessEnvironment_NewQProcessEnvironment())
	runtime.SetFinalizer(tmpValue, (*QProcessEnvironment).DestroyQProcessEnvironment)
	return tmpValue
}

func NewQProcessEnvironment2(other QProcessEnvironment_ITF) *QProcessEnvironment {
	tmpValue := NewQProcessEnvironmentFromPointer(C.QProcessEnvironment_NewQProcessEnvironment2(PointerFromQProcessEnvironment(other)))
	runtime.SetFinalizer(tmpValue, (*QProcessEnvironment).DestroyQProcessEnvironment)
	return tmpValue
}

func (ptr *QProcessEnvironment) Clear() {
	if ptr.Pointer() != nil {
		C.QProcessEnvironment_Clear(ptr.Pointer())
	}
}

func (ptr *QProcessEnvironment) Contains(name string) bool {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int8(C.QProcessEnvironment_Contains(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})) != 0
	}
	return false
}

func (ptr *QProcessEnvironment) Insert(name string, value string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		var valueC *C.char
		if value != "" {
			valueC = C.CString(value)
			defer C.free(unsafe.Pointer(valueC))
		}
		C.QProcessEnvironment_Insert(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.struct_QtCore_PackedString{data: valueC, len: C.longlong(len(value))})
	}
}

func (ptr *QProcessEnvironment) Insert2(e QProcessEnvironment_ITF) {
	if ptr.Pointer() != nil {
		C.QProcessEnvironment_Insert2(ptr.Pointer(), PointerFromQProcessEnvironment(e))
	}
}

func (ptr *QProcessEnvironment) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QProcessEnvironment_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QProcessEnvironment) Keys() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QProcessEnvironment_Keys(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QProcessEnvironment) Remove(name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QProcessEnvironment_Remove(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

func (ptr *QProcessEnvironment) Swap(other QProcessEnvironment_ITF) {
	if ptr.Pointer() != nil {
		C.QProcessEnvironment_Swap(ptr.Pointer(), PointerFromQProcessEnvironment(other))
	}
}

func QProcessEnvironment_SystemEnvironment() *QProcessEnvironment {
	tmpValue := NewQProcessEnvironmentFromPointer(C.QProcessEnvironment_QProcessEnvironment_SystemEnvironment())
	runtime.SetFinalizer(tmpValue, (*QProcessEnvironment).DestroyQProcessEnvironment)
	return tmpValue
}

func (ptr *QProcessEnvironment) SystemEnvironment() *QProcessEnvironment {
	tmpValue := NewQProcessEnvironmentFromPointer(C.QProcessEnvironment_QProcessEnvironment_SystemEnvironment())
	runtime.SetFinalizer(tmpValue, (*QProcessEnvironment).DestroyQProcessEnvironment)
	return tmpValue
}

func (ptr *QProcessEnvironment) ToStringList() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QProcessEnvironment_ToStringList(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QProcessEnvironment) Value(name string, defaultValue string) string {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		var defaultValueC *C.char
		if defaultValue != "" {
			defaultValueC = C.CString(defaultValue)
			defer C.free(unsafe.Pointer(defaultValueC))
		}
		return cGoUnpackString(C.QProcessEnvironment_Value(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.struct_QtCore_PackedString{data: defaultValueC, len: C.longlong(len(defaultValue))}))
	}
	return ""
}

func (ptr *QProcessEnvironment) DestroyQProcessEnvironment() {
	if ptr.Pointer() != nil {
		C.QProcessEnvironment_DestroyQProcessEnvironment(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QPropertyAnimation struct {
	QVariantAnimation
}

type QPropertyAnimation_ITF interface {
	QVariantAnimation_ITF
	QPropertyAnimation_PTR() *QPropertyAnimation
}

func (ptr *QPropertyAnimation) QPropertyAnimation_PTR() *QPropertyAnimation {
	return ptr
}

func (ptr *QPropertyAnimation) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QVariantAnimation_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQPropertyAnimation(ptr QPropertyAnimation_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPropertyAnimation_PTR().Pointer()
	}
	return nil
}

func NewQPropertyAnimationFromPointer(ptr unsafe.Pointer) (n *QPropertyAnimation) {
	n = new(QPropertyAnimation)
	n.SetPointer(ptr)
	return
}
func NewQPropertyAnimation(parent QObject_ITF) *QPropertyAnimation {
	tmpValue := NewQPropertyAnimationFromPointer(C.QPropertyAnimation_NewQPropertyAnimation(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQPropertyAnimation2(target QObject_ITF, propertyName QByteArray_ITF, parent QObject_ITF) *QPropertyAnimation {
	tmpValue := NewQPropertyAnimationFromPointer(C.QPropertyAnimation_NewQPropertyAnimation2(PointerFromQObject(target), PointerFromQByteArray(propertyName), PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QPropertyAnimation) PropertyName() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QPropertyAnimation_PropertyName(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QPropertyAnimation) SetPropertyName(propertyName QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QPropertyAnimation_SetPropertyName(ptr.Pointer(), PointerFromQByteArray(propertyName))
	}
}

func (ptr *QPropertyAnimation) SetTargetObject(target QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QPropertyAnimation_SetTargetObject(ptr.Pointer(), PointerFromQObject(target))
	}
}

func (ptr *QPropertyAnimation) TargetObject() *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QPropertyAnimation_TargetObject(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQPropertyAnimation_DestroyQPropertyAnimation
func callbackQPropertyAnimation_DestroyQPropertyAnimation(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QPropertyAnimation"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPropertyAnimationFromPointer(ptr).DestroyQPropertyAnimationDefault()
	}
}

func (ptr *QPropertyAnimation) ConnectDestroyQPropertyAnimation(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QPropertyAnimation"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QPropertyAnimation", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QPropertyAnimation", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPropertyAnimation) DisconnectDestroyQPropertyAnimation() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QPropertyAnimation")
	}
}

func (ptr *QPropertyAnimation) DestroyQPropertyAnimation() {
	if ptr.Pointer() != nil {
		C.QPropertyAnimation_DestroyQPropertyAnimation(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPropertyAnimation) DestroyQPropertyAnimationDefault() {
	if ptr.Pointer() != nil {
		C.QPropertyAnimation_DestroyQPropertyAnimationDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QQueue struct {
	ptr unsafe.Pointer
}

type QQueue_ITF interface {
	QQueue_PTR() *QQueue
}

func (ptr *QQueue) QQueue_PTR() *QQueue {
	return ptr
}

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

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

func PointerFromQQueue(ptr QQueue_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQueue_PTR().Pointer()
	}
	return nil
}

func NewQQueueFromPointer(ptr unsafe.Pointer) (n *QQueue) {
	n = new(QQueue)
	n.SetPointer(ptr)
	return
}

func (ptr *QQueue) DestroyQQueue() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QRandomGenerator struct {
	ptr unsafe.Pointer
}

type QRandomGenerator_ITF interface {
	QRandomGenerator_PTR() *QRandomGenerator
}

func (ptr *QRandomGenerator) QRandomGenerator_PTR() *QRandomGenerator {
	return ptr
}

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

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

func PointerFromQRandomGenerator(ptr QRandomGenerator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRandomGenerator_PTR().Pointer()
	}
	return nil
}

func NewQRandomGeneratorFromPointer(ptr unsafe.Pointer) (n *QRandomGenerator) {
	n = new(QRandomGenerator)
	n.SetPointer(ptr)
	return
}

func (ptr *QRandomGenerator) DestroyQRandomGenerator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQRandomGenerator(seedValue uint) *QRandomGenerator {
	tmpValue := NewQRandomGeneratorFromPointer(C.QRandomGenerator_NewQRandomGenerator(C.uint(uint32(seedValue))))
	runtime.SetFinalizer(tmpValue, (*QRandomGenerator).DestroyQRandomGenerator)
	return tmpValue
}

func NewQRandomGenerator5(begin uint, end uint) *QRandomGenerator {
	tmpValue := NewQRandomGeneratorFromPointer(C.QRandomGenerator_NewQRandomGenerator5(C.uint(uint32(begin)), C.uint(uint32(end))))
	runtime.SetFinalizer(tmpValue, (*QRandomGenerator).DestroyQRandomGenerator)
	return tmpValue
}

func NewQRandomGenerator6(other QRandomGenerator_ITF) *QRandomGenerator {
	tmpValue := NewQRandomGeneratorFromPointer(C.QRandomGenerator_NewQRandomGenerator6(PointerFromQRandomGenerator(other)))
	runtime.SetFinalizer(tmpValue, (*QRandomGenerator).DestroyQRandomGenerator)
	return tmpValue
}

func (ptr *QRandomGenerator) Bounded(highest float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QRandomGenerator_Bounded(ptr.Pointer(), C.double(highest)))
	}
	return 0
}

func (ptr *QRandomGenerator) Bounded2(highest uint) uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QRandomGenerator_Bounded2(ptr.Pointer(), C.uint(uint32(highest)))))
	}
	return 0
}

func (ptr *QRandomGenerator) Bounded3(highest int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRandomGenerator_Bounded3(ptr.Pointer(), C.int(int32(highest)))))
	}
	return 0
}

func (ptr *QRandomGenerator) Bounded4(lowest uint, highest uint) uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QRandomGenerator_Bounded4(ptr.Pointer(), C.uint(uint32(lowest)), C.uint(uint32(highest)))))
	}
	return 0
}

func (ptr *QRandomGenerator) Bounded5(lowest int, highest int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRandomGenerator_Bounded5(ptr.Pointer(), C.int(int32(lowest)), C.int(int32(highest)))))
	}
	return 0
}

func (ptr *QRandomGenerator) Discard(z uint64) {
	if ptr.Pointer() != nil {
		C.QRandomGenerator_Discard(ptr.Pointer(), C.ulonglong(z))
	}
}

func (ptr *QRandomGenerator) Generate() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QRandomGenerator_Generate(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRandomGenerator) Generate64() uint64 {
	if ptr.Pointer() != nil {
		return uint64(C.QRandomGenerator_Generate64(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRandomGenerator) GenerateDouble() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QRandomGenerator_GenerateDouble(ptr.Pointer()))
	}
	return 0
}

func QRandomGenerator_Global() *QRandomGenerator {
	return NewQRandomGeneratorFromPointer(C.QRandomGenerator_QRandomGenerator_Global())
}

func (ptr *QRandomGenerator) Global() *QRandomGenerator {
	return NewQRandomGeneratorFromPointer(C.QRandomGenerator_QRandomGenerator_Global())
}

func QRandomGenerator_SecurelySeeded() *QRandomGenerator {
	tmpValue := NewQRandomGeneratorFromPointer(C.QRandomGenerator_QRandomGenerator_SecurelySeeded())
	runtime.SetFinalizer(tmpValue, (*QRandomGenerator).DestroyQRandomGenerator)
	return tmpValue
}

func (ptr *QRandomGenerator) SecurelySeeded() *QRandomGenerator {
	tmpValue := NewQRandomGeneratorFromPointer(C.QRandomGenerator_QRandomGenerator_SecurelySeeded())
	runtime.SetFinalizer(tmpValue, (*QRandomGenerator).DestroyQRandomGenerator)
	return tmpValue
}

func (ptr *QRandomGenerator) Seed(seed uint) {
	if ptr.Pointer() != nil {
		C.QRandomGenerator_Seed(ptr.Pointer(), C.uint(uint32(seed)))
	}
}

func QRandomGenerator_System() *QRandomGenerator {
	return NewQRandomGeneratorFromPointer(C.QRandomGenerator_QRandomGenerator_System())
}

func (ptr *QRandomGenerator) System() *QRandomGenerator {
	return NewQRandomGeneratorFromPointer(C.QRandomGenerator_QRandomGenerator_System())
}

type QRandomGenerator64 struct {
	QRandomGenerator
}

type QRandomGenerator64_ITF interface {
	QRandomGenerator_ITF
	QRandomGenerator64_PTR() *QRandomGenerator64
}

func (ptr *QRandomGenerator64) QRandomGenerator64_PTR() *QRandomGenerator64 {
	return ptr
}

func (ptr *QRandomGenerator64) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QRandomGenerator_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQRandomGenerator64(ptr QRandomGenerator64_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRandomGenerator64_PTR().Pointer()
	}
	return nil
}

func NewQRandomGenerator64FromPointer(ptr unsafe.Pointer) (n *QRandomGenerator64) {
	n = new(QRandomGenerator64)
	n.SetPointer(ptr)
	return
}

func (ptr *QRandomGenerator64) DestroyQRandomGenerator64() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QRandomGenerator64) Generate() uint64 {
	if ptr.Pointer() != nil {
		return uint64(C.QRandomGenerator64_Generate(ptr.Pointer()))
	}
	return 0
}

type QReadLocker struct {
	ptr unsafe.Pointer
}

type QReadLocker_ITF interface {
	QReadLocker_PTR() *QReadLocker
}

func (ptr *QReadLocker) QReadLocker_PTR() *QReadLocker {
	return ptr
}

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

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

func PointerFromQReadLocker(ptr QReadLocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QReadLocker_PTR().Pointer()
	}
	return nil
}

func NewQReadLockerFromPointer(ptr unsafe.Pointer) (n *QReadLocker) {
	n = new(QReadLocker)
	n.SetPointer(ptr)
	return
}
func NewQReadLocker(lock QReadWriteLock_ITF) *QReadLocker {
	tmpValue := NewQReadLockerFromPointer(C.QReadLocker_NewQReadLocker(PointerFromQReadWriteLock(lock)))
	runtime.SetFinalizer(tmpValue, (*QReadLocker).DestroyQReadLocker)
	return tmpValue
}

func (ptr *QReadLocker) ReadWriteLock() *QReadWriteLock {
	if ptr.Pointer() != nil {
		return NewQReadWriteLockFromPointer(C.QReadLocker_ReadWriteLock(ptr.Pointer()))
	}
	return nil
}

func (ptr *QReadLocker) Relock() {
	if ptr.Pointer() != nil {
		C.QReadLocker_Relock(ptr.Pointer())
	}
}

func (ptr *QReadLocker) Unlock() {
	if ptr.Pointer() != nil {
		C.QReadLocker_Unlock(ptr.Pointer())
	}
}

func (ptr *QReadLocker) DestroyQReadLocker() {
	if ptr.Pointer() != nil {
		C.QReadLocker_DestroyQReadLocker(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QReadWriteLock struct {
	ptr unsafe.Pointer
}

type QReadWriteLock_ITF interface {
	QReadWriteLock_PTR() *QReadWriteLock
}

func (ptr *QReadWriteLock) QReadWriteLock_PTR() *QReadWriteLock {
	return ptr
}

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

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

func PointerFromQReadWriteLock(ptr QReadWriteLock_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QReadWriteLock_PTR().Pointer()
	}
	return nil
}

func NewQReadWriteLockFromPointer(ptr unsafe.Pointer) (n *QReadWriteLock) {
	n = new(QReadWriteLock)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QReadWriteLock__RecursionMode
//QReadWriteLock::RecursionMode
type QReadWriteLock__RecursionMode int64

const (
	QReadWriteLock__NonRecursive QReadWriteLock__RecursionMode = QReadWriteLock__RecursionMode(0)
	QReadWriteLock__Recursive    QReadWriteLock__RecursionMode = QReadWriteLock__RecursionMode(1)
)

func NewQReadWriteLock(recursionMode QReadWriteLock__RecursionMode) *QReadWriteLock {
	tmpValue := NewQReadWriteLockFromPointer(C.QReadWriteLock_NewQReadWriteLock(C.longlong(recursionMode)))
	runtime.SetFinalizer(tmpValue, (*QReadWriteLock).DestroyQReadWriteLock)
	return tmpValue
}

func (ptr *QReadWriteLock) LockForRead() {
	if ptr.Pointer() != nil {
		C.QReadWriteLock_LockForRead(ptr.Pointer())
	}
}

func (ptr *QReadWriteLock) LockForWrite() {
	if ptr.Pointer() != nil {
		C.QReadWriteLock_LockForWrite(ptr.Pointer())
	}
}

func (ptr *QReadWriteLock) TryLockForRead() bool {
	if ptr.Pointer() != nil {
		return int8(C.QReadWriteLock_TryLockForRead(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QReadWriteLock) TryLockForRead2(timeout int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QReadWriteLock_TryLockForRead2(ptr.Pointer(), C.int(int32(timeout)))) != 0
	}
	return false
}

func (ptr *QReadWriteLock) TryLockForWrite() bool {
	if ptr.Pointer() != nil {
		return int8(C.QReadWriteLock_TryLockForWrite(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QReadWriteLock) TryLockForWrite2(timeout int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QReadWriteLock_TryLockForWrite2(ptr.Pointer(), C.int(int32(timeout)))) != 0
	}
	return false
}

func (ptr *QReadWriteLock) Unlock() {
	if ptr.Pointer() != nil {
		C.QReadWriteLock_Unlock(ptr.Pointer())
	}
}

func (ptr *QReadWriteLock) DestroyQReadWriteLock() {
	if ptr.Pointer() != nil {
		C.QReadWriteLock_DestroyQReadWriteLock(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QRect struct {
	ptr unsafe.Pointer
}

type QRect_ITF interface {
	QRect_PTR() *QRect
}

func (ptr *QRect) QRect_PTR() *QRect {
	return ptr
}

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

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

func PointerFromQRect(ptr QRect_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRect_PTR().Pointer()
	}
	return nil
}

func NewQRectFromPointer(ptr unsafe.Pointer) (n *QRect) {
	n = new(QRect)
	n.SetPointer(ptr)
	return
}

func (ptr *QRect) DestroyQRect() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQRect() *QRect {
	tmpValue := NewQRectFromPointer(C.QRect_NewQRect())
	runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
	return tmpValue
}

func NewQRect2(topLeft QPoint_ITF, bottomRight QPoint_ITF) *QRect {
	tmpValue := NewQRectFromPointer(C.QRect_NewQRect2(PointerFromQPoint(topLeft), PointerFromQPoint(bottomRight)))
	runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
	return tmpValue
}

func NewQRect3(topLeft QPoint_ITF, size QSize_ITF) *QRect {
	tmpValue := NewQRectFromPointer(C.QRect_NewQRect3(PointerFromQPoint(topLeft), PointerFromQSize(size)))
	runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
	return tmpValue
}

func NewQRect4(x int, y int, width int, height int) *QRect {
	tmpValue := NewQRectFromPointer(C.QRect_NewQRect4(C.int(int32(x)), C.int(int32(y)), C.int(int32(width)), C.int(int32(height))))
	runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
	return tmpValue
}

func (ptr *QRect) Adjust(dx1 int, dy1 int, dx2 int, dy2 int) {
	if ptr.Pointer() != nil {
		C.QRect_Adjust(ptr.Pointer(), C.int(int32(dx1)), C.int(int32(dy1)), C.int(int32(dx2)), C.int(int32(dy2)))
	}
}

func (ptr *QRect) Adjusted(dx1 int, dy1 int, dx2 int, dy2 int) *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRect_Adjusted(ptr.Pointer(), C.int(int32(dx1)), C.int(int32(dy1)), C.int(int32(dx2)), C.int(int32(dy2))))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Bottom() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRect_Bottom(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRect) BottomLeft() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QRect_BottomLeft(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) BottomRight() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QRect_BottomRight(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Center() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QRect_Center(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Contains(point QPoint_ITF, proper bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QRect_Contains(ptr.Pointer(), PointerFromQPoint(point), C.char(int8(qt.GoBoolToInt(proper))))) != 0
	}
	return false
}

func (ptr *QRect) Contains2(rectangle QRect_ITF, proper bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QRect_Contains2(ptr.Pointer(), PointerFromQRect(rectangle), C.char(int8(qt.GoBoolToInt(proper))))) != 0
	}
	return false
}

func (ptr *QRect) Contains3(x int, y int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QRect_Contains3(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)))) != 0
	}
	return false
}

func (ptr *QRect) Contains4(x int, y int, proper bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QRect_Contains4(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)), C.char(int8(qt.GoBoolToInt(proper))))) != 0
	}
	return false
}

func (ptr *QRect) GetCoords(x1 int, y1 int, x2 int, y2 int) {
	if ptr.Pointer() != nil {
		C.QRect_GetCoords(ptr.Pointer(), C.int(int32(x1)), C.int(int32(y1)), C.int(int32(x2)), C.int(int32(y2)))
	}
}

func (ptr *QRect) GetRect(x int, y int, width int, height int) {
	if ptr.Pointer() != nil {
		C.QRect_GetRect(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)), C.int(int32(width)), C.int(int32(height)))
	}
}

func (ptr *QRect) Height() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRect_Height(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRect) Intersected(rectangle QRect_ITF) *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRect_Intersected(ptr.Pointer(), PointerFromQRect(rectangle)))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Intersects(rectangle QRect_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QRect_Intersects(ptr.Pointer(), PointerFromQRect(rectangle))) != 0
	}
	return false
}

func (ptr *QRect) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRect_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRect) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRect_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRect) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRect_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRect) Left() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRect_Left(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRect) MarginsAdded(margins QMargins_ITF) *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRect_MarginsAdded(ptr.Pointer(), PointerFromQMargins(margins)))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) MarginsRemoved(margins QMargins_ITF) *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRect_MarginsRemoved(ptr.Pointer(), PointerFromQMargins(margins)))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) MoveBottom(y int) {
	if ptr.Pointer() != nil {
		C.QRect_MoveBottom(ptr.Pointer(), C.int(int32(y)))
	}
}

func (ptr *QRect) MoveBottomLeft(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_MoveBottomLeft(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveBottomRight(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_MoveBottomRight(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveCenter(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_MoveCenter(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveLeft(x int) {
	if ptr.Pointer() != nil {
		C.QRect_MoveLeft(ptr.Pointer(), C.int(int32(x)))
	}
}

func (ptr *QRect) MoveRight(x int) {
	if ptr.Pointer() != nil {
		C.QRect_MoveRight(ptr.Pointer(), C.int(int32(x)))
	}
}

func (ptr *QRect) MoveTo(x int, y int) {
	if ptr.Pointer() != nil {
		C.QRect_MoveTo(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)))
	}
}

func (ptr *QRect) MoveTo2(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_MoveTo2(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveTop(y int) {
	if ptr.Pointer() != nil {
		C.QRect_MoveTop(ptr.Pointer(), C.int(int32(y)))
	}
}

func (ptr *QRect) MoveTopLeft(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_MoveTopLeft(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveTopRight(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_MoveTopRight(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) Normalized() *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRect_Normalized(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Right() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRect_Right(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRect) SetBottom(y int) {
	if ptr.Pointer() != nil {
		C.QRect_SetBottom(ptr.Pointer(), C.int(int32(y)))
	}
}

func (ptr *QRect) SetBottomLeft(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_SetBottomLeft(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) SetBottomRight(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_SetBottomRight(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) SetCoords(x1 int, y1 int, x2 int, y2 int) {
	if ptr.Pointer() != nil {
		C.QRect_SetCoords(ptr.Pointer(), C.int(int32(x1)), C.int(int32(y1)), C.int(int32(x2)), C.int(int32(y2)))
	}
}

func (ptr *QRect) SetHeight(height int) {
	if ptr.Pointer() != nil {
		C.QRect_SetHeight(ptr.Pointer(), C.int(int32(height)))
	}
}

func (ptr *QRect) SetLeft(x int) {
	if ptr.Pointer() != nil {
		C.QRect_SetLeft(ptr.Pointer(), C.int(int32(x)))
	}
}

func (ptr *QRect) SetRect(x int, y int, width int, height int) {
	if ptr.Pointer() != nil {
		C.QRect_SetRect(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)), C.int(int32(width)), C.int(int32(height)))
	}
}

func (ptr *QRect) SetRight(x int) {
	if ptr.Pointer() != nil {
		C.QRect_SetRight(ptr.Pointer(), C.int(int32(x)))
	}
}

func (ptr *QRect) SetSize(size QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_SetSize(ptr.Pointer(), PointerFromQSize(size))
	}
}

func (ptr *QRect) SetTop(y int) {
	if ptr.Pointer() != nil {
		C.QRect_SetTop(ptr.Pointer(), C.int(int32(y)))
	}
}

func (ptr *QRect) SetTopLeft(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_SetTopLeft(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) SetTopRight(position QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_SetTopRight(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) SetWidth(width int) {
	if ptr.Pointer() != nil {
		C.QRect_SetWidth(ptr.Pointer(), C.int(int32(width)))
	}
}

func (ptr *QRect) SetX(x int) {
	if ptr.Pointer() != nil {
		C.QRect_SetX(ptr.Pointer(), C.int(int32(x)))
	}
}

func (ptr *QRect) SetY(y int) {
	if ptr.Pointer() != nil {
		C.QRect_SetY(ptr.Pointer(), C.int(int32(y)))
	}
}

func (ptr *QRect) Size() *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QRect_Size(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Top() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRect_Top(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRect) TopLeft() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QRect_TopLeft(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) TopRight() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QRect_TopRight(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Translate(dx int, dy int) {
	if ptr.Pointer() != nil {
		C.QRect_Translate(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy)))
	}
}

func (ptr *QRect) Translate2(offset QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QRect_Translate2(ptr.Pointer(), PointerFromQPoint(offset))
	}
}

func (ptr *QRect) Translated(dx int, dy int) *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRect_Translated(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy))))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Translated2(offset QPoint_ITF) *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRect_Translated2(ptr.Pointer(), PointerFromQPoint(offset)))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Transposed() *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRect_Transposed(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) United(rectangle QRect_ITF) *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRect_United(ptr.Pointer(), PointerFromQRect(rectangle)))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRect) Width() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRect_Width(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRect) X() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRect_X(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRect) Y() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRect_Y(ptr.Pointer())))
	}
	return 0
}

type QRectF struct {
	ptr unsafe.Pointer
}

type QRectF_ITF interface {
	QRectF_PTR() *QRectF
}

func (ptr *QRectF) QRectF_PTR() *QRectF {
	return ptr
}

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

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

func PointerFromQRectF(ptr QRectF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRectF_PTR().Pointer()
	}
	return nil
}

func NewQRectFFromPointer(ptr unsafe.Pointer) (n *QRectF) {
	n = new(QRectF)
	n.SetPointer(ptr)
	return
}

func (ptr *QRectF) DestroyQRectF() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQRectF() *QRectF {
	tmpValue := NewQRectFFromPointer(C.QRectF_NewQRectF())
	runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
	return tmpValue
}

func NewQRectF2(topLeft QPointF_ITF, size QSizeF_ITF) *QRectF {
	tmpValue := NewQRectFFromPointer(C.QRectF_NewQRectF2(PointerFromQPointF(topLeft), PointerFromQSizeF(size)))
	runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
	return tmpValue
}

func NewQRectF3(topLeft QPointF_ITF, bottomRight QPointF_ITF) *QRectF {
	tmpValue := NewQRectFFromPointer(C.QRectF_NewQRectF3(PointerFromQPointF(topLeft), PointerFromQPointF(bottomRight)))
	runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
	return tmpValue
}

func NewQRectF4(x float64, y float64, width float64, height float64) *QRectF {
	tmpValue := NewQRectFFromPointer(C.QRectF_NewQRectF4(C.double(x), C.double(y), C.double(width), C.double(height)))
	runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
	return tmpValue
}

func NewQRectF5(rectangle QRect_ITF) *QRectF {
	tmpValue := NewQRectFFromPointer(C.QRectF_NewQRectF5(PointerFromQRect(rectangle)))
	runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
	return tmpValue
}

func (ptr *QRectF) Adjust(dx1 float64, dy1 float64, dx2 float64, dy2 float64) {
	if ptr.Pointer() != nil {
		C.QRectF_Adjust(ptr.Pointer(), C.double(dx1), C.double(dy1), C.double(dx2), C.double(dy2))
	}
}

func (ptr *QRectF) Adjusted(dx1 float64, dy1 float64, dx2 float64, dy2 float64) *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QRectF_Adjusted(ptr.Pointer(), C.double(dx1), C.double(dy1), C.double(dx2), C.double(dy2)))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) Bottom() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QRectF_Bottom(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) BottomLeft() *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QRectF_BottomLeft(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) BottomRight() *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QRectF_BottomRight(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) Center() *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QRectF_Center(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) Contains(point QPointF_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QRectF_Contains(ptr.Pointer(), PointerFromQPointF(point))) != 0
	}
	return false
}

func (ptr *QRectF) Contains2(rectangle QRectF_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QRectF_Contains2(ptr.Pointer(), PointerFromQRectF(rectangle))) != 0
	}
	return false
}

func (ptr *QRectF) Contains3(x float64, y float64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QRectF_Contains3(ptr.Pointer(), C.double(x), C.double(y))) != 0
	}
	return false
}

func (ptr *QRectF) GetCoords(x1 float64, y1 float64, x2 float64, y2 float64) {
	if ptr.Pointer() != nil {
		C.QRectF_GetCoords(ptr.Pointer(), C.double(x1), C.double(y1), C.double(x2), C.double(y2))
	}
}

func (ptr *QRectF) GetRect(x float64, y float64, width float64, height float64) {
	if ptr.Pointer() != nil {
		C.QRectF_GetRect(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height))
	}
}

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

func (ptr *QRectF) Intersected(rectangle QRectF_ITF) *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QRectF_Intersected(ptr.Pointer(), PointerFromQRectF(rectangle)))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) Intersects(rectangle QRectF_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QRectF_Intersects(ptr.Pointer(), PointerFromQRectF(rectangle))) != 0
	}
	return false
}

func (ptr *QRectF) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRectF_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRectF) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRectF_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRectF) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRectF_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRectF) Left() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QRectF_Left(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) MarginsAdded(margins QMarginsF_ITF) *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QRectF_MarginsAdded(ptr.Pointer(), PointerFromQMarginsF(margins)))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) MarginsRemoved(margins QMarginsF_ITF) *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QRectF_MarginsRemoved(ptr.Pointer(), PointerFromQMarginsF(margins)))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) MoveBottom(y float64) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveBottom(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) MoveBottomLeft(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveBottomLeft(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveBottomRight(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveBottomRight(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveCenter(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveCenter(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveLeft(x float64) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveLeft(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) MoveRight(x float64) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveRight(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) MoveTo(x float64, y float64) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveTo(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QRectF) MoveTo2(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveTo2(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveTop(y float64) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveTop(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) MoveTopLeft(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveTopLeft(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveTopRight(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_MoveTopRight(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) Normalized() *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QRectF_Normalized(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) Right() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QRectF_Right(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) SetBottom(y float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetBottom(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) SetBottomLeft(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_SetBottomLeft(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) SetBottomRight(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_SetBottomRight(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) SetCoords(x1 float64, y1 float64, x2 float64, y2 float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetCoords(ptr.Pointer(), C.double(x1), C.double(y1), C.double(x2), C.double(y2))
	}
}

func (ptr *QRectF) SetHeight(height float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetHeight(ptr.Pointer(), C.double(height))
	}
}

func (ptr *QRectF) SetLeft(x float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetLeft(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) SetRect(x float64, y float64, width float64, height float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetRect(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height))
	}
}

func (ptr *QRectF) SetRight(x float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetRight(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) SetSize(size QSizeF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_SetSize(ptr.Pointer(), PointerFromQSizeF(size))
	}
}

func (ptr *QRectF) SetTop(y float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetTop(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) SetTopLeft(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_SetTopLeft(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) SetTopRight(position QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_SetTopRight(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) SetWidth(width float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QRectF) SetX(x float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetX(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) SetY(y float64) {
	if ptr.Pointer() != nil {
		C.QRectF_SetY(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) Size() *QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFFromPointer(C.QRectF_Size(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) ToAlignedRect() *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRectF_ToAlignedRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) ToRect() *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QRectF_ToRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) Top() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QRectF_Top(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) TopLeft() *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QRectF_TopLeft(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) TopRight() *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QRectF_TopRight(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) Translate(dx float64, dy float64) {
	if ptr.Pointer() != nil {
		C.QRectF_Translate(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

func (ptr *QRectF) Translate2(offset QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QRectF_Translate2(ptr.Pointer(), PointerFromQPointF(offset))
	}
}

func (ptr *QRectF) Translated(dx float64, dy float64) *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QRectF_Translated(ptr.Pointer(), C.double(dx), C.double(dy)))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) Translated2(offset QPointF_ITF) *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QRectF_Translated2(ptr.Pointer(), PointerFromQPointF(offset)))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) Transposed() *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QRectF_Transposed(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QRectF) United(rectangle QRectF_ITF) *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QRectF_United(ptr.Pointer(), PointerFromQRectF(rectangle)))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

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

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

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

type QRegExp struct {
	ptr unsafe.Pointer
}

type QRegExp_ITF interface {
	QRegExp_PTR() *QRegExp
}

func (ptr *QRegExp) QRegExp_PTR() *QRegExp {
	return ptr
}

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

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

func PointerFromQRegExp(ptr QRegExp_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegExp_PTR().Pointer()
	}
	return nil
}

func NewQRegExpFromPointer(ptr unsafe.Pointer) (n *QRegExp) {
	n = new(QRegExp)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QRegExp__PatternSyntax
//QRegExp::PatternSyntax
type QRegExp__PatternSyntax int64

const (
	QRegExp__RegExp         QRegExp__PatternSyntax = QRegExp__PatternSyntax(0)
	QRegExp__Wildcard       QRegExp__PatternSyntax = QRegExp__PatternSyntax(1)
	QRegExp__FixedString    QRegExp__PatternSyntax = QRegExp__PatternSyntax(2)
	QRegExp__RegExp2        QRegExp__PatternSyntax = QRegExp__PatternSyntax(3)
	QRegExp__WildcardUnix   QRegExp__PatternSyntax = QRegExp__PatternSyntax(4)
	QRegExp__W3CXmlSchema11 QRegExp__PatternSyntax = QRegExp__PatternSyntax(5)
)

//go:generate stringer -type=QRegExp__CaretMode
//QRegExp::CaretMode
type QRegExp__CaretMode int64

const (
	QRegExp__CaretAtZero    QRegExp__CaretMode = QRegExp__CaretMode(0)
	QRegExp__CaretAtOffset  QRegExp__CaretMode = QRegExp__CaretMode(1)
	QRegExp__CaretWontMatch QRegExp__CaretMode = QRegExp__CaretMode(2)
)

func NewQRegExp() *QRegExp {
	tmpValue := NewQRegExpFromPointer(C.QRegExp_NewQRegExp())
	runtime.SetFinalizer(tmpValue, (*QRegExp).DestroyQRegExp)
	return tmpValue
}

func NewQRegExp2(pattern string, cs Qt__CaseSensitivity, syntax QRegExp__PatternSyntax) *QRegExp {
	var patternC *C.char
	if pattern != "" {
		patternC = C.CString(pattern)
		defer C.free(unsafe.Pointer(patternC))
	}
	tmpValue := NewQRegExpFromPointer(C.QRegExp_NewQRegExp2(C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))}, C.longlong(cs), C.longlong(syntax)))
	runtime.SetFinalizer(tmpValue, (*QRegExp).DestroyQRegExp)
	return tmpValue
}

func NewQRegExp3(rx QRegExp_ITF) *QRegExp {
	tmpValue := NewQRegExpFromPointer(C.QRegExp_NewQRegExp3(PointerFromQRegExp(rx)))
	runtime.SetFinalizer(tmpValue, (*QRegExp).DestroyQRegExp)
	return tmpValue
}

func (ptr *QRegExp) Cap(nth int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QRegExp_Cap(ptr.Pointer(), C.int(int32(nth))))
	}
	return ""
}

func (ptr *QRegExp) CaptureCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegExp_CaptureCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRegExp) CapturedTexts() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QRegExp_CapturedTexts(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QRegExp) CaseSensitivity() Qt__CaseSensitivity {
	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QRegExp_CaseSensitivity(ptr.Pointer()))
	}
	return 0
}

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

func QRegExp_Escape(str string) string {
	var strC *C.char
	if str != "" {
		strC = C.CString(str)
		defer C.free(unsafe.Pointer(strC))
	}
	return cGoUnpackString(C.QRegExp_QRegExp_Escape(C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
}

func (ptr *QRegExp) Escape(str string) string {
	var strC *C.char
	if str != "" {
		strC = C.CString(str)
		defer C.free(unsafe.Pointer(strC))
	}
	return cGoUnpackString(C.QRegExp_QRegExp_Escape(C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
}

func (ptr *QRegExp) ExactMatch(str string) bool {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int8(C.QRegExp_ExactMatch(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))})) != 0
	}
	return false
}

func (ptr *QRegExp) IndexIn(str string, offset int, caretMode QRegExp__CaretMode) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QRegExp_IndexIn(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.int(int32(offset)), C.longlong(caretMode))))
	}
	return 0
}

func (ptr *QRegExp) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRegExp_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRegExp) IsMinimal() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRegExp_IsMinimal(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRegExp) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRegExp_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRegExp) LastIndexIn(str string, offset int, caretMode QRegExp__CaretMode) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QRegExp_LastIndexIn(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.int(int32(offset)), C.longlong(caretMode))))
	}
	return 0
}

func (ptr *QRegExp) MatchedLength() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegExp_MatchedLength(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRegExp) Pattern() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QRegExp_Pattern(ptr.Pointer()))
	}
	return ""
}

func (ptr *QRegExp) PatternSyntax() QRegExp__PatternSyntax {
	if ptr.Pointer() != nil {
		return QRegExp__PatternSyntax(C.QRegExp_PatternSyntax(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegExp) Pos(nth int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegExp_Pos(ptr.Pointer(), C.int(int32(nth)))))
	}
	return 0
}

func (ptr *QRegExp) SetCaseSensitivity(cs Qt__CaseSensitivity) {
	if ptr.Pointer() != nil {
		C.QRegExp_SetCaseSensitivity(ptr.Pointer(), C.longlong(cs))
	}
}

func (ptr *QRegExp) SetMinimal(minimal bool) {
	if ptr.Pointer() != nil {
		C.QRegExp_SetMinimal(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(minimal))))
	}
}

func (ptr *QRegExp) SetPattern(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QRegExp_SetPattern(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

func (ptr *QRegExp) SetPatternSyntax(syntax QRegExp__PatternSyntax) {
	if ptr.Pointer() != nil {
		C.QRegExp_SetPatternSyntax(ptr.Pointer(), C.longlong(syntax))
	}
}

func (ptr *QRegExp) Swap(other QRegExp_ITF) {
	if ptr.Pointer() != nil {
		C.QRegExp_Swap(ptr.Pointer(), PointerFromQRegExp(other))
	}
}

func (ptr *QRegExp) DestroyQRegExp() {
	if ptr.Pointer() != nil {
		C.QRegExp_DestroyQRegExp(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QRegularExpression struct {
	ptr unsafe.Pointer
}

type QRegularExpression_ITF interface {
	QRegularExpression_PTR() *QRegularExpression
}

func (ptr *QRegularExpression) QRegularExpression_PTR() *QRegularExpression {
	return ptr
}

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

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

func PointerFromQRegularExpression(ptr QRegularExpression_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegularExpression_PTR().Pointer()
	}
	return nil
}

func NewQRegularExpressionFromPointer(ptr unsafe.Pointer) (n *QRegularExpression) {
	n = new(QRegularExpression)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QRegularExpression__PatternOption
//QRegularExpression::PatternOption
type QRegularExpression__PatternOption int64

const (
	QRegularExpression__NoPatternOption                 QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0000)
	QRegularExpression__CaseInsensitiveOption           QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0001)
	QRegularExpression__DotMatchesEverythingOption      QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0002)
	QRegularExpression__MultilineOption                 QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0004)
	QRegularExpression__ExtendedPatternSyntaxOption     QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0008)
	QRegularExpression__InvertedGreedinessOption        QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0010)
	QRegularExpression__DontCaptureOption               QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0020)
	QRegularExpression__UseUnicodePropertiesOption      QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0040)
	QRegularExpression__OptimizeOnFirstUsageOption      QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0080)
	QRegularExpression__DontAutomaticallyOptimizeOption QRegularExpression__PatternOption = QRegularExpression__PatternOption(0x0100)
)

//go:generate stringer -type=QRegularExpression__MatchType
//QRegularExpression::MatchType
type QRegularExpression__MatchType int64

const (
	QRegularExpression__NormalMatch                QRegularExpression__MatchType = QRegularExpression__MatchType(0)
	QRegularExpression__PartialPreferCompleteMatch QRegularExpression__MatchType = QRegularExpression__MatchType(1)
	QRegularExpression__PartialPreferFirstMatch    QRegularExpression__MatchType = QRegularExpression__MatchType(2)
	QRegularExpression__NoMatch                    QRegularExpression__MatchType = QRegularExpression__MatchType(3)
)

//go:generate stringer -type=QRegularExpression__MatchOption
//QRegularExpression::MatchOption
type QRegularExpression__MatchOption int64

const (
	QRegularExpression__NoMatchOption                     QRegularExpression__MatchOption = QRegularExpression__MatchOption(0x0000)
	QRegularExpression__AnchoredMatchOption               QRegularExpression__MatchOption = QRegularExpression__MatchOption(0x0001)
	QRegularExpression__DontCheckSubjectStringMatchOption QRegularExpression__MatchOption = QRegularExpression__MatchOption(0x0002)
)

func NewQRegularExpression() *QRegularExpression {
	tmpValue := NewQRegularExpressionFromPointer(C.QRegularExpression_NewQRegularExpression())
	runtime.SetFinalizer(tmpValue, (*QRegularExpression).DestroyQRegularExpression)
	return tmpValue
}

func NewQRegularExpression2(pattern string, options QRegularExpression__PatternOption) *QRegularExpression {
	var patternC *C.char
	if pattern != "" {
		patternC = C.CString(pattern)
		defer C.free(unsafe.Pointer(patternC))
	}
	tmpValue := NewQRegularExpressionFromPointer(C.QRegularExpression_NewQRegularExpression2(C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))}, C.longlong(options)))
	runtime.SetFinalizer(tmpValue, (*QRegularExpression).DestroyQRegularExpression)
	return tmpValue
}

func NewQRegularExpression3(re QRegularExpression_ITF) *QRegularExpression {
	tmpValue := NewQRegularExpressionFromPointer(C.QRegularExpression_NewQRegularExpression3(PointerFromQRegularExpression(re)))
	runtime.SetFinalizer(tmpValue, (*QRegularExpression).DestroyQRegularExpression)
	return tmpValue
}

func QRegularExpression_AnchoredPattern(expression string) string {
	var expressionC *C.char
	if expression != "" {
		expressionC = C.CString(expression)
		defer C.free(unsafe.Pointer(expressionC))
	}
	return cGoUnpackString(C.QRegularExpression_QRegularExpression_AnchoredPattern(C.struct_QtCore_PackedString{data: expressionC, len: C.longlong(len(expression))}))
}

func (ptr *QRegularExpression) AnchoredPattern(expression string) string {
	var expressionC *C.char
	if expression != "" {
		expressionC = C.CString(expression)
		defer C.free(unsafe.Pointer(expressionC))
	}
	return cGoUnpackString(C.QRegularExpression_QRegularExpression_AnchoredPattern(C.struct_QtCore_PackedString{data: expressionC, len: C.longlong(len(expression))}))
}

func (ptr *QRegularExpression) CaptureCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegularExpression_CaptureCount(ptr.Pointer())))
	}
	return 0
}

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

func QRegularExpression_Escape(str string) string {
	var strC *C.char
	if str != "" {
		strC = C.CString(str)
		defer C.free(unsafe.Pointer(strC))
	}
	return cGoUnpackString(C.QRegularExpression_QRegularExpression_Escape(C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
}

func (ptr *QRegularExpression) Escape(str string) string {
	var strC *C.char
	if str != "" {
		strC = C.CString(str)
		defer C.free(unsafe.Pointer(strC))
	}
	return cGoUnpackString(C.QRegularExpression_QRegularExpression_Escape(C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
}

func (ptr *QRegularExpression) GlobalMatch(subject string, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatchIterator {
	if ptr.Pointer() != nil {
		var subjectC *C.char
		if subject != "" {
			subjectC = C.CString(subject)
			defer C.free(unsafe.Pointer(subjectC))
		}
		return NewQRegularExpressionMatchIteratorFromPointer(C.QRegularExpression_GlobalMatch(ptr.Pointer(), C.struct_QtCore_PackedString{data: subjectC, len: C.longlong(len(subject))}, C.int(int32(offset)), C.longlong(matchType), C.longlong(matchOptions)))
	}
	return nil
}

func (ptr *QRegularExpression) GlobalMatch2(subjectRef QStringRef_ITF, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatchIterator {
	if ptr.Pointer() != nil {
		return NewQRegularExpressionMatchIteratorFromPointer(C.QRegularExpression_GlobalMatch2(ptr.Pointer(), PointerFromQStringRef(subjectRef), C.int(int32(offset)), C.longlong(matchType), C.longlong(matchOptions)))
	}
	return nil
}

func (ptr *QRegularExpression) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRegularExpression_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRegularExpression) Match(subject string, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatch {
	if ptr.Pointer() != nil {
		var subjectC *C.char
		if subject != "" {
			subjectC = C.CString(subject)
			defer C.free(unsafe.Pointer(subjectC))
		}
		tmpValue := NewQRegularExpressionMatchFromPointer(C.QRegularExpression_Match(ptr.Pointer(), C.struct_QtCore_PackedString{data: subjectC, len: C.longlong(len(subject))}, C.int(int32(offset)), C.longlong(matchType), C.longlong(matchOptions)))
		runtime.SetFinalizer(tmpValue, (*QRegularExpressionMatch).DestroyQRegularExpressionMatch)
		return tmpValue
	}
	return nil
}

func (ptr *QRegularExpression) Match2(subjectRef QStringRef_ITF, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatch {
	if ptr.Pointer() != nil {
		tmpValue := NewQRegularExpressionMatchFromPointer(C.QRegularExpression_Match2(ptr.Pointer(), PointerFromQStringRef(subjectRef), C.int(int32(offset)), C.longlong(matchType), C.longlong(matchOptions)))
		runtime.SetFinalizer(tmpValue, (*QRegularExpressionMatch).DestroyQRegularExpressionMatch)
		return tmpValue
	}
	return nil
}

func (ptr *QRegularExpression) NamedCaptureGroups() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QRegularExpression_NamedCaptureGroups(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QRegularExpression) Optimize() {
	if ptr.Pointer() != nil {
		C.QRegularExpression_Optimize(ptr.Pointer())
	}
}

func (ptr *QRegularExpression) Pattern() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QRegularExpression_Pattern(ptr.Pointer()))
	}
	return ""
}

func (ptr *QRegularExpression) PatternErrorOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegularExpression_PatternErrorOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRegularExpression) PatternOptions() QRegularExpression__PatternOption {
	if ptr.Pointer() != nil {
		return QRegularExpression__PatternOption(C.QRegularExpression_PatternOptions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegularExpression) SetPattern(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QRegularExpression_SetPattern(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

func (ptr *QRegularExpression) SetPatternOptions(options QRegularExpression__PatternOption) {
	if ptr.Pointer() != nil {
		C.QRegularExpression_SetPatternOptions(ptr.Pointer(), C.longlong(options))
	}
}

func (ptr *QRegularExpression) Swap(other QRegularExpression_ITF) {
	if ptr.Pointer() != nil {
		C.QRegularExpression_Swap(ptr.Pointer(), PointerFromQRegularExpression(other))
	}
}

func QRegularExpression_WildcardToRegularExpression(pattern string) string {
	var patternC *C.char
	if pattern != "" {
		patternC = C.CString(pattern)
		defer C.free(unsafe.Pointer(patternC))
	}
	return cGoUnpackString(C.QRegularExpression_QRegularExpression_WildcardToRegularExpression(C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))}))
}

func (ptr *QRegularExpression) WildcardToRegularExpression(pattern string) string {
	var patternC *C.char
	if pattern != "" {
		patternC = C.CString(pattern)
		defer C.free(unsafe.Pointer(patternC))
	}
	return cGoUnpackString(C.QRegularExpression_QRegularExpression_WildcardToRegularExpression(C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))}))
}

func (ptr *QRegularExpression) DestroyQRegularExpression() {
	if ptr.Pointer() != nil {
		C.QRegularExpression_DestroyQRegularExpression(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QRegularExpressionMatch struct {
	ptr unsafe.Pointer
}

type QRegularExpressionMatch_ITF interface {
	QRegularExpressionMatch_PTR() *QRegularExpressionMatch
}

func (ptr *QRegularExpressionMatch) QRegularExpressionMatch_PTR() *QRegularExpressionMatch {
	return ptr
}

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

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

func PointerFromQRegularExpressionMatch(ptr QRegularExpressionMatch_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegularExpressionMatch_PTR().Pointer()
	}
	return nil
}

func NewQRegularExpressionMatchFromPointer(ptr unsafe.Pointer) (n *QRegularExpressionMatch) {
	n = new(QRegularExpressionMatch)
	n.SetPointer(ptr)
	return
}
func NewQRegularExpressionMatch() *QRegularExpressionMatch {
	tmpValue := NewQRegularExpressionMatchFromPointer(C.QRegularExpressionMatch_NewQRegularExpressionMatch())
	runtime.SetFinalizer(tmpValue, (*QRegularExpressionMatch).DestroyQRegularExpressionMatch)
	return tmpValue
}

func NewQRegularExpressionMatch2(match QRegularExpressionMatch_ITF) *QRegularExpressionMatch {
	tmpValue := NewQRegularExpressionMatchFromPointer(C.QRegularExpressionMatch_NewQRegularExpressionMatch2(PointerFromQRegularExpressionMatch(match)))
	runtime.SetFinalizer(tmpValue, (*QRegularExpressionMatch).DestroyQRegularExpressionMatch)
	return tmpValue
}

func (ptr *QRegularExpressionMatch) Captured(nth int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QRegularExpressionMatch_Captured(ptr.Pointer(), C.int(int32(nth))))
	}
	return ""
}

func (ptr *QRegularExpressionMatch) Captured2(name string) string {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return cGoUnpackString(C.QRegularExpressionMatch_Captured2(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}))
	}
	return ""
}

func (ptr *QRegularExpressionMatch) Captured3(name QStringView_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QRegularExpressionMatch_Captured3(ptr.Pointer(), PointerFromQStringView(name)))
	}
	return ""
}

func (ptr *QRegularExpressionMatch) CapturedEnd(nth int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegularExpressionMatch_CapturedEnd(ptr.Pointer(), C.int(int32(nth)))))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedEnd2(name string) int {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int(int32(C.QRegularExpressionMatch_CapturedEnd2(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedEnd3(name QStringView_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegularExpressionMatch_CapturedEnd3(ptr.Pointer(), PointerFromQStringView(name))))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedLength(nth int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegularExpressionMatch_CapturedLength(ptr.Pointer(), C.int(int32(nth)))))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedLength2(name string) int {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int(int32(C.QRegularExpressionMatch_CapturedLength2(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedLength3(name QStringView_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegularExpressionMatch_CapturedLength3(ptr.Pointer(), PointerFromQStringView(name))))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedRef(nth int) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QRegularExpressionMatch_CapturedRef(ptr.Pointer(), C.int(int32(nth))))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QRegularExpressionMatch) CapturedRef2(name string) *QStringRef {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		tmpValue := NewQStringRefFromPointer(C.QRegularExpressionMatch_CapturedRef2(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QRegularExpressionMatch) CapturedRef3(name QStringView_ITF) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QRegularExpressionMatch_CapturedRef3(ptr.Pointer(), PointerFromQStringView(name)))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QRegularExpressionMatch) CapturedStart(nth int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegularExpressionMatch_CapturedStart(ptr.Pointer(), C.int(int32(nth)))))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedStart2(name string) int {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int(int32(C.QRegularExpressionMatch_CapturedStart2(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedStart3(name QStringView_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegularExpressionMatch_CapturedStart3(ptr.Pointer(), PointerFromQStringView(name))))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedTexts() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QRegularExpressionMatch_CapturedTexts(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QRegularExpressionMatch) CapturedView(nth int) *QStringView {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringViewFromPointer(C.QRegularExpressionMatch_CapturedView(ptr.Pointer(), C.int(int32(nth))))
		runtime.SetFinalizer(tmpValue, (*QStringView).DestroyQStringView)
		return tmpValue
	}
	return nil
}

func (ptr *QRegularExpressionMatch) CapturedView2(name QStringView_ITF) *QStringView {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringViewFromPointer(C.QRegularExpressionMatch_CapturedView2(ptr.Pointer(), PointerFromQStringView(name)))
		runtime.SetFinalizer(tmpValue, (*QStringView).DestroyQStringView)
		return tmpValue
	}
	return nil
}

func (ptr *QRegularExpressionMatch) HasMatch() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRegularExpressionMatch_HasMatch(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRegularExpressionMatch) HasPartialMatch() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRegularExpressionMatch_HasPartialMatch(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRegularExpressionMatch) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRegularExpressionMatch_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QRegularExpressionMatch) LastCapturedIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QRegularExpressionMatch_LastCapturedIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) MatchOptions() QRegularExpression__MatchOption {
	if ptr.Pointer() != nil {
		return QRegularExpression__MatchOption(C.QRegularExpressionMatch_MatchOptions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) MatchType() QRegularExpression__MatchType {
	if ptr.Pointer() != nil {
		return QRegularExpression__MatchType(C.QRegularExpressionMatch_MatchType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) RegularExpression() *QRegularExpression {
	if ptr.Pointer() != nil {
		tmpValue := NewQRegularExpressionFromPointer(C.QRegularExpressionMatch_RegularExpression(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRegularExpression).DestroyQRegularExpression)
		return tmpValue
	}
	return nil
}

func (ptr *QRegularExpressionMatch) Swap(other QRegularExpressionMatch_ITF) {
	if ptr.Pointer() != nil {
		C.QRegularExpressionMatch_Swap(ptr.Pointer(), PointerFromQRegularExpressionMatch(other))
	}
}

func (ptr *QRegularExpressionMatch) DestroyQRegularExpressionMatch() {
	if ptr.Pointer() != nil {
		C.QRegularExpressionMatch_DestroyQRegularExpressionMatch(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QRegularExpressionMatchIterator struct {
	ptr unsafe.Pointer
}

type QRegularExpressionMatchIterator_ITF interface {
	QRegularExpressionMatchIterator_PTR() *QRegularExpressionMatchIterator
}

func (ptr *QRegularExpressionMatchIterator) QRegularExpressionMatchIterator_PTR() *QRegularExpressionMatchIterator {
	return ptr
}

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

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

func PointerFromQRegularExpressionMatchIterator(ptr QRegularExpressionMatchIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegularExpressionMatchIterator_PTR().Pointer()
	}
	return nil
}

func NewQRegularExpressionMatchIteratorFromPointer(ptr unsafe.Pointer) (n *QRegularExpressionMatchIterator) {
	n = new(QRegularExpressionMatchIterator)
	n.SetPointer(ptr)
	return
}

type QResource struct {
	ptr unsafe.Pointer
}

type QResource_ITF interface {
	QResource_PTR() *QResource
}

func (ptr *QResource) QResource_PTR() *QResource {
	return ptr
}

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

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

func PointerFromQResource(ptr QResource_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QResource_PTR().Pointer()
	}
	return nil
}

func NewQResourceFromPointer(ptr unsafe.Pointer) (n *QResource) {
	n = new(QResource)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QResource__Compression
//QResource::Compression
type QResource__Compression int64

const (
	QResource__NoCompression   QResource__Compression = QResource__Compression(0)
	QResource__ZlibCompression QResource__Compression = QResource__Compression(1)
	QResource__ZstdCompression QResource__Compression = QResource__Compression(2)
)

func NewQResource(file string, locale QLocale_ITF) *QResource {
	var fileC *C.char
	if file != "" {
		fileC = C.CString(file)
		defer C.free(unsafe.Pointer(fileC))
	}
	tmpValue := NewQResourceFromPointer(C.QResource_NewQResource(C.struct_QtCore_PackedString{data: fileC, len: C.longlong(len(file))}, PointerFromQLocale(locale)))
	runtime.SetFinalizer(tmpValue, (*QResource).DestroyQResource)
	return tmpValue
}

func (ptr *QResource) AbsoluteFilePath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QResource_AbsoluteFilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QResource) Children() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QResource_Children(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QResource) CompressionAlgorithm() QResource__Compression {
	if ptr.Pointer() != nil {
		return QResource__Compression(C.QResource_CompressionAlgorithm(ptr.Pointer()))
	}
	return 0
}

func (ptr *QResource) Data() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QResource_Data(ptr.Pointer()))
	}
	return ""
}

func (ptr *QResource) FileName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QResource_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QResource) IsCompressed() bool {
	if ptr.Pointer() != nil {
		return int8(C.QResource_IsCompressed(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QResource) IsDir() bool {
	if ptr.Pointer() != nil {
		return int8(C.QResource_IsDir(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QResource) IsFile() bool {
	if ptr.Pointer() != nil {
		return int8(C.QResource_IsFile(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QResource) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QResource_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QResource) LastModified() *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QResource_LastModified(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QResource) Locale() *QLocale {
	if ptr.Pointer() != nil {
		tmpValue := NewQLocaleFromPointer(C.QResource_Locale(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
		return tmpValue
	}
	return nil
}

func QResource_RegisterResource(rccFileName string, mapRoot string) bool {
	var rccFileNameC *C.char
	if rccFileName != "" {
		rccFileNameC = C.CString(rccFileName)
		defer C.free(unsafe.Pointer(rccFileNameC))
	}
	var mapRootC *C.char
	if mapRoot != "" {
		mapRootC = C.CString(mapRoot)
		defer C.free(unsafe.Pointer(mapRootC))
	}
	return int8(C.QResource_QResource_RegisterResource(C.struct_QtCore_PackedString{data: rccFileNameC, len: C.longlong(len(rccFileName))}, C.struct_QtCore_PackedString{data: mapRootC, len: C.longlong(len(mapRoot))})) != 0
}

func (ptr *QResource) RegisterResource(rccFileName string, mapRoot string) bool {
	var rccFileNameC *C.char
	if rccFileName != "" {
		rccFileNameC = C.CString(rccFileName)
		defer C.free(unsafe.Pointer(rccFileNameC))
	}
	var mapRootC *C.char
	if mapRoot != "" {
		mapRootC = C.CString(mapRoot)
		defer C.free(unsafe.Pointer(mapRootC))
	}
	return int8(C.QResource_QResource_RegisterResource(C.struct_QtCore_PackedString{data: rccFileNameC, len: C.longlong(len(rccFileName))}, C.struct_QtCore_PackedString{data: mapRootC, len: C.longlong(len(mapRoot))})) != 0
}

func QResource_RegisterResource2(rccData string, mapRoot string) bool {
	var rccDataC *C.char
	if rccData != "" {
		rccDataC = C.CString(rccData)
		defer C.free(unsafe.Pointer(rccDataC))
	}
	var mapRootC *C.char
	if mapRoot != "" {
		mapRootC = C.CString(mapRoot)
		defer C.free(unsafe.Pointer(mapRootC))
	}
	return int8(C.QResource_QResource_RegisterResource2(rccDataC, C.struct_QtCore_PackedString{data: mapRootC, len: C.longlong(len(mapRoot))})) != 0
}

func (ptr *QResource) RegisterResource2(rccData string, mapRoot string) bool {
	var rccDataC *C.char
	if rccData != "" {
		rccDataC = C.CString(rccData)
		defer C.free(unsafe.Pointer(rccDataC))
	}
	var mapRootC *C.char
	if mapRoot != "" {
		mapRootC = C.CString(mapRoot)
		defer C.free(unsafe.Pointer(mapRootC))
	}
	return int8(C.QResource_QResource_RegisterResource2(rccDataC, C.struct_QtCore_PackedString{data: mapRootC, len: C.longlong(len(mapRoot))})) != 0
}

func (ptr *QResource) SetFileName(file string) {
	if ptr.Pointer() != nil {
		var fileC *C.char
		if file != "" {
			fileC = C.CString(file)
			defer C.free(unsafe.Pointer(fileC))
		}
		C.QResource_SetFileName(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileC, len: C.longlong(len(file))})
	}
}

func (ptr *QResource) SetLocale(locale QLocale_ITF) {
	if ptr.Pointer() != nil {
		C.QResource_SetLocale(ptr.Pointer(), PointerFromQLocale(locale))
	}
}

func (ptr *QResource) Size() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QResource_Size(ptr.Pointer()))
	}
	return 0
}

func QResource_UnregisterResource(rccFileName string, mapRoot string) bool {
	var rccFileNameC *C.char
	if rccFileName != "" {
		rccFileNameC = C.CString(rccFileName)
		defer C.free(unsafe.Pointer(rccFileNameC))
	}
	var mapRootC *C.char
	if mapRoot != "" {
		mapRootC = C.CString(mapRoot)
		defer C.free(unsafe.Pointer(mapRootC))
	}
	return int8(C.QResource_QResource_UnregisterResource(C.struct_QtCore_PackedString{data: rccFileNameC, len: C.longlong(len(rccFileName))}, C.struct_QtCore_PackedString{data: mapRootC, len: C.longlong(len(mapRoot))})) != 0
}

func (ptr *QResource) UnregisterResource(rccFileName string, mapRoot string) bool {
	var rccFileNameC *C.char
	if rccFileName != "" {
		rccFileNameC = C.CString(rccFileName)
		defer C.free(unsafe.Pointer(rccFileNameC))
	}
	var mapRootC *C.char
	if mapRoot != "" {
		mapRootC = C.CString(mapRoot)
		defer C.free(unsafe.Pointer(mapRootC))
	}
	return int8(C.QResource_QResource_UnregisterResource(C.struct_QtCore_PackedString{data: rccFileNameC, len: C.longlong(len(rccFileName))}, C.struct_QtCore_PackedString{data: mapRootC, len: C.longlong(len(mapRoot))})) != 0
}

func QResource_UnregisterResource2(rccData string, mapRoot string) bool {
	var rccDataC *C.char
	if rccData != "" {
		rccDataC = C.CString(rccData)
		defer C.free(unsafe.Pointer(rccDataC))
	}
	var mapRootC *C.char
	if mapRoot != "" {
		mapRootC = C.CString(mapRoot)
		defer C.free(unsafe.Pointer(mapRootC))
	}
	return int8(C.QResource_QResource_UnregisterResource2(rccDataC, C.struct_QtCore_PackedString{data: mapRootC, len: C.longlong(len(mapRoot))})) != 0
}

func (ptr *QResource) UnregisterResource2(rccData string, mapRoot string) bool {
	var rccDataC *C.char
	if rccData != "" {
		rccDataC = C.CString(rccData)
		defer C.free(unsafe.Pointer(rccDataC))
	}
	var mapRootC *C.char
	if mapRoot != "" {
		mapRootC = C.CString(mapRoot)
		defer C.free(unsafe.Pointer(mapRootC))
	}
	return int8(C.QResource_QResource_UnregisterResource2(rccDataC, C.struct_QtCore_PackedString{data: mapRootC, len: C.longlong(len(mapRoot))})) != 0
}

func (ptr *QResource) DestroyQResource() {
	if ptr.Pointer() != nil {
		C.QResource_DestroyQResource(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QReturnArgument struct {
	QGenericReturnArgument
}

type QReturnArgument_ITF interface {
	QGenericReturnArgument_ITF
	QReturnArgument_PTR() *QReturnArgument
}

func (ptr *QReturnArgument) QReturnArgument_PTR() *QReturnArgument {
	return ptr
}

func (ptr *QReturnArgument) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericReturnArgument_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQReturnArgument(ptr QReturnArgument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QReturnArgument_PTR().Pointer()
	}
	return nil
}

func NewQReturnArgumentFromPointer(ptr unsafe.Pointer) (n *QReturnArgument) {
	n = new(QReturnArgument)
	n.SetPointer(ptr)
	return
}

func (ptr *QReturnArgument) DestroyQReturnArgument() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QRunnable struct {
	ptr unsafe.Pointer
}

type QRunnable_ITF interface {
	QRunnable_PTR() *QRunnable
}

func (ptr *QRunnable) QRunnable_PTR() *QRunnable {
	return ptr
}

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

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

func PointerFromQRunnable(ptr QRunnable_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRunnable_PTR().Pointer()
	}
	return nil
}

func NewQRunnableFromPointer(ptr unsafe.Pointer) (n *QRunnable) {
	n = new(QRunnable)
	n.SetPointer(ptr)
	return
}
func NewQRunnable() *QRunnable {
	return NewQRunnableFromPointer(C.QRunnable_NewQRunnable())
}

func (ptr *QRunnable) AutoDelete() bool {
	if ptr.Pointer() != nil {
		return int8(C.QRunnable_AutoDelete(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQRunnable_Run
func callbackQRunnable_Run(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "run"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QRunnable) ConnectRun(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "run"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "run", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "run", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QRunnable) DisconnectRun() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "run")
	}
}

func (ptr *QRunnable) Run() {
	if ptr.Pointer() != nil {
		C.QRunnable_Run(ptr.Pointer())
	}
}

func (ptr *QRunnable) SetAutoDelete(autoDelete bool) {
	if ptr.Pointer() != nil {
		C.QRunnable_SetAutoDelete(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(autoDelete))))
	}
}

//export callbackQRunnable_DestroyQRunnable
func callbackQRunnable_DestroyQRunnable(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QRunnable"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQRunnableFromPointer(ptr).DestroyQRunnableDefault()
	}
}

func (ptr *QRunnable) ConnectDestroyQRunnable(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QRunnable"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QRunnable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QRunnable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QRunnable) DisconnectDestroyQRunnable() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QRunnable")
	}
}

func (ptr *QRunnable) DestroyQRunnable() {
	if ptr.Pointer() != nil {
		C.QRunnable_DestroyQRunnable(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QRunnable) DestroyQRunnableDefault() {
	if ptr.Pointer() != nil {
		C.QRunnable_DestroyQRunnableDefault(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

type QSaveFile struct {
	QFileDevice
}

type QSaveFile_ITF interface {
	QFileDevice_ITF
	QSaveFile_PTR() *QSaveFile
}

func (ptr *QSaveFile) QSaveFile_PTR() *QSaveFile {
	return ptr
}

func (ptr *QSaveFile) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileDevice_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQSaveFile(ptr QSaveFile_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSaveFile_PTR().Pointer()
	}
	return nil
}

func NewQSaveFileFromPointer(ptr unsafe.Pointer) (n *QSaveFile) {
	n = new(QSaveFile)
	n.SetPointer(ptr)
	return
}
func NewQSaveFile(name string) *QSaveFile {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	tmpValue := NewQSaveFileFromPointer(C.QSaveFile_NewQSaveFile(C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSaveFile2(parent QObject_ITF) *QSaveFile {
	tmpValue := NewQSaveFileFromPointer(C.QSaveFile_NewQSaveFile2(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSaveFile3(name string, parent QObject_ITF) *QSaveFile {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	tmpValue := NewQSaveFileFromPointer(C.QSaveFile_NewQSaveFile3(C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QSaveFile) CancelWriting() {
	if ptr.Pointer() != nil {
		C.QSaveFile_CancelWriting(ptr.Pointer())
	}
}

func (ptr *QSaveFile) Commit() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSaveFile_Commit(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSaveFile) DirectWriteFallback() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSaveFile_DirectWriteFallback(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSaveFile) SetDirectWriteFallback(enabled bool) {
	if ptr.Pointer() != nil {
		C.QSaveFile_SetDirectWriteFallback(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QSaveFile) SetFileName(name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QSaveFile_SetFileName(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

//export callbackQSaveFile_DestroyQSaveFile
func callbackQSaveFile_DestroyQSaveFile(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSaveFile"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSaveFileFromPointer(ptr).DestroyQSaveFileDefault()
	}
}

func (ptr *QSaveFile) ConnectDestroyQSaveFile(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSaveFile"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSaveFile", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSaveFile", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSaveFile) DisconnectDestroyQSaveFile() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSaveFile")
	}
}

func (ptr *QSaveFile) DestroyQSaveFile() {
	if ptr.Pointer() != nil {
		C.QSaveFile_DestroyQSaveFile(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSaveFile) DestroyQSaveFileDefault() {
	if ptr.Pointer() != nil {
		C.QSaveFile_DestroyQSaveFileDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QScopeGuard struct {
	ptr unsafe.Pointer
}

type QScopeGuard_ITF interface {
	QScopeGuard_PTR() *QScopeGuard
}

func (ptr *QScopeGuard) QScopeGuard_PTR() *QScopeGuard {
	return ptr
}

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

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

func PointerFromQScopeGuard(ptr QScopeGuard_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopeGuard_PTR().Pointer()
	}
	return nil
}

func NewQScopeGuardFromPointer(ptr unsafe.Pointer) (n *QScopeGuard) {
	n = new(QScopeGuard)
	n.SetPointer(ptr)
	return
}

func (ptr *QScopeGuard) DestroyQScopeGuard() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QScopedArrayPointer struct {
	QScopedPointer
}

type QScopedArrayPointer_ITF interface {
	QScopedPointer_ITF
	QScopedArrayPointer_PTR() *QScopedArrayPointer
}

func (ptr *QScopedArrayPointer) QScopedArrayPointer_PTR() *QScopedArrayPointer {
	return ptr
}

func (ptr *QScopedArrayPointer) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedPointer_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQScopedArrayPointer(ptr QScopedArrayPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedArrayPointer_PTR().Pointer()
	}
	return nil
}

func NewQScopedArrayPointerFromPointer(ptr unsafe.Pointer) (n *QScopedArrayPointer) {
	n = new(QScopedArrayPointer)
	n.SetPointer(ptr)
	return
}

func (ptr *QScopedArrayPointer) DestroyQScopedArrayPointer() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QScopedPointer struct {
	ptr unsafe.Pointer
}

type QScopedPointer_ITF interface {
	QScopedPointer_PTR() *QScopedPointer
}

func (ptr *QScopedPointer) QScopedPointer_PTR() *QScopedPointer {
	return ptr
}

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

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

func PointerFromQScopedPointer(ptr QScopedPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedPointer_PTR().Pointer()
	}
	return nil
}

func NewQScopedPointerFromPointer(ptr unsafe.Pointer) (n *QScopedPointer) {
	n = new(QScopedPointer)
	n.SetPointer(ptr)
	return
}

type QScopedPointerArrayDeleter struct {
	ptr unsafe.Pointer
}

type QScopedPointerArrayDeleter_ITF interface {
	QScopedPointerArrayDeleter_PTR() *QScopedPointerArrayDeleter
}

func (ptr *QScopedPointerArrayDeleter) QScopedPointerArrayDeleter_PTR() *QScopedPointerArrayDeleter {
	return ptr
}

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

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

func PointerFromQScopedPointerArrayDeleter(ptr QScopedPointerArrayDeleter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedPointerArrayDeleter_PTR().Pointer()
	}
	return nil
}

func NewQScopedPointerArrayDeleterFromPointer(ptr unsafe.Pointer) (n *QScopedPointerArrayDeleter) {
	n = new(QScopedPointerArrayDeleter)
	n.SetPointer(ptr)
	return
}

func (ptr *QScopedPointerArrayDeleter) DestroyQScopedPointerArrayDeleter() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QScopedPointerDeleter struct {
	ptr unsafe.Pointer
}

type QScopedPointerDeleter_ITF interface {
	QScopedPointerDeleter_PTR() *QScopedPointerDeleter
}

func (ptr *QScopedPointerDeleter) QScopedPointerDeleter_PTR() *QScopedPointerDeleter {
	return ptr
}

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

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

func PointerFromQScopedPointerDeleter(ptr QScopedPointerDeleter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedPointerDeleter_PTR().Pointer()
	}
	return nil
}

func NewQScopedPointerDeleterFromPointer(ptr unsafe.Pointer) (n *QScopedPointerDeleter) {
	n = new(QScopedPointerDeleter)
	n.SetPointer(ptr)
	return
}

func (ptr *QScopedPointerDeleter) DestroyQScopedPointerDeleter() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QScopedPointerObjectDeleteLater struct {
	ptr unsafe.Pointer
}

type QScopedPointerObjectDeleteLater_ITF interface {
	QScopedPointerObjectDeleteLater_PTR() *QScopedPointerObjectDeleteLater
}

func (ptr *QScopedPointerObjectDeleteLater) QScopedPointerObjectDeleteLater_PTR() *QScopedPointerObjectDeleteLater {
	return ptr
}

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

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

func PointerFromQScopedPointerObjectDeleteLater(ptr QScopedPointerObjectDeleteLater_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedPointerObjectDeleteLater_PTR().Pointer()
	}
	return nil
}

func NewQScopedPointerObjectDeleteLaterFromPointer(ptr unsafe.Pointer) (n *QScopedPointerObjectDeleteLater) {
	n = new(QScopedPointerObjectDeleteLater)
	n.SetPointer(ptr)
	return
}

func (ptr *QScopedPointerObjectDeleteLater) DestroyQScopedPointerObjectDeleteLater() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QScopedPointerPodDeleter struct {
	ptr unsafe.Pointer
}

type QScopedPointerPodDeleter_ITF interface {
	QScopedPointerPodDeleter_PTR() *QScopedPointerPodDeleter
}

func (ptr *QScopedPointerPodDeleter) QScopedPointerPodDeleter_PTR() *QScopedPointerPodDeleter {
	return ptr
}

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

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

func PointerFromQScopedPointerPodDeleter(ptr QScopedPointerPodDeleter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedPointerPodDeleter_PTR().Pointer()
	}
	return nil
}

func NewQScopedPointerPodDeleterFromPointer(ptr unsafe.Pointer) (n *QScopedPointerPodDeleter) {
	n = new(QScopedPointerPodDeleter)
	n.SetPointer(ptr)
	return
}

func (ptr *QScopedPointerPodDeleter) DestroyQScopedPointerPodDeleter() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QScopedValueRollback struct {
	ptr unsafe.Pointer
}

type QScopedValueRollback_ITF interface {
	QScopedValueRollback_PTR() *QScopedValueRollback
}

func (ptr *QScopedValueRollback) QScopedValueRollback_PTR() *QScopedValueRollback {
	return ptr
}

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

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

func PointerFromQScopedValueRollback(ptr QScopedValueRollback_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedValueRollback_PTR().Pointer()
	}
	return nil
}

func NewQScopedValueRollbackFromPointer(ptr unsafe.Pointer) (n *QScopedValueRollback) {
	n = new(QScopedValueRollback)
	n.SetPointer(ptr)
	return
}

type QSemaphore struct {
	ptr unsafe.Pointer
}

type QSemaphore_ITF interface {
	QSemaphore_PTR() *QSemaphore
}

func (ptr *QSemaphore) QSemaphore_PTR() *QSemaphore {
	return ptr
}

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

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

func PointerFromQSemaphore(ptr QSemaphore_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSemaphore_PTR().Pointer()
	}
	return nil
}

func NewQSemaphoreFromPointer(ptr unsafe.Pointer) (n *QSemaphore) {
	n = new(QSemaphore)
	n.SetPointer(ptr)
	return
}
func NewQSemaphore(n int) *QSemaphore {
	tmpValue := NewQSemaphoreFromPointer(C.QSemaphore_NewQSemaphore(C.int(int32(n))))
	runtime.SetFinalizer(tmpValue, (*QSemaphore).DestroyQSemaphore)
	return tmpValue
}

func (ptr *QSemaphore) Acquire(n int) {
	if ptr.Pointer() != nil {
		C.QSemaphore_Acquire(ptr.Pointer(), C.int(int32(n)))
	}
}

func (ptr *QSemaphore) Available() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSemaphore_Available(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSemaphore) Release(n int) {
	if ptr.Pointer() != nil {
		C.QSemaphore_Release(ptr.Pointer(), C.int(int32(n)))
	}
}

func (ptr *QSemaphore) TryAcquire(n int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSemaphore_TryAcquire(ptr.Pointer(), C.int(int32(n)))) != 0
	}
	return false
}

func (ptr *QSemaphore) TryAcquire2(n int, timeout int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSemaphore_TryAcquire2(ptr.Pointer(), C.int(int32(n)), C.int(int32(timeout)))) != 0
	}
	return false
}

func (ptr *QSemaphore) DestroyQSemaphore() {
	if ptr.Pointer() != nil {
		C.QSemaphore_DestroyQSemaphore(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSemaphoreReleaser struct {
	ptr unsafe.Pointer
}

type QSemaphoreReleaser_ITF interface {
	QSemaphoreReleaser_PTR() *QSemaphoreReleaser
}

func (ptr *QSemaphoreReleaser) QSemaphoreReleaser_PTR() *QSemaphoreReleaser {
	return ptr
}

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

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

func PointerFromQSemaphoreReleaser(ptr QSemaphoreReleaser_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSemaphoreReleaser_PTR().Pointer()
	}
	return nil
}

func NewQSemaphoreReleaserFromPointer(ptr unsafe.Pointer) (n *QSemaphoreReleaser) {
	n = new(QSemaphoreReleaser)
	n.SetPointer(ptr)
	return
}
func NewQSemaphoreReleaser() *QSemaphoreReleaser {
	tmpValue := NewQSemaphoreReleaserFromPointer(C.QSemaphoreReleaser_NewQSemaphoreReleaser())
	runtime.SetFinalizer(tmpValue, (*QSemaphoreReleaser).DestroyQSemaphoreReleaser)
	return tmpValue
}

func NewQSemaphoreReleaser2(sem QSemaphore_ITF, n int) *QSemaphoreReleaser {
	tmpValue := NewQSemaphoreReleaserFromPointer(C.QSemaphoreReleaser_NewQSemaphoreReleaser2(PointerFromQSemaphore(sem), C.int(int32(n))))
	runtime.SetFinalizer(tmpValue, (*QSemaphoreReleaser).DestroyQSemaphoreReleaser)
	return tmpValue
}

func NewQSemaphoreReleaser3(sem QSemaphore_ITF, n int) *QSemaphoreReleaser {
	tmpValue := NewQSemaphoreReleaserFromPointer(C.QSemaphoreReleaser_NewQSemaphoreReleaser3(PointerFromQSemaphore(sem), C.int(int32(n))))
	runtime.SetFinalizer(tmpValue, (*QSemaphoreReleaser).DestroyQSemaphoreReleaser)
	return tmpValue
}

func (ptr *QSemaphoreReleaser) Cancel() *QSemaphore {
	if ptr.Pointer() != nil {
		return NewQSemaphoreFromPointer(C.QSemaphoreReleaser_Cancel(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSemaphoreReleaser) Semaphore() *QSemaphore {
	if ptr.Pointer() != nil {
		return NewQSemaphoreFromPointer(C.QSemaphoreReleaser_Semaphore(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSemaphoreReleaser) Swap(other QSemaphoreReleaser_ITF) {
	if ptr.Pointer() != nil {
		C.QSemaphoreReleaser_Swap(ptr.Pointer(), PointerFromQSemaphoreReleaser(other))
	}
}

func (ptr *QSemaphoreReleaser) DestroyQSemaphoreReleaser() {
	if ptr.Pointer() != nil {
		C.QSemaphoreReleaser_DestroyQSemaphoreReleaser(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSequentialAnimationGroup struct {
	QAnimationGroup
}

type QSequentialAnimationGroup_ITF interface {
	QAnimationGroup_ITF
	QSequentialAnimationGroup_PTR() *QSequentialAnimationGroup
}

func (ptr *QSequentialAnimationGroup) QSequentialAnimationGroup_PTR() *QSequentialAnimationGroup {
	return ptr
}

func (ptr *QSequentialAnimationGroup) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAnimationGroup_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQSequentialAnimationGroup(ptr QSequentialAnimationGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSequentialAnimationGroup_PTR().Pointer()
	}
	return nil
}

func NewQSequentialAnimationGroupFromPointer(ptr unsafe.Pointer) (n *QSequentialAnimationGroup) {
	n = new(QSequentialAnimationGroup)
	n.SetPointer(ptr)
	return
}
func NewQSequentialAnimationGroup(parent QObject_ITF) *QSequentialAnimationGroup {
	tmpValue := NewQSequentialAnimationGroupFromPointer(C.QSequentialAnimationGroup_NewQSequentialAnimationGroup(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QSequentialAnimationGroup) AddPause(msecs int) *QPauseAnimation {
	if ptr.Pointer() != nil {
		tmpValue := NewQPauseAnimationFromPointer(C.QSequentialAnimationGroup_AddPause(ptr.Pointer(), C.int(int32(msecs))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSequentialAnimationGroup) CurrentAnimation() *QAbstractAnimation {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractAnimationFromPointer(C.QSequentialAnimationGroup_CurrentAnimation(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQSequentialAnimationGroup_CurrentAnimationChanged
func callbackQSequentialAnimationGroup_CurrentAnimationChanged(ptr unsafe.Pointer, current unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentAnimationChanged"); signal != nil {
		(*(*func(*QAbstractAnimation))(signal))(NewQAbstractAnimationFromPointer(current))
	}

}

func (ptr *QSequentialAnimationGroup) ConnectCurrentAnimationChanged(f func(current *QAbstractAnimation)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentAnimationChanged") {
			C.QSequentialAnimationGroup_ConnectCurrentAnimationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentAnimationChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentAnimationChanged"); signal != nil {
			f := func(current *QAbstractAnimation) {
				(*(*func(*QAbstractAnimation))(signal))(current)
				f(current)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentAnimationChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentAnimationChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectCurrentAnimationChanged() {
	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_DisconnectCurrentAnimationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentAnimationChanged")
	}
}

func (ptr *QSequentialAnimationGroup) CurrentAnimationChanged(current QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_CurrentAnimationChanged(ptr.Pointer(), PointerFromQAbstractAnimation(current))
	}
}

//export callbackQSequentialAnimationGroup_Duration
func callbackQSequentialAnimationGroup_Duration(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "duration"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQSequentialAnimationGroupFromPointer(ptr).DurationDefault()))
}

func (ptr *QSequentialAnimationGroup) ConnectDuration(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "duration"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectDuration() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "duration")
	}
}

func (ptr *QSequentialAnimationGroup) Duration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSequentialAnimationGroup_Duration(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSequentialAnimationGroup) DurationDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSequentialAnimationGroup_DurationDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSequentialAnimationGroup) InsertPause(index int, msecs int) *QPauseAnimation {
	if ptr.Pointer() != nil {
		tmpValue := NewQPauseAnimationFromPointer(C.QSequentialAnimationGroup_InsertPause(ptr.Pointer(), C.int(int32(index)), C.int(int32(msecs))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQSequentialAnimationGroup_UpdateCurrentTime
func callbackQSequentialAnimationGroup_UpdateCurrentTime(ptr unsafe.Pointer, currentTime C.int) {
	if signal := qt.GetSignal(ptr, "updateCurrentTime"); signal != nil {
		(*(*func(int))(signal))(int(int32(currentTime)))
	} else {
		NewQSequentialAnimationGroupFromPointer(ptr).UpdateCurrentTimeDefault(int(int32(currentTime)))
	}
}

func (ptr *QSequentialAnimationGroup) ConnectUpdateCurrentTime(f func(currentTime int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateCurrentTime"); signal != nil {
			f := func(currentTime int) {
				(*(*func(int))(signal))(currentTime)
				f(currentTime)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectUpdateCurrentTime() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateCurrentTime")
	}
}

func (ptr *QSequentialAnimationGroup) UpdateCurrentTime(currentTime int) {
	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_UpdateCurrentTime(ptr.Pointer(), C.int(int32(currentTime)))
	}
}

func (ptr *QSequentialAnimationGroup) UpdateCurrentTimeDefault(currentTime int) {
	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(int32(currentTime)))
	}
}

//export callbackQSequentialAnimationGroup_DestroyQSequentialAnimationGroup
func callbackQSequentialAnimationGroup_DestroyQSequentialAnimationGroup(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSequentialAnimationGroup"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSequentialAnimationGroupFromPointer(ptr).DestroyQSequentialAnimationGroupDefault()
	}
}

func (ptr *QSequentialAnimationGroup) ConnectDestroyQSequentialAnimationGroup(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSequentialAnimationGroup"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSequentialAnimationGroup", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSequentialAnimationGroup", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectDestroyQSequentialAnimationGroup() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSequentialAnimationGroup")
	}
}

func (ptr *QSequentialAnimationGroup) DestroyQSequentialAnimationGroup() {
	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_DestroyQSequentialAnimationGroup(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSequentialAnimationGroup) DestroyQSequentialAnimationGroupDefault() {
	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_DestroyQSequentialAnimationGroupDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSequentialIterable struct {
	ptr unsafe.Pointer
}

type QSequentialIterable_ITF interface {
	QSequentialIterable_PTR() *QSequentialIterable
}

func (ptr *QSequentialIterable) QSequentialIterable_PTR() *QSequentialIterable {
	return ptr
}

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

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

func PointerFromQSequentialIterable(ptr QSequentialIterable_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSequentialIterable_PTR().Pointer()
	}
	return nil
}

func NewQSequentialIterableFromPointer(ptr unsafe.Pointer) (n *QSequentialIterable) {
	n = new(QSequentialIterable)
	n.SetPointer(ptr)
	return
}

func (ptr *QSequentialIterable) DestroyQSequentialIterable() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSequentialIterable) At(idx int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QSequentialIterable_At(ptr.Pointer(), C.int(int32(idx))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QSequentialIterable) CanReverseIterate() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSequentialIterable_CanReverseIterate(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSequentialIterable) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSequentialIterable_Size(ptr.Pointer())))
	}
	return 0
}

type QSet struct {
	ptr unsafe.Pointer
}

type QSet_ITF interface {
	QSet_PTR() *QSet
}

func (ptr *QSet) QSet_PTR() *QSet {
	return ptr
}

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

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

func PointerFromQSet(ptr QSet_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSet_PTR().Pointer()
	}
	return nil
}

func NewQSetFromPointer(ptr unsafe.Pointer) (n *QSet) {
	n = new(QSet)
	n.SetPointer(ptr)
	return
}

func (ptr *QSet) DestroyQSet() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSetIterator struct {
	ptr unsafe.Pointer
}

type QSetIterator_ITF interface {
	QSetIterator_PTR() *QSetIterator
}

func (ptr *QSetIterator) QSetIterator_PTR() *QSetIterator {
	return ptr
}

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

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

func PointerFromQSetIterator(ptr QSetIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSetIterator_PTR().Pointer()
	}
	return nil
}

func NewQSetIteratorFromPointer(ptr unsafe.Pointer) (n *QSetIterator) {
	n = new(QSetIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QSetIterator) DestroyQSetIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSettings struct {
	QObject
}

type QSettings_ITF interface {
	QObject_ITF
	QSettings_PTR() *QSettings
}

func (ptr *QSettings) QSettings_PTR() *QSettings {
	return ptr
}

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

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

func PointerFromQSettings(ptr QSettings_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSettings_PTR().Pointer()
	}
	return nil
}

func NewQSettingsFromPointer(ptr unsafe.Pointer) (n *QSettings) {
	n = new(QSettings)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QSettings__Status
//QSettings::Status
type QSettings__Status int64

const (
	QSettings__NoError     QSettings__Status = QSettings__Status(0)
	QSettings__AccessError QSettings__Status = QSettings__Status(1)
	QSettings__FormatError QSettings__Status = QSettings__Status(2)
)

//go:generate stringer -type=QSettings__Format
//QSettings::Format
type QSettings__Format int64

const (
	QSettings__NativeFormat     QSettings__Format = QSettings__Format(0)
	QSettings__IniFormat        QSettings__Format = QSettings__Format(1)
	QSettings__Registry32Format QSettings__Format = QSettings__Format(2)
	QSettings__Registry64Format QSettings__Format = QSettings__Format(3)
	QSettings__InvalidFormat    QSettings__Format = QSettings__Format(16)
	QSettings__CustomFormat1    QSettings__Format = QSettings__Format(17)
	QSettings__CustomFormat2    QSettings__Format = QSettings__Format(18)
	QSettings__CustomFormat3    QSettings__Format = QSettings__Format(19)
	QSettings__CustomFormat4    QSettings__Format = QSettings__Format(20)
	QSettings__CustomFormat5    QSettings__Format = QSettings__Format(21)
	QSettings__CustomFormat6    QSettings__Format = QSettings__Format(22)
	QSettings__CustomFormat7    QSettings__Format = QSettings__Format(23)
	QSettings__CustomFormat8    QSettings__Format = QSettings__Format(24)
	QSettings__CustomFormat9    QSettings__Format = QSettings__Format(25)
	QSettings__CustomFormat10   QSettings__Format = QSettings__Format(26)
	QSettings__CustomFormat11   QSettings__Format = QSettings__Format(27)
	QSettings__CustomFormat12   QSettings__Format = QSettings__Format(28)
	QSettings__CustomFormat13   QSettings__Format = QSettings__Format(29)
	QSettings__CustomFormat14   QSettings__Format = QSettings__Format(30)
	QSettings__CustomFormat15   QSettings__Format = QSettings__Format(31)
	QSettings__CustomFormat16   QSettings__Format = QSettings__Format(32)
)

//go:generate stringer -type=QSettings__Scope
//QSettings::Scope
type QSettings__Scope int64

const (
	QSettings__UserScope   QSettings__Scope = QSettings__Scope(0)
	QSettings__SystemScope QSettings__Scope = QSettings__Scope(1)
)

func NewQSettings(organization string, application string, parent QObject_ITF) *QSettings {
	var organizationC *C.char
	if organization != "" {
		organizationC = C.CString(organization)
		defer C.free(unsafe.Pointer(organizationC))
	}
	var applicationC *C.char
	if application != "" {
		applicationC = C.CString(application)
		defer C.free(unsafe.Pointer(applicationC))
	}
	tmpValue := NewQSettingsFromPointer(C.QSettings_NewQSettings(C.struct_QtCore_PackedString{data: organizationC, len: C.longlong(len(organization))}, C.struct_QtCore_PackedString{data: applicationC, len: C.longlong(len(application))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSettings2(scope QSettings__Scope, organization string, application string, parent QObject_ITF) *QSettings {
	var organizationC *C.char
	if organization != "" {
		organizationC = C.CString(organization)
		defer C.free(unsafe.Pointer(organizationC))
	}
	var applicationC *C.char
	if application != "" {
		applicationC = C.CString(application)
		defer C.free(unsafe.Pointer(applicationC))
	}
	tmpValue := NewQSettingsFromPointer(C.QSettings_NewQSettings2(C.longlong(scope), C.struct_QtCore_PackedString{data: organizationC, len: C.longlong(len(organization))}, C.struct_QtCore_PackedString{data: applicationC, len: C.longlong(len(application))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSettings3(format QSettings__Format, scope QSettings__Scope, organization string, application string, parent QObject_ITF) *QSettings {
	var organizationC *C.char
	if organization != "" {
		organizationC = C.CString(organization)
		defer C.free(unsafe.Pointer(organizationC))
	}
	var applicationC *C.char
	if application != "" {
		applicationC = C.CString(application)
		defer C.free(unsafe.Pointer(applicationC))
	}
	tmpValue := NewQSettingsFromPointer(C.QSettings_NewQSettings3(C.longlong(format), C.longlong(scope), C.struct_QtCore_PackedString{data: organizationC, len: C.longlong(len(organization))}, C.struct_QtCore_PackedString{data: applicationC, len: C.longlong(len(application))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSettings4(fileName string, format QSettings__Format, parent QObject_ITF) *QSettings {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	tmpValue := NewQSettingsFromPointer(C.QSettings_NewQSettings4(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(format), PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSettings5(parent QObject_ITF) *QSettings {
	tmpValue := NewQSettingsFromPointer(C.QSettings_NewQSettings5(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSettings6(scope QSettings__Scope, parent QObject_ITF) *QSettings {
	tmpValue := NewQSettingsFromPointer(C.QSettings_NewQSettings6(C.longlong(scope), PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QSettings) AllKeys() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QSettings_AllKeys(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QSettings) ApplicationName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSettings_ApplicationName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSettings) BeginGroup(prefix string) {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		C.QSettings_BeginGroup(ptr.Pointer(), C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))})
	}
}

func (ptr *QSettings) BeginReadArray(prefix string) int {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		return int(int32(C.QSettings_BeginReadArray(ptr.Pointer(), C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))})))
	}
	return 0
}

func (ptr *QSettings) BeginWriteArray(prefix string, size int) {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		C.QSettings_BeginWriteArray(ptr.Pointer(), C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))}, C.int(int32(size)))
	}
}

func (ptr *QSettings) ChildGroups() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QSettings_ChildGroups(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QSettings) ChildKeys() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QSettings_ChildKeys(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QSettings) Clear() {
	if ptr.Pointer() != nil {
		C.QSettings_Clear(ptr.Pointer())
	}
}

func (ptr *QSettings) Contains(key string) bool {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		return int8(C.QSettings_Contains(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})) != 0
	}
	return false
}

func QSettings_DefaultFormat() QSettings__Format {
	return QSettings__Format(C.QSettings_QSettings_DefaultFormat())
}

func (ptr *QSettings) DefaultFormat() QSettings__Format {
	return QSettings__Format(C.QSettings_QSettings_DefaultFormat())
}

func (ptr *QSettings) EndArray() {
	if ptr.Pointer() != nil {
		C.QSettings_EndArray(ptr.Pointer())
	}
}

func (ptr *QSettings) EndGroup() {
	if ptr.Pointer() != nil {
		C.QSettings_EndGroup(ptr.Pointer())
	}
}

func (ptr *QSettings) FallbacksEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSettings_FallbacksEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSettings) FileName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSettings_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSettings) Format() QSettings__Format {
	if ptr.Pointer() != nil {
		return QSettings__Format(C.QSettings_Format(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSettings) Group() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSettings_Group(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSettings) IniCodec() *QTextCodec {
	if ptr.Pointer() != nil {
		return NewQTextCodecFromPointer(C.QSettings_IniCodec(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSettings) IsAtomicSyncRequired() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSettings_IsAtomicSyncRequired(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSettings) IsWritable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSettings_IsWritable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSettings) OrganizationName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSettings_OrganizationName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSettings) Remove(key string) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QSettings_Remove(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})
	}
}

func (ptr *QSettings) Scope() QSettings__Scope {
	if ptr.Pointer() != nil {
		return QSettings__Scope(C.QSettings_Scope(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSettings) SetArrayIndex(i int) {
	if ptr.Pointer() != nil {
		C.QSettings_SetArrayIndex(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QSettings) SetAtomicSyncRequired(enable bool) {
	if ptr.Pointer() != nil {
		C.QSettings_SetAtomicSyncRequired(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func QSettings_SetDefaultFormat(format QSettings__Format) {
	C.QSettings_QSettings_SetDefaultFormat(C.longlong(format))
}

func (ptr *QSettings) SetDefaultFormat(format QSettings__Format) {
	C.QSettings_QSettings_SetDefaultFormat(C.longlong(format))
}

func (ptr *QSettings) SetFallbacksEnabled(b bool) {
	if ptr.Pointer() != nil {
		C.QSettings_SetFallbacksEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QSettings) SetIniCodec(codec QTextCodec_ITF) {
	if ptr.Pointer() != nil {
		C.QSettings_SetIniCodec(ptr.Pointer(), PointerFromQTextCodec(codec))
	}
}

func (ptr *QSettings) SetIniCodec2(codecName string) {
	if ptr.Pointer() != nil {
		var codecNameC *C.char
		if codecName != "" {
			codecNameC = C.CString(codecName)
			defer C.free(unsafe.Pointer(codecNameC))
		}
		C.QSettings_SetIniCodec2(ptr.Pointer(), codecNameC)
	}
}

func QSettings_SetPath(format QSettings__Format, scope QSettings__Scope, path string) {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	C.QSettings_QSettings_SetPath(C.longlong(format), C.longlong(scope), C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
}

func (ptr *QSettings) SetPath(format QSettings__Format, scope QSettings__Scope, path string) {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	C.QSettings_QSettings_SetPath(C.longlong(format), C.longlong(scope), C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
}

func (ptr *QSettings) SetValue(key string, value QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QSettings_SetValue(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(value))
	}
}

func (ptr *QSettings) Status() QSettings__Status {
	if ptr.Pointer() != nil {
		return QSettings__Status(C.QSettings_Status(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSettings) Sync() {
	if ptr.Pointer() != nil {
		C.QSettings_Sync(ptr.Pointer())
	}
}

func (ptr *QSettings) Value(key string, defaultValue QVariant_ITF) *QVariant {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		tmpValue := NewQVariantFromPointer(C.QSettings_Value(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(defaultValue)))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQSettings_DestroyQSettings
func callbackQSettings_DestroyQSettings(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSettings"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSettingsFromPointer(ptr).DestroyQSettingsDefault()
	}
}

func (ptr *QSettings) ConnectDestroyQSettings(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSettings"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSettings", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSettings", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSettings) DisconnectDestroyQSettings() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSettings")
	}
}

func (ptr *QSettings) DestroyQSettings() {
	if ptr.Pointer() != nil {
		C.QSettings_DestroyQSettings(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSettings) DestroyQSettingsDefault() {
	if ptr.Pointer() != nil {
		C.QSettings_DestroyQSettingsDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSharedData struct {
	ptr unsafe.Pointer
}

type QSharedData_ITF interface {
	QSharedData_PTR() *QSharedData
}

func (ptr *QSharedData) QSharedData_PTR() *QSharedData {
	return ptr
}

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

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

func PointerFromQSharedData(ptr QSharedData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSharedData_PTR().Pointer()
	}
	return nil
}

func NewQSharedDataFromPointer(ptr unsafe.Pointer) (n *QSharedData) {
	n = new(QSharedData)
	n.SetPointer(ptr)
	return
}

func (ptr *QSharedData) DestroyQSharedData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQSharedData() *QSharedData {
	tmpValue := NewQSharedDataFromPointer(C.QSharedData_NewQSharedData())
	runtime.SetFinalizer(tmpValue, (*QSharedData).DestroyQSharedData)
	return tmpValue
}

func NewQSharedData2(vqs QSharedData_ITF) *QSharedData {
	tmpValue := NewQSharedDataFromPointer(C.QSharedData_NewQSharedData2(PointerFromQSharedData(vqs)))
	runtime.SetFinalizer(tmpValue, (*QSharedData).DestroyQSharedData)
	return tmpValue
}

type QSharedDataPointer struct {
	ptr unsafe.Pointer
}

type QSharedDataPointer_ITF interface {
	QSharedDataPointer_PTR() *QSharedDataPointer
}

func (ptr *QSharedDataPointer) QSharedDataPointer_PTR() *QSharedDataPointer {
	return ptr
}

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

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

func PointerFromQSharedDataPointer(ptr QSharedDataPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSharedDataPointer_PTR().Pointer()
	}
	return nil
}

func NewQSharedDataPointerFromPointer(ptr unsafe.Pointer) (n *QSharedDataPointer) {
	n = new(QSharedDataPointer)
	n.SetPointer(ptr)
	return
}

type QSharedMemory struct {
	QObject
}

type QSharedMemory_ITF interface {
	QObject_ITF
	QSharedMemory_PTR() *QSharedMemory
}

func (ptr *QSharedMemory) QSharedMemory_PTR() *QSharedMemory {
	return ptr
}

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

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

func PointerFromQSharedMemory(ptr QSharedMemory_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSharedMemory_PTR().Pointer()
	}
	return nil
}

func NewQSharedMemoryFromPointer(ptr unsafe.Pointer) (n *QSharedMemory) {
	n = new(QSharedMemory)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QSharedMemory__AccessMode
//QSharedMemory::AccessMode
type QSharedMemory__AccessMode int64

const (
	QSharedMemory__ReadOnly  QSharedMemory__AccessMode = QSharedMemory__AccessMode(0)
	QSharedMemory__ReadWrite QSharedMemory__AccessMode = QSharedMemory__AccessMode(1)
)

//go:generate stringer -type=QSharedMemory__SharedMemoryError
//QSharedMemory::SharedMemoryError
type QSharedMemory__SharedMemoryError int64

const (
	QSharedMemory__NoError          QSharedMemory__SharedMemoryError = QSharedMemory__SharedMemoryError(0)
	QSharedMemory__PermissionDenied QSharedMemory__SharedMemoryError = QSharedMemory__SharedMemoryError(1)
	QSharedMemory__InvalidSize      QSharedMemory__SharedMemoryError = QSharedMemory__SharedMemoryError(2)
	QSharedMemory__KeyError         QSharedMemory__SharedMemoryError = QSharedMemory__SharedMemoryError(3)
	QSharedMemory__AlreadyExists    QSharedMemory__SharedMemoryError = QSharedMemory__SharedMemoryError(4)
	QSharedMemory__NotFound         QSharedMemory__SharedMemoryError = QSharedMemory__SharedMemoryError(5)
	QSharedMemory__LockError        QSharedMemory__SharedMemoryError = QSharedMemory__SharedMemoryError(6)
	QSharedMemory__OutOfResources   QSharedMemory__SharedMemoryError = QSharedMemory__SharedMemoryError(7)
	QSharedMemory__UnknownError     QSharedMemory__SharedMemoryError = QSharedMemory__SharedMemoryError(8)
)

func NewQSharedMemory(key string, parent QObject_ITF) *QSharedMemory {
	var keyC *C.char
	if key != "" {
		keyC = C.CString(key)
		defer C.free(unsafe.Pointer(keyC))
	}
	tmpValue := NewQSharedMemoryFromPointer(C.QSharedMemory_NewQSharedMemory(C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSharedMemory2(parent QObject_ITF) *QSharedMemory {
	tmpValue := NewQSharedMemoryFromPointer(C.QSharedMemory_NewQSharedMemory2(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QSharedMemory) Attach(mode QSharedMemory__AccessMode) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSharedMemory_Attach(ptr.Pointer(), C.longlong(mode))) != 0
	}
	return false
}

func (ptr *QSharedMemory) ConstData() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QSharedMemory_ConstData(ptr.Pointer())
	}
	return nil
}

func (ptr *QSharedMemory) Create(size int, mode QSharedMemory__AccessMode) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSharedMemory_Create(ptr.Pointer(), C.int(int32(size)), C.longlong(mode))) != 0
	}
	return false
}

func (ptr *QSharedMemory) Data() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QSharedMemory_Data(ptr.Pointer())
	}
	return nil
}

func (ptr *QSharedMemory) Data2() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QSharedMemory_Data2(ptr.Pointer())
	}
	return nil
}

func (ptr *QSharedMemory) Detach() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSharedMemory_Detach(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSharedMemory) Error() QSharedMemory__SharedMemoryError {
	if ptr.Pointer() != nil {
		return QSharedMemory__SharedMemoryError(C.QSharedMemory_Error(ptr.Pointer()))
	}
	return 0
}

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

func (ptr *QSharedMemory) IsAttached() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSharedMemory_IsAttached(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSharedMemory) Key() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSharedMemory_Key(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSharedMemory) Lock() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSharedMemory_Lock(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSharedMemory) NativeKey() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSharedMemory_NativeKey(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSharedMemory) SetKey(key string) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QSharedMemory_SetKey(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})
	}
}

func (ptr *QSharedMemory) SetNativeKey(key string) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QSharedMemory_SetNativeKey(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})
	}
}

func (ptr *QSharedMemory) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSharedMemory_Size(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSharedMemory) Unlock() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSharedMemory_Unlock(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQSharedMemory_DestroyQSharedMemory
func callbackQSharedMemory_DestroyQSharedMemory(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSharedMemory"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSharedMemoryFromPointer(ptr).DestroyQSharedMemoryDefault()
	}
}

func (ptr *QSharedMemory) ConnectDestroyQSharedMemory(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSharedMemory"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSharedMemory", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSharedMemory", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSharedMemory) DisconnectDestroyQSharedMemory() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSharedMemory")
	}
}

func (ptr *QSharedMemory) DestroyQSharedMemory() {
	if ptr.Pointer() != nil {
		C.QSharedMemory_DestroyQSharedMemory(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSharedMemory) DestroyQSharedMemoryDefault() {
	if ptr.Pointer() != nil {
		C.QSharedMemory_DestroyQSharedMemoryDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSharedPointer struct {
	ptr unsafe.Pointer
}

type QSharedPointer_ITF interface {
	QSharedPointer_PTR() *QSharedPointer
}

func (ptr *QSharedPointer) QSharedPointer_PTR() *QSharedPointer {
	return ptr
}

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

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

func PointerFromQSharedPointer(ptr QSharedPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSharedPointer_PTR().Pointer()
	}
	return nil
}

func NewQSharedPointerFromPointer(ptr unsafe.Pointer) (n *QSharedPointer) {
	n = new(QSharedPointer)
	n.SetPointer(ptr)
	return
}

type QSignalBlocker struct {
	ptr unsafe.Pointer
}

type QSignalBlocker_ITF interface {
	QSignalBlocker_PTR() *QSignalBlocker
}

func (ptr *QSignalBlocker) QSignalBlocker_PTR() *QSignalBlocker {
	return ptr
}

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

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

func PointerFromQSignalBlocker(ptr QSignalBlocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSignalBlocker_PTR().Pointer()
	}
	return nil
}

func NewQSignalBlockerFromPointer(ptr unsafe.Pointer) (n *QSignalBlocker) {
	n = new(QSignalBlocker)
	n.SetPointer(ptr)
	return
}
func NewQSignalBlocker(object QObject_ITF) *QSignalBlocker {
	tmpValue := NewQSignalBlockerFromPointer(C.QSignalBlocker_NewQSignalBlocker(PointerFromQObject(object)))
	runtime.SetFinalizer(tmpValue, (*QSignalBlocker).DestroyQSignalBlocker)
	return tmpValue
}

func NewQSignalBlocker2(object QObject_ITF) *QSignalBlocker {
	tmpValue := NewQSignalBlockerFromPointer(C.QSignalBlocker_NewQSignalBlocker2(PointerFromQObject(object)))
	runtime.SetFinalizer(tmpValue, (*QSignalBlocker).DestroyQSignalBlocker)
	return tmpValue
}

func (ptr *QSignalBlocker) Reblock() {
	if ptr.Pointer() != nil {
		C.QSignalBlocker_Reblock(ptr.Pointer())
	}
}

func (ptr *QSignalBlocker) Unblock() {
	if ptr.Pointer() != nil {
		C.QSignalBlocker_Unblock(ptr.Pointer())
	}
}

func (ptr *QSignalBlocker) DestroyQSignalBlocker() {
	if ptr.Pointer() != nil {
		C.QSignalBlocker_DestroyQSignalBlocker(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSignalMapper struct {
	QObject
}

type QSignalMapper_ITF interface {
	QObject_ITF
	QSignalMapper_PTR() *QSignalMapper
}

func (ptr *QSignalMapper) QSignalMapper_PTR() *QSignalMapper {
	return ptr
}

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

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

func PointerFromQSignalMapper(ptr QSignalMapper_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSignalMapper_PTR().Pointer()
	}
	return nil
}

func NewQSignalMapperFromPointer(ptr unsafe.Pointer) (n *QSignalMapper) {
	n = new(QSignalMapper)
	n.SetPointer(ptr)
	return
}

type QSignalTransition struct {
	QAbstractTransition
}

type QSignalTransition_ITF interface {
	QAbstractTransition_ITF
	QSignalTransition_PTR() *QSignalTransition
}

func (ptr *QSignalTransition) QSignalTransition_PTR() *QSignalTransition {
	return ptr
}

func (ptr *QSignalTransition) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractTransition_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQSignalTransition(ptr QSignalTransition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSignalTransition_PTR().Pointer()
	}
	return nil
}

func NewQSignalTransitionFromPointer(ptr unsafe.Pointer) (n *QSignalTransition) {
	n = new(QSignalTransition)
	n.SetPointer(ptr)
	return
}
func NewQSignalTransition(sourceState QState_ITF) *QSignalTransition {
	tmpValue := NewQSignalTransitionFromPointer(C.QSignalTransition_NewQSignalTransition(PointerFromQState(sourceState)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSignalTransition2(sender QObject_ITF, sign string, sourceState QState_ITF) *QSignalTransition {
	var signC *C.char
	if sign != "" {
		signC = C.CString(sign)
		defer C.free(unsafe.Pointer(signC))
	}
	tmpValue := NewQSignalTransitionFromPointer(C.QSignalTransition_NewQSignalTransition2(PointerFromQObject(sender), signC, PointerFromQState(sourceState)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

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

	return C.char(int8(qt.GoBoolToInt(NewQSignalTransitionFromPointer(ptr).EventTestDefault(NewQEventFromPointer(event)))))
}

func (ptr *QSignalTransition) ConnectEventTest(f func(event *QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "eventTest"); signal != nil {
			f := func(event *QEvent) bool {
				(*(*func(*QEvent) bool)(signal))(event)
				return f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "eventTest", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "eventTest", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSignalTransition) DisconnectEventTest() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "eventTest")
	}
}

func (ptr *QSignalTransition) EventTest(event QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSignalTransition_EventTest(ptr.Pointer(), PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QSignalTransition) EventTestDefault(event QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSignalTransition_EventTestDefault(ptr.Pointer(), PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQSignalTransition_OnTransition
func callbackQSignalTransition_OnTransition(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onTransition"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	} else {
		NewQSignalTransitionFromPointer(ptr).OnTransitionDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSignalTransition) ConnectOnTransition(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onTransition"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onTransition", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onTransition", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSignalTransition) DisconnectOnTransition() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onTransition")
	}
}

func (ptr *QSignalTransition) OnTransition(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSignalTransition_OnTransition(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSignalTransition) OnTransitionDefault(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSignalTransition_OnTransitionDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSignalTransition) SenderObject() *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QSignalTransition_SenderObject(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQSignalTransition_SenderObjectChanged
func callbackQSignalTransition_SenderObjectChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "senderObjectChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QSignalTransition) ConnectSenderObjectChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "senderObjectChanged") {
			C.QSignalTransition_ConnectSenderObjectChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "senderObjectChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "senderObjectChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "senderObjectChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "senderObjectChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSignalTransition) DisconnectSenderObjectChanged() {
	if ptr.Pointer() != nil {
		C.QSignalTransition_DisconnectSenderObjectChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "senderObjectChanged")
	}
}

func (ptr *QSignalTransition) SetSenderObject(sender QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSignalTransition_SetSenderObject(ptr.Pointer(), PointerFromQObject(sender))
	}
}

func (ptr *QSignalTransition) SetSignal(sign QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QSignalTransition_SetSignal(ptr.Pointer(), PointerFromQByteArray(sign))
	}
}

func (ptr *QSignalTransition) Signal() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QSignalTransition_Signal(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

//export callbackQSignalTransition_SignalChanged
func callbackQSignalTransition_SignalChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "signalChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QSignalTransition) ConnectSignalChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "signalChanged") {
			C.QSignalTransition_ConnectSignalChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "signalChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "signalChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "signalChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "signalChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSignalTransition) DisconnectSignalChanged() {
	if ptr.Pointer() != nil {
		C.QSignalTransition_DisconnectSignalChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "signalChanged")
	}
}

//export callbackQSignalTransition_DestroyQSignalTransition
func callbackQSignalTransition_DestroyQSignalTransition(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSignalTransition"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSignalTransitionFromPointer(ptr).DestroyQSignalTransitionDefault()
	}
}

func (ptr *QSignalTransition) ConnectDestroyQSignalTransition(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSignalTransition"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSignalTransition", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSignalTransition", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSignalTransition) DisconnectDestroyQSignalTransition() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSignalTransition")
	}
}

func (ptr *QSignalTransition) DestroyQSignalTransition() {
	if ptr.Pointer() != nil {
		C.QSignalTransition_DestroyQSignalTransition(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSignalTransition) DestroyQSignalTransitionDefault() {
	if ptr.Pointer() != nil {
		C.QSignalTransition_DestroyQSignalTransitionDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSize struct {
	ptr unsafe.Pointer
}

type QSize_ITF interface {
	QSize_PTR() *QSize
}

func (ptr *QSize) QSize_PTR() *QSize {
	return ptr
}

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

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

func PointerFromQSize(ptr QSize_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSize_PTR().Pointer()
	}
	return nil
}

func NewQSizeFromPointer(ptr unsafe.Pointer) (n *QSize) {
	n = new(QSize)
	n.SetPointer(ptr)
	return
}

func (ptr *QSize) DestroyQSize() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQSize() *QSize {
	tmpValue := NewQSizeFromPointer(C.QSize_NewQSize())
	runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
	return tmpValue
}

func NewQSize2(width int, height int) *QSize {
	tmpValue := NewQSizeFromPointer(C.QSize_NewQSize2(C.int(int32(width)), C.int(int32(height))))
	runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
	return tmpValue
}

func (ptr *QSize) BoundedTo(otherSize QSize_ITF) *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QSize_BoundedTo(ptr.Pointer(), PointerFromQSize(otherSize)))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSize) ExpandedTo(otherSize QSize_ITF) *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QSize_ExpandedTo(ptr.Pointer(), PointerFromQSize(otherSize)))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSize) Height() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSize_Height(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSize) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSize_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSize) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSize_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSize) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSize_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSize) Rheight() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSize_Rheight(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSize) Rwidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSize_Rwidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSize) Scale(width int, height int, mode Qt__AspectRatioMode) {
	if ptr.Pointer() != nil {
		C.QSize_Scale(ptr.Pointer(), C.int(int32(width)), C.int(int32(height)), C.longlong(mode))
	}
}

func (ptr *QSize) Scale2(size QSize_ITF, mode Qt__AspectRatioMode) {
	if ptr.Pointer() != nil {
		C.QSize_Scale2(ptr.Pointer(), PointerFromQSize(size), C.longlong(mode))
	}
}

func (ptr *QSize) Scaled(width int, height int, mode Qt__AspectRatioMode) *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QSize_Scaled(ptr.Pointer(), C.int(int32(width)), C.int(int32(height)), C.longlong(mode)))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSize) Scaled2(s QSize_ITF, mode Qt__AspectRatioMode) *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QSize_Scaled2(ptr.Pointer(), PointerFromQSize(s), C.longlong(mode)))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSize) SetHeight(height int) {
	if ptr.Pointer() != nil {
		C.QSize_SetHeight(ptr.Pointer(), C.int(int32(height)))
	}
}

func (ptr *QSize) SetWidth(width int) {
	if ptr.Pointer() != nil {
		C.QSize_SetWidth(ptr.Pointer(), C.int(int32(width)))
	}
}

func (ptr *QSize) Transpose() {
	if ptr.Pointer() != nil {
		C.QSize_Transpose(ptr.Pointer())
	}
}

func (ptr *QSize) Transposed() *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QSize_Transposed(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSize) Width() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSize_Width(ptr.Pointer())))
	}
	return 0
}

type QSizeF struct {
	ptr unsafe.Pointer
}

type QSizeF_ITF interface {
	QSizeF_PTR() *QSizeF
}

func (ptr *QSizeF) QSizeF_PTR() *QSizeF {
	return ptr
}

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

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

func PointerFromQSizeF(ptr QSizeF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSizeF_PTR().Pointer()
	}
	return nil
}

func NewQSizeFFromPointer(ptr unsafe.Pointer) (n *QSizeF) {
	n = new(QSizeF)
	n.SetPointer(ptr)
	return
}

func (ptr *QSizeF) DestroyQSizeF() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQSizeF() *QSizeF {
	tmpValue := NewQSizeFFromPointer(C.QSizeF_NewQSizeF())
	runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
	return tmpValue
}

func NewQSizeF2(size QSize_ITF) *QSizeF {
	tmpValue := NewQSizeFFromPointer(C.QSizeF_NewQSizeF2(PointerFromQSize(size)))
	runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
	return tmpValue
}

func NewQSizeF3(width float64, height float64) *QSizeF {
	tmpValue := NewQSizeFFromPointer(C.QSizeF_NewQSizeF3(C.double(width), C.double(height)))
	runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
	return tmpValue
}

func (ptr *QSizeF) BoundedTo(otherSize QSizeF_ITF) *QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFFromPointer(C.QSizeF_BoundedTo(ptr.Pointer(), PointerFromQSizeF(otherSize)))
		runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QSizeF) ExpandedTo(otherSize QSizeF_ITF) *QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFFromPointer(C.QSizeF_ExpandedTo(ptr.Pointer(), PointerFromQSizeF(otherSize)))
		runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

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

func (ptr *QSizeF) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSizeF_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSizeF) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSizeF_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSizeF) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSizeF_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSizeF) Rheight() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QSizeF_Rheight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSizeF) Rwidth() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QSizeF_Rwidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSizeF) Scale(width float64, height float64, mode Qt__AspectRatioMode) {
	if ptr.Pointer() != nil {
		C.QSizeF_Scale(ptr.Pointer(), C.double(width), C.double(height), C.longlong(mode))
	}
}

func (ptr *QSizeF) Scale2(size QSizeF_ITF, mode Qt__AspectRatioMode) {
	if ptr.Pointer() != nil {
		C.QSizeF_Scale2(ptr.Pointer(), PointerFromQSizeF(size), C.longlong(mode))
	}
}

func (ptr *QSizeF) Scaled(width float64, height float64, mode Qt__AspectRatioMode) *QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFFromPointer(C.QSizeF_Scaled(ptr.Pointer(), C.double(width), C.double(height), C.longlong(mode)))
		runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QSizeF) Scaled2(s QSizeF_ITF, mode Qt__AspectRatioMode) *QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFFromPointer(C.QSizeF_Scaled2(ptr.Pointer(), PointerFromQSizeF(s), C.longlong(mode)))
		runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QSizeF) SetHeight(height float64) {
	if ptr.Pointer() != nil {
		C.QSizeF_SetHeight(ptr.Pointer(), C.double(height))
	}
}

func (ptr *QSizeF) SetWidth(width float64) {
	if ptr.Pointer() != nil {
		C.QSizeF_SetWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QSizeF) ToSize() *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QSizeF_ToSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSizeF) Transpose() {
	if ptr.Pointer() != nil {
		C.QSizeF_Transpose(ptr.Pointer())
	}
}

func (ptr *QSizeF) Transposed() *QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFFromPointer(C.QSizeF_Transposed(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

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

type QSocketNotifier struct {
	QObject
}

type QSocketNotifier_ITF interface {
	QObject_ITF
	QSocketNotifier_PTR() *QSocketNotifier
}

func (ptr *QSocketNotifier) QSocketNotifier_PTR() *QSocketNotifier {
	return ptr
}

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

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

func PointerFromQSocketNotifier(ptr QSocketNotifier_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSocketNotifier_PTR().Pointer()
	}
	return nil
}

func NewQSocketNotifierFromPointer(ptr unsafe.Pointer) (n *QSocketNotifier) {
	n = new(QSocketNotifier)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QSocketNotifier__Type
//QSocketNotifier::Type
type QSocketNotifier__Type int64

const (
	QSocketNotifier__Read      QSocketNotifier__Type = QSocketNotifier__Type(0)
	QSocketNotifier__Write     QSocketNotifier__Type = QSocketNotifier__Type(1)
	QSocketNotifier__Exception QSocketNotifier__Type = QSocketNotifier__Type(2)
)

//export callbackQSocketNotifier_Activated
func callbackQSocketNotifier_Activated(ptr unsafe.Pointer, socket C.int) {
	if signal := qt.GetSignal(ptr, "activated"); signal != nil {
		(*(*func(int))(signal))(int(int32(socket)))
	}

}

func (ptr *QSocketNotifier) ConnectActivated(f func(socket int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activated") {
			C.QSocketNotifier_ConnectActivated(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "activated")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "activated"); signal != nil {
			f := func(socket int) {
				(*(*func(int))(signal))(socket)
				f(socket)
			}
			qt.ConnectSignal(ptr.Pointer(), "activated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "activated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSocketNotifier) DisconnectActivated() {
	if ptr.Pointer() != nil {
		C.QSocketNotifier_DisconnectActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activated")
	}
}

func (ptr *QSocketNotifier) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSocketNotifier_IsEnabled(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQSocketNotifier_SetEnabled
func callbackQSocketNotifier_SetEnabled(ptr unsafe.Pointer, enable C.char) {
	if signal := qt.GetSignal(ptr, "setEnabled"); signal != nil {
		(*(*func(bool))(signal))(int8(enable) != 0)
	} else {
		NewQSocketNotifierFromPointer(ptr).SetEnabledDefault(int8(enable) != 0)
	}
}

func (ptr *QSocketNotifier) ConnectSetEnabled(f func(enable bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setEnabled"); signal != nil {
			f := func(enable bool) {
				(*(*func(bool))(signal))(enable)
				f(enable)
			}
			qt.ConnectSignal(ptr.Pointer(), "setEnabled", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setEnabled", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSocketNotifier) DisconnectSetEnabled() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setEnabled")
	}
}

func (ptr *QSocketNotifier) SetEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QSocketNotifier_SetEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QSocketNotifier) SetEnabledDefault(enable bool) {
	if ptr.Pointer() != nil {
		C.QSocketNotifier_SetEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QSocketNotifier) Type() QSocketNotifier__Type {
	if ptr.Pointer() != nil {
		return QSocketNotifier__Type(C.QSocketNotifier_Type(ptr.Pointer()))
	}
	return 0
}

//export callbackQSocketNotifier_DestroyQSocketNotifier
func callbackQSocketNotifier_DestroyQSocketNotifier(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSocketNotifier"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSocketNotifierFromPointer(ptr).DestroyQSocketNotifierDefault()
	}
}

func (ptr *QSocketNotifier) ConnectDestroyQSocketNotifier(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSocketNotifier"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSocketNotifier", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSocketNotifier", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSocketNotifier) DisconnectDestroyQSocketNotifier() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSocketNotifier")
	}
}

func (ptr *QSocketNotifier) DestroyQSocketNotifier() {
	if ptr.Pointer() != nil {
		C.QSocketNotifier_DestroyQSocketNotifier(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSocketNotifier) DestroyQSocketNotifierDefault() {
	if ptr.Pointer() != nil {
		C.QSocketNotifier_DestroyQSocketNotifierDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSortFilterProxyModel struct {
	QAbstractProxyModel
}

type QSortFilterProxyModel_ITF interface {
	QAbstractProxyModel_ITF
	QSortFilterProxyModel_PTR() *QSortFilterProxyModel
}

func (ptr *QSortFilterProxyModel) QSortFilterProxyModel_PTR() *QSortFilterProxyModel {
	return ptr
}

func (ptr *QSortFilterProxyModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractProxyModel_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQSortFilterProxyModel(ptr QSortFilterProxyModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSortFilterProxyModel_PTR().Pointer()
	}
	return nil
}

func NewQSortFilterProxyModelFromPointer(ptr unsafe.Pointer) (n *QSortFilterProxyModel) {
	n = new(QSortFilterProxyModel)
	n.SetPointer(ptr)
	return
}
func NewQSortFilterProxyModel(parent QObject_ITF) *QSortFilterProxyModel {
	tmpValue := NewQSortFilterProxyModelFromPointer(C.QSortFilterProxyModel_NewQSortFilterProxyModel(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQSortFilterProxyModel_ColumnCount
func callbackQSortFilterProxyModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQSortFilterProxyModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QSortFilterProxyModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectColumnCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnCount")
	}
}

func (ptr *QSortFilterProxyModel) ColumnCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSortFilterProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) ColumnCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSortFilterProxyModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) DynamicSortFilter() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSortFilterProxyModel_DynamicSortFilter(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQSortFilterProxyModel_FilterAcceptsColumn
func callbackQSortFilterProxyModel_FilterAcceptsColumn(ptr unsafe.Pointer, source_column C.int, source_parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "filterAcceptsColumn"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, *QModelIndex) bool)(signal))(int(int32(source_column)), NewQModelIndexFromPointer(source_parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).FilterAcceptsColumnDefault(int(int32(source_column)), NewQModelIndexFromPointer(source_parent)))))
}

func (ptr *QSortFilterProxyModel) ConnectFilterAcceptsColumn(f func(source_column int, source_parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "filterAcceptsColumn"); signal != nil {
			f := func(source_column int, source_parent *QModelIndex) bool {
				(*(*func(int, *QModelIndex) bool)(signal))(source_column, source_parent)
				return f(source_column, source_parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "filterAcceptsColumn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "filterAcceptsColumn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectFilterAcceptsColumn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "filterAcceptsColumn")
	}
}

func (ptr *QSortFilterProxyModel) FilterAcceptsColumn(source_column int, source_parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSortFilterProxyModel_FilterAcceptsColumn(ptr.Pointer(), C.int(int32(source_column)), PointerFromQModelIndex(source_parent))) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) FilterAcceptsColumnDefault(source_column int, source_parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSortFilterProxyModel_FilterAcceptsColumnDefault(ptr.Pointer(), C.int(int32(source_column)), PointerFromQModelIndex(source_parent))) != 0
	}
	return false
}

//export callbackQSortFilterProxyModel_FilterAcceptsRow
func callbackQSortFilterProxyModel_FilterAcceptsRow(ptr unsafe.Pointer, source_row C.int, source_parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "filterAcceptsRow"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, *QModelIndex) bool)(signal))(int(int32(source_row)), NewQModelIndexFromPointer(source_parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).FilterAcceptsRowDefault(int(int32(source_row)), NewQModelIndexFromPointer(source_parent)))))
}

func (ptr *QSortFilterProxyModel) ConnectFilterAcceptsRow(f func(source_row int, source_parent *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "filterAcceptsRow"); signal != nil {
			f := func(source_row int, source_parent *QModelIndex) bool {
				(*(*func(int, *QModelIndex) bool)(signal))(source_row, source_parent)
				return f(source_row, source_parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "filterAcceptsRow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "filterAcceptsRow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectFilterAcceptsRow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "filterAcceptsRow")
	}
}

func (ptr *QSortFilterProxyModel) FilterAcceptsRow(source_row int, source_parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSortFilterProxyModel_FilterAcceptsRow(ptr.Pointer(), C.int(int32(source_row)), PointerFromQModelIndex(source_parent))) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) FilterAcceptsRowDefault(source_row int, source_parent QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSortFilterProxyModel_FilterAcceptsRowDefault(ptr.Pointer(), C.int(int32(source_row)), PointerFromQModelIndex(source_parent))) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) FilterCaseSensitivity() Qt__CaseSensitivity {
	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QSortFilterProxyModel_FilterCaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) FilterKeyColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSortFilterProxyModel_FilterKeyColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) FilterRegExp() *QRegExp {
	if ptr.Pointer() != nil {
		tmpValue := NewQRegExpFromPointer(C.QSortFilterProxyModel_FilterRegExp(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRegExp).DestroyQRegExp)
		return tmpValue
	}
	return nil
}

func (ptr *QSortFilterProxyModel) FilterRegularExpression() *QRegularExpression {
	if ptr.Pointer() != nil {
		tmpValue := NewQRegularExpressionFromPointer(C.QSortFilterProxyModel_FilterRegularExpression(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRegularExpression).DestroyQRegularExpression)
		return tmpValue
	}
	return nil
}

func (ptr *QSortFilterProxyModel) FilterRole() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSortFilterProxyModel_FilterRole(ptr.Pointer())))
	}
	return 0
}

//export callbackQSortFilterProxyModel_Index
func callbackQSortFilterProxyModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return PointerFromQModelIndex((*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
	}

	return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).IndexDefault(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
}

func (ptr *QSortFilterProxyModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "index"); signal != nil {
			f := func(row int, column int, parent *QModelIndex) *QModelIndex {
				(*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(row, column, parent)
				return f(row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "index")
	}
}

func (ptr *QSortFilterProxyModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QSortFilterProxyModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QSortFilterProxyModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QSortFilterProxyModel_IndexDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQSortFilterProxyModel_Invalidate
func callbackQSortFilterProxyModel_Invalidate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "invalidate"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).InvalidateDefault()
	}
}

func (ptr *QSortFilterProxyModel) ConnectInvalidate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "invalidate"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "invalidate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "invalidate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectInvalidate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "invalidate")
	}
}

func (ptr *QSortFilterProxyModel) Invalidate() {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_Invalidate(ptr.Pointer())
	}
}

func (ptr *QSortFilterProxyModel) InvalidateDefault() {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_InvalidateDefault(ptr.Pointer())
	}
}

func (ptr *QSortFilterProxyModel) InvalidateFilter() {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_InvalidateFilter(ptr.Pointer())
	}
}

func (ptr *QSortFilterProxyModel) IsRecursiveFilteringEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSortFilterProxyModel_IsRecursiveFilteringEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) IsSortLocaleAware() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSortFilterProxyModel_IsSortLocaleAware(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQSortFilterProxyModel_LessThan
func callbackQSortFilterProxyModel_LessThan(ptr unsafe.Pointer, source_left unsafe.Pointer, source_right unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "lessThan"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QModelIndex, *QModelIndex) bool)(signal))(NewQModelIndexFromPointer(source_left), NewQModelIndexFromPointer(source_right)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSortFilterProxyModelFromPointer(ptr).LessThanDefault(NewQModelIndexFromPointer(source_left), NewQModelIndexFromPointer(source_right)))))
}

func (ptr *QSortFilterProxyModel) ConnectLessThan(f func(source_left *QModelIndex, source_right *QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "lessThan"); signal != nil {
			f := func(source_left *QModelIndex, source_right *QModelIndex) bool {
				(*(*func(*QModelIndex, *QModelIndex) bool)(signal))(source_left, source_right)
				return f(source_left, source_right)
			}
			qt.ConnectSignal(ptr.Pointer(), "lessThan", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "lessThan", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectLessThan() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "lessThan")
	}
}

func (ptr *QSortFilterProxyModel) LessThan(source_left QModelIndex_ITF, source_right QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSortFilterProxyModel_LessThan(ptr.Pointer(), PointerFromQModelIndex(source_left), PointerFromQModelIndex(source_right))) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) LessThanDefault(source_left QModelIndex_ITF, source_right QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSortFilterProxyModel_LessThanDefault(ptr.Pointer(), PointerFromQModelIndex(source_left), PointerFromQModelIndex(source_right))) != 0
	}
	return false
}

//export callbackQSortFilterProxyModel_MapFromSource
func callbackQSortFilterProxyModel_MapFromSource(ptr unsafe.Pointer, sourceIndex unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapFromSource"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(sourceIndex)))
	}

	return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).MapFromSourceDefault(NewQModelIndexFromPointer(sourceIndex)))
}

func (ptr *QSortFilterProxyModel) ConnectMapFromSource(f func(sourceIndex *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapFromSource"); signal != nil {
			f := func(sourceIndex *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(sourceIndex)
				return f(sourceIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapFromSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapFromSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectMapFromSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapFromSource")
	}
}

func (ptr *QSortFilterProxyModel) MapFromSource(sourceIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QSortFilterProxyModel_MapFromSource(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QSortFilterProxyModel) MapFromSourceDefault(sourceIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QSortFilterProxyModel_MapFromSourceDefault(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQSortFilterProxyModel_MapToSource
func callbackQSortFilterProxyModel_MapToSource(ptr unsafe.Pointer, proxyIndex unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapToSource"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(proxyIndex)))
	}

	return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).MapToSourceDefault(NewQModelIndexFromPointer(proxyIndex)))
}

func (ptr *QSortFilterProxyModel) ConnectMapToSource(f func(proxyIndex *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapToSource"); signal != nil {
			f := func(proxyIndex *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(proxyIndex)
				return f(proxyIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapToSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapToSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectMapToSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapToSource")
	}
}

func (ptr *QSortFilterProxyModel) MapToSource(proxyIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QSortFilterProxyModel_MapToSource(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QSortFilterProxyModel) MapToSourceDefault(proxyIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QSortFilterProxyModel_MapToSourceDefault(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQSortFilterProxyModel_Parent
func callbackQSortFilterProxyModel_Parent(ptr unsafe.Pointer, child unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(child)))
	}

	return PointerFromQModelIndex(NewQSortFilterProxyModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(child)))
}

func (ptr *QSortFilterProxyModel) ConnectParent(f func(child *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "parent"); signal != nil {
			f := func(child *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(child)
				return f(child)
			}
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectParent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "parent")
	}
}

func (ptr *QSortFilterProxyModel) Parent(child QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QSortFilterProxyModel_Parent(ptr.Pointer(), PointerFromQModelIndex(child)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QSortFilterProxyModel) ParentDefault(child QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QSortFilterProxyModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(child)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQSortFilterProxyModel_RowCount
func callbackQSortFilterProxyModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQSortFilterProxyModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QSortFilterProxyModel) ConnectRowCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectRowCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowCount")
	}
}

func (ptr *QSortFilterProxyModel) RowCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSortFilterProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) RowCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSortFilterProxyModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) SetDynamicSortFilter(enable bool) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetDynamicSortFilter(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterCaseSensitivity(cs Qt__CaseSensitivity) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterCaseSensitivity(ptr.Pointer(), C.longlong(cs))
	}
}

//export callbackQSortFilterProxyModel_SetFilterFixedString
func callbackQSortFilterProxyModel_SetFilterFixedString(ptr unsafe.Pointer, pattern C.struct_QtCore_PackedString) {
	if signal := qt.GetSignal(ptr, "setFilterFixedString"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(pattern))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).SetFilterFixedStringDefault(cGoUnpackString(pattern))
	}
}

func (ptr *QSortFilterProxyModel) ConnectSetFilterFixedString(f func(pattern string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFilterFixedString"); signal != nil {
			f := func(pattern string) {
				(*(*func(string))(signal))(pattern)
				f(pattern)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFilterFixedString", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFilterFixedString", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectSetFilterFixedString() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFilterFixedString")
	}
}

func (ptr *QSortFilterProxyModel) SetFilterFixedString(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QSortFilterProxyModel_SetFilterFixedString(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

func (ptr *QSortFilterProxyModel) SetFilterFixedStringDefault(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QSortFilterProxyModel_SetFilterFixedStringDefault(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

func (ptr *QSortFilterProxyModel) SetFilterKeyColumn(column int) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterKeyColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

//export callbackQSortFilterProxyModel_SetFilterRegExp
func callbackQSortFilterProxyModel_SetFilterRegExp(ptr unsafe.Pointer, regExp unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setFilterRegExp"); signal != nil {
		(*(*func(*QRegExp))(signal))(NewQRegExpFromPointer(regExp))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).SetFilterRegExpDefault(NewQRegExpFromPointer(regExp))
	}
}

func (ptr *QSortFilterProxyModel) ConnectSetFilterRegExp(f func(regExp *QRegExp)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFilterRegExp"); signal != nil {
			f := func(regExp *QRegExp) {
				(*(*func(*QRegExp))(signal))(regExp)
				f(regExp)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFilterRegExp", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFilterRegExp", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectSetFilterRegExp() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFilterRegExp")
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegExp(regExp QRegExp_ITF) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterRegExp(ptr.Pointer(), PointerFromQRegExp(regExp))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegExpDefault(regExp QRegExp_ITF) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterRegExpDefault(ptr.Pointer(), PointerFromQRegExp(regExp))
	}
}

//export callbackQSortFilterProxyModel_SetFilterRegExp2
func callbackQSortFilterProxyModel_SetFilterRegExp2(ptr unsafe.Pointer, pattern C.struct_QtCore_PackedString) {
	if signal := qt.GetSignal(ptr, "setFilterRegExp2"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(pattern))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).SetFilterRegExp2Default(cGoUnpackString(pattern))
	}
}

func (ptr *QSortFilterProxyModel) ConnectSetFilterRegExp2(f func(pattern string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFilterRegExp2"); signal != nil {
			f := func(pattern string) {
				(*(*func(string))(signal))(pattern)
				f(pattern)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFilterRegExp2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFilterRegExp2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectSetFilterRegExp2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFilterRegExp2")
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegExp2(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QSortFilterProxyModel_SetFilterRegExp2(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegExp2Default(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QSortFilterProxyModel_SetFilterRegExp2Default(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

//export callbackQSortFilterProxyModel_SetFilterRegularExpression
func callbackQSortFilterProxyModel_SetFilterRegularExpression(ptr unsafe.Pointer, pattern C.struct_QtCore_PackedString) {
	if signal := qt.GetSignal(ptr, "setFilterRegularExpression"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(pattern))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).SetFilterRegularExpressionDefault(cGoUnpackString(pattern))
	}
}

func (ptr *QSortFilterProxyModel) ConnectSetFilterRegularExpression(f func(pattern string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFilterRegularExpression"); signal != nil {
			f := func(pattern string) {
				(*(*func(string))(signal))(pattern)
				f(pattern)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFilterRegularExpression", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFilterRegularExpression", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectSetFilterRegularExpression() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFilterRegularExpression")
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegularExpression(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QSortFilterProxyModel_SetFilterRegularExpression(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegularExpressionDefault(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QSortFilterProxyModel_SetFilterRegularExpressionDefault(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

//export callbackQSortFilterProxyModel_SetFilterRegularExpression2
func callbackQSortFilterProxyModel_SetFilterRegularExpression2(ptr unsafe.Pointer, regularExpression unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setFilterRegularExpression2"); signal != nil {
		(*(*func(*QRegularExpression))(signal))(NewQRegularExpressionFromPointer(regularExpression))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).SetFilterRegularExpression2Default(NewQRegularExpressionFromPointer(regularExpression))
	}
}

func (ptr *QSortFilterProxyModel) ConnectSetFilterRegularExpression2(f func(regularExpression *QRegularExpression)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFilterRegularExpression2"); signal != nil {
			f := func(regularExpression *QRegularExpression) {
				(*(*func(*QRegularExpression))(signal))(regularExpression)
				f(regularExpression)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFilterRegularExpression2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFilterRegularExpression2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectSetFilterRegularExpression2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFilterRegularExpression2")
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegularExpression2(regularExpression QRegularExpression_ITF) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterRegularExpression2(ptr.Pointer(), PointerFromQRegularExpression(regularExpression))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegularExpression2Default(regularExpression QRegularExpression_ITF) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterRegularExpression2Default(ptr.Pointer(), PointerFromQRegularExpression(regularExpression))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRole(role int) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterRole(ptr.Pointer(), C.int(int32(role)))
	}
}

//export callbackQSortFilterProxyModel_SetFilterWildcard
func callbackQSortFilterProxyModel_SetFilterWildcard(ptr unsafe.Pointer, pattern C.struct_QtCore_PackedString) {
	if signal := qt.GetSignal(ptr, "setFilterWildcard"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(pattern))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).SetFilterWildcardDefault(cGoUnpackString(pattern))
	}
}

func (ptr *QSortFilterProxyModel) ConnectSetFilterWildcard(f func(pattern string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFilterWildcard"); signal != nil {
			f := func(pattern string) {
				(*(*func(string))(signal))(pattern)
				f(pattern)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFilterWildcard", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFilterWildcard", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectSetFilterWildcard() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFilterWildcard")
	}
}

func (ptr *QSortFilterProxyModel) SetFilterWildcard(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QSortFilterProxyModel_SetFilterWildcard(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

func (ptr *QSortFilterProxyModel) SetFilterWildcardDefault(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QSortFilterProxyModel_SetFilterWildcardDefault(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

func (ptr *QSortFilterProxyModel) SetRecursiveFilteringEnabled(recursive bool) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetRecursiveFilteringEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(recursive))))
	}
}

func (ptr *QSortFilterProxyModel) SetSortCaseSensitivity(cs Qt__CaseSensitivity) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetSortCaseSensitivity(ptr.Pointer(), C.longlong(cs))
	}
}

func (ptr *QSortFilterProxyModel) SetSortLocaleAware(on bool) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetSortLocaleAware(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QSortFilterProxyModel) SetSortRole(role int) {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetSortRole(ptr.Pointer(), C.int(int32(role)))
	}
}

func (ptr *QSortFilterProxyModel) SortCaseSensitivity() Qt__CaseSensitivity {
	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QSortFilterProxyModel_SortCaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) SortColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSortFilterProxyModel_SortColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) SortOrder() Qt__SortOrder {
	if ptr.Pointer() != nil {
		return Qt__SortOrder(C.QSortFilterProxyModel_SortOrder(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) SortRole() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSortFilterProxyModel_SortRole(ptr.Pointer())))
	}
	return 0
}

//export callbackQSortFilterProxyModel_DestroyQSortFilterProxyModel
func callbackQSortFilterProxyModel_DestroyQSortFilterProxyModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSortFilterProxyModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).DestroyQSortFilterProxyModelDefault()
	}
}

func (ptr *QSortFilterProxyModel) ConnectDestroyQSortFilterProxyModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSortFilterProxyModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSortFilterProxyModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSortFilterProxyModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSortFilterProxyModel) DisconnectDestroyQSortFilterProxyModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSortFilterProxyModel")
	}
}

func (ptr *QSortFilterProxyModel) DestroyQSortFilterProxyModel() {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_DestroyQSortFilterProxyModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSortFilterProxyModel) DestroyQSortFilterProxyModelDefault() {
	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_DestroyQSortFilterProxyModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSpecialInteger struct {
	ptr unsafe.Pointer
}

type QSpecialInteger_ITF interface {
	QSpecialInteger_PTR() *QSpecialInteger
}

func (ptr *QSpecialInteger) QSpecialInteger_PTR() *QSpecialInteger {
	return ptr
}

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

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

func PointerFromQSpecialInteger(ptr QSpecialInteger_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSpecialInteger_PTR().Pointer()
	}
	return nil
}

func NewQSpecialIntegerFromPointer(ptr unsafe.Pointer) (n *QSpecialInteger) {
	n = new(QSpecialInteger)
	n.SetPointer(ptr)
	return
}

func (ptr *QSpecialInteger) DestroyQSpecialInteger() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QStack struct {
	QVector
}

type QStack_ITF interface {
	QVector_ITF
	QStack_PTR() *QStack
}

func (ptr *QStack) QStack_PTR() *QStack {
	return ptr
}

func (ptr *QStack) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QVector_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQStack(ptr QStack_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStack_PTR().Pointer()
	}
	return nil
}

func NewQStackFromPointer(ptr unsafe.Pointer) (n *QStack) {
	n = new(QStack)
	n.SetPointer(ptr)
	return
}

func (ptr *QStack) DestroyQStack() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QStandardPaths struct {
	ptr unsafe.Pointer
}

type QStandardPaths_ITF interface {
	QStandardPaths_PTR() *QStandardPaths
}

func (ptr *QStandardPaths) QStandardPaths_PTR() *QStandardPaths {
	return ptr
}

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

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

func PointerFromQStandardPaths(ptr QStandardPaths_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStandardPaths_PTR().Pointer()
	}
	return nil
}

func NewQStandardPathsFromPointer(ptr unsafe.Pointer) (n *QStandardPaths) {
	n = new(QStandardPaths)
	n.SetPointer(ptr)
	return
}

func (ptr *QStandardPaths) DestroyQStandardPaths() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStandardPaths__StandardLocation
//QStandardPaths::StandardLocation
type QStandardPaths__StandardLocation int64

const (
	QStandardPaths__DesktopLocation       QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(0)
	QStandardPaths__DocumentsLocation     QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(1)
	QStandardPaths__FontsLocation         QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(2)
	QStandardPaths__ApplicationsLocation  QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(3)
	QStandardPaths__MusicLocation         QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(4)
	QStandardPaths__MoviesLocation        QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(5)
	QStandardPaths__PicturesLocation      QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(6)
	QStandardPaths__TempLocation          QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(7)
	QStandardPaths__HomeLocation          QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(8)
	QStandardPaths__DataLocation          QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(9)
	QStandardPaths__CacheLocation         QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(10)
	QStandardPaths__GenericDataLocation   QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(11)
	QStandardPaths__RuntimeLocation       QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(12)
	QStandardPaths__ConfigLocation        QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(13)
	QStandardPaths__DownloadLocation      QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(14)
	QStandardPaths__GenericCacheLocation  QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(15)
	QStandardPaths__GenericConfigLocation QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(16)
	QStandardPaths__AppDataLocation       QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(17)
	QStandardPaths__AppConfigLocation     QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(18)
	QStandardPaths__AppLocalDataLocation  QStandardPaths__StandardLocation = QStandardPaths__StandardLocation(QStandardPaths__DataLocation)
)

//go:generate stringer -type=QStandardPaths__LocateOption
//QStandardPaths::LocateOption
type QStandardPaths__LocateOption int64

const (
	QStandardPaths__LocateFile      QStandardPaths__LocateOption = QStandardPaths__LocateOption(0x0)
	QStandardPaths__LocateDirectory QStandardPaths__LocateOption = QStandardPaths__LocateOption(0x1)
)

func QStandardPaths_DisplayName(ty QStandardPaths__StandardLocation) string {
	return cGoUnpackString(C.QStandardPaths_QStandardPaths_DisplayName(C.longlong(ty)))
}

func (ptr *QStandardPaths) DisplayName(ty QStandardPaths__StandardLocation) string {
	return cGoUnpackString(C.QStandardPaths_QStandardPaths_DisplayName(C.longlong(ty)))
}

func QStandardPaths_FindExecutable(executableName string, paths []string) string {
	var executableNameC *C.char
	if executableName != "" {
		executableNameC = C.CString(executableName)
		defer C.free(unsafe.Pointer(executableNameC))
	}
	pathsC := C.CString(strings.Join(paths, "¡¦!"))
	defer C.free(unsafe.Pointer(pathsC))
	return cGoUnpackString(C.QStandardPaths_QStandardPaths_FindExecutable(C.struct_QtCore_PackedString{data: executableNameC, len: C.longlong(len(executableName))}, C.struct_QtCore_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "¡¦!")))}))
}

func (ptr *QStandardPaths) FindExecutable(executableName string, paths []string) string {
	var executableNameC *C.char
	if executableName != "" {
		executableNameC = C.CString(executableName)
		defer C.free(unsafe.Pointer(executableNameC))
	}
	pathsC := C.CString(strings.Join(paths, "¡¦!"))
	defer C.free(unsafe.Pointer(pathsC))
	return cGoUnpackString(C.QStandardPaths_QStandardPaths_FindExecutable(C.struct_QtCore_PackedString{data: executableNameC, len: C.longlong(len(executableName))}, C.struct_QtCore_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "¡¦!")))}))
}

func QStandardPaths_Locate(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) string {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return cGoUnpackString(C.QStandardPaths_QStandardPaths_Locate(C.longlong(ty), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(options)))
}

func (ptr *QStandardPaths) Locate(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) string {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return cGoUnpackString(C.QStandardPaths_QStandardPaths_Locate(C.longlong(ty), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(options)))
}

func QStandardPaths_LocateAll(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) []string {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return unpackStringList(cGoUnpackString(C.QStandardPaths_QStandardPaths_LocateAll(C.longlong(ty), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(options))))
}

func (ptr *QStandardPaths) LocateAll(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) []string {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	return unpackStringList(cGoUnpackString(C.QStandardPaths_QStandardPaths_LocateAll(C.longlong(ty), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(options))))
}

func QStandardPaths_SetTestModeEnabled(testMode bool) {
	C.QStandardPaths_QStandardPaths_SetTestModeEnabled(C.char(int8(qt.GoBoolToInt(testMode))))
}

func (ptr *QStandardPaths) SetTestModeEnabled(testMode bool) {
	C.QStandardPaths_QStandardPaths_SetTestModeEnabled(C.char(int8(qt.GoBoolToInt(testMode))))
}

func QStandardPaths_StandardLocations(ty QStandardPaths__StandardLocation) []string {
	return unpackStringList(cGoUnpackString(C.QStandardPaths_QStandardPaths_StandardLocations(C.longlong(ty))))
}

func (ptr *QStandardPaths) StandardLocations(ty QStandardPaths__StandardLocation) []string {
	return unpackStringList(cGoUnpackString(C.QStandardPaths_QStandardPaths_StandardLocations(C.longlong(ty))))
}

func QStandardPaths_WritableLocation(ty QStandardPaths__StandardLocation) string {
	return cGoUnpackString(C.QStandardPaths_QStandardPaths_WritableLocation(C.longlong(ty)))
}

func (ptr *QStandardPaths) WritableLocation(ty QStandardPaths__StandardLocation) string {
	return cGoUnpackString(C.QStandardPaths_QStandardPaths_WritableLocation(C.longlong(ty)))
}

type QState struct {
	QAbstractState
}

type QState_ITF interface {
	QAbstractState_ITF
	QState_PTR() *QState
}

func (ptr *QState) QState_PTR() *QState {
	return ptr
}

func (ptr *QState) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractState_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQState(ptr QState_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QState_PTR().Pointer()
	}
	return nil
}

func NewQStateFromPointer(ptr unsafe.Pointer) (n *QState) {
	n = new(QState)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QState__ChildMode
//QState::ChildMode
type QState__ChildMode int64

const (
	QState__ExclusiveStates QState__ChildMode = QState__ChildMode(0)
	QState__ParallelStates  QState__ChildMode = QState__ChildMode(1)
)

//go:generate stringer -type=QState__RestorePolicy
//QState::RestorePolicy
type QState__RestorePolicy int64

const (
	QState__DontRestoreProperties QState__RestorePolicy = QState__RestorePolicy(0)
	QState__RestoreProperties     QState__RestorePolicy = QState__RestorePolicy(1)
)

func NewQState(parent QState_ITF) *QState {
	tmpValue := NewQStateFromPointer(C.QState_NewQState(PointerFromQState(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQState2(childMode QState__ChildMode, parent QState_ITF) *QState {
	tmpValue := NewQStateFromPointer(C.QState_NewQState2(C.longlong(childMode), PointerFromQState(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QState) AddTransition(transition QAbstractTransition_ITF) {
	if ptr.Pointer() != nil {
		C.QState_AddTransition(ptr.Pointer(), PointerFromQAbstractTransition(transition))
	}
}

func (ptr *QState) AddTransition2(sender QObject_ITF, sign string, target QAbstractState_ITF) *QSignalTransition {
	if ptr.Pointer() != nil {
		var signC *C.char
		if sign != "" {
			signC = C.CString(sign)
			defer C.free(unsafe.Pointer(signC))
		}
		tmpValue := NewQSignalTransitionFromPointer(C.QState_AddTransition2(ptr.Pointer(), PointerFromQObject(sender), signC, PointerFromQAbstractState(target)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QState) AddTransition4(target QAbstractState_ITF) *QAbstractTransition {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractTransitionFromPointer(C.QState_AddTransition4(ptr.Pointer(), PointerFromQAbstractState(target)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QState) AssignProperty(object QObject_ITF, name string, value QVariant_ITF) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QState_AssignProperty(ptr.Pointer(), PointerFromQObject(object), nameC, PointerFromQVariant(value))
	}
}

func (ptr *QState) ChildMode() QState__ChildMode {
	if ptr.Pointer() != nil {
		return QState__ChildMode(C.QState_ChildMode(ptr.Pointer()))
	}
	return 0
}

//export callbackQState_ChildModeChanged
func callbackQState_ChildModeChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childModeChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QState) ConnectChildModeChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "childModeChanged") {
			C.QState_ConnectChildModeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "childModeChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "childModeChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "childModeChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "childModeChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QState) DisconnectChildModeChanged() {
	if ptr.Pointer() != nil {
		C.QState_DisconnectChildModeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "childModeChanged")
	}
}

func (ptr *QState) ErrorState() *QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractStateFromPointer(C.QState_ErrorState(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQState_ErrorStateChanged
func callbackQState_ErrorStateChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "errorStateChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QState) ConnectErrorStateChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "errorStateChanged") {
			C.QState_ConnectErrorStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "errorStateChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "errorStateChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "errorStateChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "errorStateChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QState) DisconnectErrorStateChanged() {
	if ptr.Pointer() != nil {
		C.QState_DisconnectErrorStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "errorStateChanged")
	}
}

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

}

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

		if !qt.ExistsSignal(ptr.Pointer(), "finished") {
			C.QState_ConnectFinished(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "finished")))
		}

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

func (ptr *QState) DisconnectFinished() {
	if ptr.Pointer() != nil {
		C.QState_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "finished")
	}
}

func (ptr *QState) InitialState() *QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractStateFromPointer(C.QState_InitialState(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQState_InitialStateChanged
func callbackQState_InitialStateChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "initialStateChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QState) ConnectInitialStateChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "initialStateChanged") {
			C.QState_ConnectInitialStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "initialStateChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "initialStateChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "initialStateChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "initialStateChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QState) DisconnectInitialStateChanged() {
	if ptr.Pointer() != nil {
		C.QState_DisconnectInitialStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "initialStateChanged")
	}
}

//export callbackQState_OnEntry
func callbackQState_OnEntry(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onEntry"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	} else {
		NewQStateFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QState) ConnectOnEntry(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onEntry"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onEntry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onEntry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QState) DisconnectOnEntry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onEntry")
	}
}

func (ptr *QState) OnEntry(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QState) OnEntryDefault(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QState_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

//export callbackQState_OnExit
func callbackQState_OnExit(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onExit"); signal != nil {
		(*(*func(*QEvent))(signal))(NewQEventFromPointer(event))
	} else {
		NewQStateFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QState) ConnectOnExit(f func(event *QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "onExit"); signal != nil {
			f := func(event *QEvent) {
				(*(*func(*QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "onExit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "onExit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QState) DisconnectOnExit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "onExit")
	}
}

func (ptr *QState) OnExit(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QState) OnExitDefault(event QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QState_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

//export callbackQState_PropertiesAssigned
func callbackQState_PropertiesAssigned(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "propertiesAssigned"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QState) ConnectPropertiesAssigned(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "propertiesAssigned") {
			C.QState_ConnectPropertiesAssigned(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "propertiesAssigned")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "propertiesAssigned"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "propertiesAssigned", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "propertiesAssigned", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QState) DisconnectPropertiesAssigned() {
	if ptr.Pointer() != nil {
		C.QState_DisconnectPropertiesAssigned(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "propertiesAssigned")
	}
}

func (ptr *QState) RemoveTransition(transition QAbstractTransition_ITF) {
	if ptr.Pointer() != nil {
		C.QState_RemoveTransition(ptr.Pointer(), PointerFromQAbstractTransition(transition))
	}
}

func (ptr *QState) SetChildMode(mode QState__ChildMode) {
	if ptr.Pointer() != nil {
		C.QState_SetChildMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QState) SetErrorState(state QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QState_SetErrorState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

func (ptr *QState) SetInitialState(state QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QState_SetInitialState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

func (ptr *QState) Transitions() []*QAbstractTransition {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QAbstractTransition {
			out := make([]*QAbstractTransition, int(l.len))
			tmpList := NewQStateFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__transitions_atList(i)
			}
			return out
		}(C.QState_Transitions(ptr.Pointer()))
	}
	return make([]*QAbstractTransition, 0)
}

//export callbackQState_DestroyQState
func callbackQState_DestroyQState(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QState"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStateFromPointer(ptr).DestroyQStateDefault()
	}
}

func (ptr *QState) ConnectDestroyQState(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QState"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QState", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QState", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QState) DisconnectDestroyQState() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QState")
	}
}

func (ptr *QState) DestroyQState() {
	if ptr.Pointer() != nil {
		C.QState_DestroyQState(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QState) DestroyQStateDefault() {
	if ptr.Pointer() != nil {
		C.QState_DestroyQStateDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QState) __transitions_atList(i int) *QAbstractTransition {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractTransitionFromPointer(C.QState___transitions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QState) __transitions_setList(i QAbstractTransition_ITF) {
	if ptr.Pointer() != nil {
		C.QState___transitions_setList(ptr.Pointer(), PointerFromQAbstractTransition(i))
	}
}

func (ptr *QState) __transitions_newList() unsafe.Pointer {
	return C.QState___transitions_newList(ptr.Pointer())
}

type QStateMachine struct {
	QState
}

type QStateMachine_ITF interface {
	QState_ITF
	QStateMachine_PTR() *QStateMachine
}

func (ptr *QStateMachine) QStateMachine_PTR() *QStateMachine {
	return ptr
}

func (ptr *QStateMachine) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QState_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQStateMachine(ptr QStateMachine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStateMachine_PTR().Pointer()
	}
	return nil
}

func NewQStateMachineFromPointer(ptr unsafe.Pointer) (n *QStateMachine) {
	n = new(QStateMachine)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QStateMachine__EventPriority
//QStateMachine::EventPriority
type QStateMachine__EventPriority int64

const (
	QStateMachine__NormalPriority QStateMachine__EventPriority = QStateMachine__EventPriority(0)
	QStateMachine__HighPriority   QStateMachine__EventPriority = QStateMachine__EventPriority(1)
)

//go:generate stringer -type=QStateMachine__Error
//QStateMachine::Error
type QStateMachine__Error int64

const (
	QStateMachine__NoError                            QStateMachine__Error = QStateMachine__Error(0)
	QStateMachine__NoInitialStateError                QStateMachine__Error = QStateMachine__Error(1)
	QStateMachine__NoDefaultStateInHistoryStateError  QStateMachine__Error = QStateMachine__Error(2)
	QStateMachine__NoCommonAncestorForTransitionError QStateMachine__Error = QStateMachine__Error(3)
)

func NewQStateMachine(parent QObject_ITF) *QStateMachine {
	tmpValue := NewQStateMachineFromPointer(C.QStateMachine_NewQStateMachine(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQStateMachine2(childMode QState__ChildMode, parent QObject_ITF) *QStateMachine {
	tmpValue := NewQStateMachineFromPointer(C.QStateMachine_NewQStateMachine2(C.longlong(childMode), PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QStateMachine) AddDefaultAnimation(animation QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QStateMachine_AddDefaultAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QStateMachine) AddState(state QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QStateMachine_AddState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

func (ptr *QStateMachine) CancelDelayedEvent(id int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStateMachine_CancelDelayedEvent(ptr.Pointer(), C.int(int32(id)))) != 0
	}
	return false
}

func (ptr *QStateMachine) ClearError() {
	if ptr.Pointer() != nil {
		C.QStateMachine_ClearError(ptr.Pointer())
	}
}

func (ptr *QStateMachine) DefaultAnimations() []*QAbstractAnimation {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QAbstractAnimation {
			out := make([]*QAbstractAnimation, int(l.len))
			tmpList := NewQStateMachineFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__defaultAnimations_atList(i)
			}
			return out
		}(C.QStateMachine_DefaultAnimations(ptr.Pointer()))
	}
	return make([]*QAbstractAnimation, 0)
}

func (ptr *QStateMachine) Error() QStateMachine__Error {
	if ptr.Pointer() != nil {
		return QStateMachine__Error(C.QStateMachine_Error(ptr.Pointer()))
	}
	return 0
}

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

func (ptr *QStateMachine) GlobalRestorePolicy() QState__RestorePolicy {
	if ptr.Pointer() != nil {
		return QState__RestorePolicy(C.QStateMachine_GlobalRestorePolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStateMachine) IsAnimated() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStateMachine_IsAnimated(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStateMachine) IsRunning() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStateMachine_IsRunning(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStateMachine) PostDelayedEvent(event QEvent_ITF, delay int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStateMachine_PostDelayedEvent(ptr.Pointer(), PointerFromQEvent(event), C.int(int32(delay)))))
	}
	return 0
}

func (ptr *QStateMachine) PostEvent(event QEvent_ITF, priority QStateMachine__EventPriority) {
	if ptr.Pointer() != nil {
		C.QStateMachine_PostEvent(ptr.Pointer(), PointerFromQEvent(event), C.longlong(priority))
	}
}

func (ptr *QStateMachine) RemoveDefaultAnimation(animation QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QStateMachine_RemoveDefaultAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QStateMachine) RemoveState(state QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QStateMachine_RemoveState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

//export callbackQStateMachine_RunningChanged
func callbackQStateMachine_RunningChanged(ptr unsafe.Pointer, running C.char) {
	if signal := qt.GetSignal(ptr, "runningChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(running) != 0)
	}

}

func (ptr *QStateMachine) ConnectRunningChanged(f func(running bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "runningChanged") {
			C.QStateMachine_ConnectRunningChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "runningChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "runningChanged"); signal != nil {
			f := func(running bool) {
				(*(*func(bool))(signal))(running)
				f(running)
			}
			qt.ConnectSignal(ptr.Pointer(), "runningChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "runningChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStateMachine) DisconnectRunningChanged() {
	if ptr.Pointer() != nil {
		C.QStateMachine_DisconnectRunningChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "runningChanged")
	}
}

func (ptr *QStateMachine) RunningChanged(running bool) {
	if ptr.Pointer() != nil {
		C.QStateMachine_RunningChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(running))))
	}
}

func (ptr *QStateMachine) SetAnimated(enabled bool) {
	if ptr.Pointer() != nil {
		C.QStateMachine_SetAnimated(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QStateMachine) SetGlobalRestorePolicy(restorePolicy QState__RestorePolicy) {
	if ptr.Pointer() != nil {
		C.QStateMachine_SetGlobalRestorePolicy(ptr.Pointer(), C.longlong(restorePolicy))
	}
}

//export callbackQStateMachine_SetRunning
func callbackQStateMachine_SetRunning(ptr unsafe.Pointer, running C.char) {
	if signal := qt.GetSignal(ptr, "setRunning"); signal != nil {
		(*(*func(bool))(signal))(int8(running) != 0)
	} else {
		NewQStateMachineFromPointer(ptr).SetRunningDefault(int8(running) != 0)
	}
}

func (ptr *QStateMachine) ConnectSetRunning(f func(running bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setRunning"); signal != nil {
			f := func(running bool) {
				(*(*func(bool))(signal))(running)
				f(running)
			}
			qt.ConnectSignal(ptr.Pointer(), "setRunning", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setRunning", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStateMachine) DisconnectSetRunning() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setRunning")
	}
}

func (ptr *QStateMachine) SetRunning(running bool) {
	if ptr.Pointer() != nil {
		C.QStateMachine_SetRunning(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(running))))
	}
}

func (ptr *QStateMachine) SetRunningDefault(running bool) {
	if ptr.Pointer() != nil {
		C.QStateMachine_SetRunningDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(running))))
	}
}

//export callbackQStateMachine_Start
func callbackQStateMachine_Start(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "start"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStateMachineFromPointer(ptr).StartDefault()
	}
}

func (ptr *QStateMachine) ConnectStart(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStateMachine) DisconnectStart() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "start")
	}
}

func (ptr *QStateMachine) Start() {
	if ptr.Pointer() != nil {
		C.QStateMachine_Start(ptr.Pointer())
	}
}

func (ptr *QStateMachine) StartDefault() {
	if ptr.Pointer() != nil {
		C.QStateMachine_StartDefault(ptr.Pointer())
	}
}

//export callbackQStateMachine_Started
func callbackQStateMachine_Started(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "started"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QStateMachine) ConnectStarted(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "started") {
			C.QStateMachine_ConnectStarted(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "started")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "started"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "started", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "started", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStateMachine) DisconnectStarted() {
	if ptr.Pointer() != nil {
		C.QStateMachine_DisconnectStarted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "started")
	}
}

//export callbackQStateMachine_Stop
func callbackQStateMachine_Stop(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "stop"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStateMachineFromPointer(ptr).StopDefault()
	}
}

func (ptr *QStateMachine) ConnectStop(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStateMachine) DisconnectStop() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "stop")
	}
}

func (ptr *QStateMachine) Stop() {
	if ptr.Pointer() != nil {
		C.QStateMachine_Stop(ptr.Pointer())
	}
}

func (ptr *QStateMachine) StopDefault() {
	if ptr.Pointer() != nil {
		C.QStateMachine_StopDefault(ptr.Pointer())
	}
}

//export callbackQStateMachine_Stopped
func callbackQStateMachine_Stopped(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "stopped"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QStateMachine) ConnectStopped(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "stopped") {
			C.QStateMachine_ConnectStopped(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stopped")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "stopped"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "stopped", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "stopped", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStateMachine) DisconnectStopped() {
	if ptr.Pointer() != nil {
		C.QStateMachine_DisconnectStopped(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "stopped")
	}
}

//export callbackQStateMachine_DestroyQStateMachine
func callbackQStateMachine_DestroyQStateMachine(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QStateMachine"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStateMachineFromPointer(ptr).DestroyQStateMachineDefault()
	}
}

func (ptr *QStateMachine) ConnectDestroyQStateMachine(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QStateMachine"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QStateMachine", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QStateMachine", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStateMachine) DisconnectDestroyQStateMachine() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QStateMachine")
	}
}

func (ptr *QStateMachine) DestroyQStateMachine() {
	if ptr.Pointer() != nil {
		C.QStateMachine_DestroyQStateMachine(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStateMachine) DestroyQStateMachineDefault() {
	if ptr.Pointer() != nil {
		C.QStateMachine_DestroyQStateMachineDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStateMachine) __defaultAnimations_atList(i int) *QAbstractAnimation {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractAnimationFromPointer(C.QStateMachine___defaultAnimations_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStateMachine) __defaultAnimations_setList(i QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QStateMachine___defaultAnimations_setList(ptr.Pointer(), PointerFromQAbstractAnimation(i))
	}
}

func (ptr *QStateMachine) __defaultAnimations_newList() unsafe.Pointer {
	return C.QStateMachine___defaultAnimations_newList(ptr.Pointer())
}

type QStaticByteArrayData struct {
	ptr unsafe.Pointer
}

type QStaticByteArrayData_ITF interface {
	QStaticByteArrayData_PTR() *QStaticByteArrayData
}

func (ptr *QStaticByteArrayData) QStaticByteArrayData_PTR() *QStaticByteArrayData {
	return ptr
}

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

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

func PointerFromQStaticByteArrayData(ptr QStaticByteArrayData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStaticByteArrayData_PTR().Pointer()
	}
	return nil
}

func NewQStaticByteArrayDataFromPointer(ptr unsafe.Pointer) (n *QStaticByteArrayData) {
	n = new(QStaticByteArrayData)
	n.SetPointer(ptr)
	return
}

func (ptr *QStaticByteArrayData) DestroyQStaticByteArrayData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QStaticByteArrayMatcher struct {
	ptr unsafe.Pointer
}

type QStaticByteArrayMatcher_ITF interface {
	QStaticByteArrayMatcher_PTR() *QStaticByteArrayMatcher
}

func (ptr *QStaticByteArrayMatcher) QStaticByteArrayMatcher_PTR() *QStaticByteArrayMatcher {
	return ptr
}

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

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

func PointerFromQStaticByteArrayMatcher(ptr QStaticByteArrayMatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStaticByteArrayMatcher_PTR().Pointer()
	}
	return nil
}

func NewQStaticByteArrayMatcherFromPointer(ptr unsafe.Pointer) (n *QStaticByteArrayMatcher) {
	n = new(QStaticByteArrayMatcher)
	n.SetPointer(ptr)
	return
}

func (ptr *QStaticByteArrayMatcher) DestroyQStaticByteArrayMatcher() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QStaticPlugin struct {
	ptr unsafe.Pointer
}

type QStaticPlugin_ITF interface {
	QStaticPlugin_PTR() *QStaticPlugin
}

func (ptr *QStaticPlugin) QStaticPlugin_PTR() *QStaticPlugin {
	return ptr
}

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

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

func PointerFromQStaticPlugin(ptr QStaticPlugin_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStaticPlugin_PTR().Pointer()
	}
	return nil
}

func NewQStaticPluginFromPointer(ptr unsafe.Pointer) (n *QStaticPlugin) {
	n = new(QStaticPlugin)
	n.SetPointer(ptr)
	return
}

func (ptr *QStaticPlugin) DestroyQStaticPlugin() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStaticPlugin) Instance() *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QStaticPlugin_Instance(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStaticPlugin) MetaData() *QJsonObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonObjectFromPointer(C.QStaticPlugin_MetaData(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
		return tmpValue
	}
	return nil
}

func (ptr *QStaticPlugin) RawMetaData() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStaticPlugin_RawMetaData(ptr.Pointer()))
	}
	return ""
}

type QStaticStringData struct {
	ptr unsafe.Pointer
}

type QStaticStringData_ITF interface {
	QStaticStringData_PTR() *QStaticStringData
}

func (ptr *QStaticStringData) QStaticStringData_PTR() *QStaticStringData {
	return ptr
}

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

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

func PointerFromQStaticStringData(ptr QStaticStringData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStaticStringData_PTR().Pointer()
	}
	return nil
}

func NewQStaticStringDataFromPointer(ptr unsafe.Pointer) (n *QStaticStringData) {
	n = new(QStaticStringData)
	n.SetPointer(ptr)
	return
}

func (ptr *QStaticStringData) DestroyQStaticStringData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QStorageInfo struct {
	ptr unsafe.Pointer
}

type QStorageInfo_ITF interface {
	QStorageInfo_PTR() *QStorageInfo
}

func (ptr *QStorageInfo) QStorageInfo_PTR() *QStorageInfo {
	return ptr
}

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

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

func PointerFromQStorageInfo(ptr QStorageInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStorageInfo_PTR().Pointer()
	}
	return nil
}

func NewQStorageInfoFromPointer(ptr unsafe.Pointer) (n *QStorageInfo) {
	n = new(QStorageInfo)
	n.SetPointer(ptr)
	return
}
func NewQStorageInfo() *QStorageInfo {
	tmpValue := NewQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo())
	runtime.SetFinalizer(tmpValue, (*QStorageInfo).DestroyQStorageInfo)
	return tmpValue
}

func NewQStorageInfo2(path string) *QStorageInfo {
	var pathC *C.char
	if path != "" {
		pathC = C.CString(path)
		defer C.free(unsafe.Pointer(pathC))
	}
	tmpValue := NewQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo2(C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))}))
	runtime.SetFinalizer(tmpValue, (*QStorageInfo).DestroyQStorageInfo)
	return tmpValue
}

func NewQStorageInfo3(dir QDir_ITF) *QStorageInfo {
	tmpValue := NewQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo3(PointerFromQDir(dir)))
	runtime.SetFinalizer(tmpValue, (*QStorageInfo).DestroyQStorageInfo)
	return tmpValue
}

func NewQStorageInfo4(other QStorageInfo_ITF) *QStorageInfo {
	tmpValue := NewQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo4(PointerFromQStorageInfo(other)))
	runtime.SetFinalizer(tmpValue, (*QStorageInfo).DestroyQStorageInfo)
	return tmpValue
}

func (ptr *QStorageInfo) BlockSize() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStorageInfo_BlockSize(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStorageInfo) BytesAvailable() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QStorageInfo_BytesAvailable(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStorageInfo) BytesFree() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QStorageInfo_BytesFree(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStorageInfo) BytesTotal() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QStorageInfo_BytesTotal(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStorageInfo) Device() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QStorageInfo_Device(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStorageInfo) DisplayName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStorageInfo_DisplayName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStorageInfo) FileSystemType() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QStorageInfo_FileSystemType(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStorageInfo) IsReadOnly() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStorageInfo_IsReadOnly(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStorageInfo) IsReady() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStorageInfo_IsReady(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStorageInfo) IsRoot() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStorageInfo_IsRoot(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStorageInfo) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStorageInfo_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func QStorageInfo_MountedVolumes() []*QStorageInfo {
	return func(l C.struct_QtCore_PackedList) []*QStorageInfo {
		out := make([]*QStorageInfo, int(l.len))
		tmpList := NewQStorageInfoFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__mountedVolumes_atList(i)
		}
		return out
	}(C.QStorageInfo_QStorageInfo_MountedVolumes())
}

func (ptr *QStorageInfo) MountedVolumes() []*QStorageInfo {
	return func(l C.struct_QtCore_PackedList) []*QStorageInfo {
		out := make([]*QStorageInfo, int(l.len))
		tmpList := NewQStorageInfoFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__mountedVolumes_atList(i)
		}
		return out
	}(C.QStorageInfo_QStorageInfo_MountedVolumes())
}

func (ptr *QStorageInfo) Name() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStorageInfo_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStorageInfo) Refresh() {
	if ptr.Pointer() != nil {
		C.QStorageInfo_Refresh(ptr.Pointer())
	}
}

func QStorageInfo_Root() *QStorageInfo {
	tmpValue := NewQStorageInfoFromPointer(C.QStorageInfo_QStorageInfo_Root())
	runtime.SetFinalizer(tmpValue, (*QStorageInfo).DestroyQStorageInfo)
	return tmpValue
}

func (ptr *QStorageInfo) Root() *QStorageInfo {
	tmpValue := NewQStorageInfoFromPointer(C.QStorageInfo_QStorageInfo_Root())
	runtime.SetFinalizer(tmpValue, (*QStorageInfo).DestroyQStorageInfo)
	return tmpValue
}

func (ptr *QStorageInfo) RootPath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStorageInfo_RootPath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStorageInfo) SetPath(path string) {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		C.QStorageInfo_SetPath(ptr.Pointer(), C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))})
	}
}

func (ptr *QStorageInfo) Subvolume() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QStorageInfo_Subvolume(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStorageInfo) Swap(other QStorageInfo_ITF) {
	if ptr.Pointer() != nil {
		C.QStorageInfo_Swap(ptr.Pointer(), PointerFromQStorageInfo(other))
	}
}

func (ptr *QStorageInfo) DestroyQStorageInfo() {
	if ptr.Pointer() != nil {
		C.QStorageInfo_DestroyQStorageInfo(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStorageInfo) __mountedVolumes_atList(i int) *QStorageInfo {
	if ptr.Pointer() != nil {
		tmpValue := NewQStorageInfoFromPointer(C.QStorageInfo___mountedVolumes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QStorageInfo).DestroyQStorageInfo)
		return tmpValue
	}
	return nil
}

func (ptr *QStorageInfo) __mountedVolumes_setList(i QStorageInfo_ITF) {
	if ptr.Pointer() != nil {
		C.QStorageInfo___mountedVolumes_setList(ptr.Pointer(), PointerFromQStorageInfo(i))
	}
}

func (ptr *QStorageInfo) __mountedVolumes_newList() unsafe.Pointer {
	return C.QStorageInfo___mountedVolumes_newList(ptr.Pointer())
}

type QString struct {
	ptr unsafe.Pointer
}

type QString_ITF interface {
	QString_PTR() *QString
}

func (ptr *QString) QString_PTR() *QString {
	return ptr
}

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

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

func PointerFromQString(ptr QString_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QString_PTR().Pointer()
	}
	return nil
}

func NewQStringFromPointer(ptr unsafe.Pointer) (n *QString) {
	n = new(QString)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QString__SectionFlag
//QString::SectionFlag
type QString__SectionFlag int64

const (
	QString__SectionDefault             QString__SectionFlag = QString__SectionFlag(0x00)
	QString__SectionSkipEmpty           QString__SectionFlag = QString__SectionFlag(0x01)
	QString__SectionIncludeLeadingSep   QString__SectionFlag = QString__SectionFlag(0x02)
	QString__SectionIncludeTrailingSep  QString__SectionFlag = QString__SectionFlag(0x04)
	QString__SectionCaseInsensitiveSeps QString__SectionFlag = QString__SectionFlag(0x08)
)

//go:generate stringer -type=QString__SplitBehavior
//QString::SplitBehavior
type QString__SplitBehavior int64

const (
	QString__KeepEmptyParts QString__SplitBehavior = QString__SplitBehavior(0)
	QString__SkipEmptyParts QString__SplitBehavior = QString__SplitBehavior(1)
)

//go:generate stringer -type=QString__NormalizationForm
//QString::NormalizationForm
type QString__NormalizationForm int64

const (
	QString__NormalizationForm_D  QString__NormalizationForm = QString__NormalizationForm(0)
	QString__NormalizationForm_C  QString__NormalizationForm = QString__NormalizationForm(1)
	QString__NormalizationForm_KD QString__NormalizationForm = QString__NormalizationForm(2)
	QString__NormalizationForm_KC QString__NormalizationForm = QString__NormalizationForm(3)
)

type QStringBuilderCommon struct {
	ptr unsafe.Pointer
}

type QStringBuilderCommon_ITF interface {
	QStringBuilderCommon_PTR() *QStringBuilderCommon
}

func (ptr *QStringBuilderCommon) QStringBuilderCommon_PTR() *QStringBuilderCommon {
	return ptr
}

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

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

func PointerFromQStringBuilderCommon(ptr QStringBuilderCommon_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringBuilderCommon_PTR().Pointer()
	}
	return nil
}

func NewQStringBuilderCommonFromPointer(ptr unsafe.Pointer) (n *QStringBuilderCommon) {
	n = new(QStringBuilderCommon)
	n.SetPointer(ptr)
	return
}

func (ptr *QStringBuilderCommon) DestroyQStringBuilderCommon() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QStringList struct {
	ptr unsafe.Pointer
}

type QStringList_ITF interface {
	QStringList_PTR() *QStringList
}

func (ptr *QStringList) QStringList_PTR() *QStringList {
	return ptr
}

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

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

func PointerFromQStringList(ptr QStringList_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringList_PTR().Pointer()
	}
	return nil
}

func NewQStringListFromPointer(ptr unsafe.Pointer) (n *QStringList) {
	n = new(QStringList)
	n.SetPointer(ptr)
	return
}

func (ptr *QStringList) DestroyQStringList() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QStringListModel struct {
	QAbstractListModel
}

type QStringListModel_ITF interface {
	QAbstractListModel_ITF
	QStringListModel_PTR() *QStringListModel
}

func (ptr *QStringListModel) QStringListModel_PTR() *QStringListModel {
	return ptr
}

func (ptr *QStringListModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractListModel_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQStringListModel(ptr QStringListModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringListModel_PTR().Pointer()
	}
	return nil
}

func NewQStringListModelFromPointer(ptr unsafe.Pointer) (n *QStringListModel) {
	n = new(QStringListModel)
	n.SetPointer(ptr)
	return
}
func NewQStringListModel(parent QObject_ITF) *QStringListModel {
	tmpValue := NewQStringListModelFromPointer(C.QStringListModel_NewQStringListModel(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQStringListModel2(strin []string, parent QObject_ITF) *QStringListModel {
	strinC := C.CString(strings.Join(strin, "¡¦!"))
	defer C.free(unsafe.Pointer(strinC))
	tmpValue := NewQStringListModelFromPointer(C.QStringListModel_NewQStringListModel2(C.struct_QtCore_PackedString{data: strinC, len: C.longlong(len(strings.Join(strin, "¡¦!")))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQStringListModel_Data
func callbackQStringListModel_Data(ptr unsafe.Pointer, index unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return PointerFromQVariant((*(*func(*QModelIndex, int) *QVariant)(signal))(NewQModelIndexFromPointer(index), int(int32(role))))
	}

	return PointerFromQVariant(NewQStringListModelFromPointer(ptr).DataDefault(NewQModelIndexFromPointer(index), int(int32(role))))
}

func (ptr *QStringListModel) ConnectData(f func(index *QModelIndex, role int) *QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "data"); signal != nil {
			f := func(index *QModelIndex, role int) *QVariant {
				(*(*func(*QModelIndex, int) *QVariant)(signal))(index, role)
				return f(index, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStringListModel) DisconnectData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "data")
	}
}

func (ptr *QStringListModel) Data(index QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QStringListModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QStringListModel) DataDefault(index QModelIndex_ITF, role int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QStringListModel_DataDefault(ptr.Pointer(), PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQStringListModel_RowCount
func callbackQStringListModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQStringListModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QStringListModel) ConnectRowCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStringListModel) DisconnectRowCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowCount")
	}
}

func (ptr *QStringListModel) RowCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringListModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QStringListModel) RowCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringListModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QStringListModel) SetStringList(strin []string) {
	if ptr.Pointer() != nil {
		strinC := C.CString(strings.Join(strin, "¡¦!"))
		defer C.free(unsafe.Pointer(strinC))
		C.QStringListModel_SetStringList(ptr.Pointer(), C.struct_QtCore_PackedString{data: strinC, len: C.longlong(len(strings.Join(strin, "¡¦!")))})
	}
}

func (ptr *QStringListModel) StringList() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QStringListModel_StringList(ptr.Pointer())))
	}
	return make([]string, 0)
}

type QStringMatcher struct {
	ptr unsafe.Pointer
}

type QStringMatcher_ITF interface {
	QStringMatcher_PTR() *QStringMatcher
}

func (ptr *QStringMatcher) QStringMatcher_PTR() *QStringMatcher {
	return ptr
}

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

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

func PointerFromQStringMatcher(ptr QStringMatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringMatcher_PTR().Pointer()
	}
	return nil
}

func NewQStringMatcherFromPointer(ptr unsafe.Pointer) (n *QStringMatcher) {
	n = new(QStringMatcher)
	n.SetPointer(ptr)
	return
}
func NewQStringMatcher() *QStringMatcher {
	tmpValue := NewQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher())
	runtime.SetFinalizer(tmpValue, (*QStringMatcher).DestroyQStringMatcher)
	return tmpValue
}

func NewQStringMatcher2(pattern string, cs Qt__CaseSensitivity) *QStringMatcher {
	var patternC *C.char
	if pattern != "" {
		patternC = C.CString(pattern)
		defer C.free(unsafe.Pointer(patternC))
	}
	tmpValue := NewQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher2(C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))}, C.longlong(cs)))
	runtime.SetFinalizer(tmpValue, (*QStringMatcher).DestroyQStringMatcher)
	return tmpValue
}

func NewQStringMatcher3(uc QChar_ITF, length int, cs Qt__CaseSensitivity) *QStringMatcher {
	tmpValue := NewQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher3(PointerFromQChar(uc), C.int(int32(length)), C.longlong(cs)))
	runtime.SetFinalizer(tmpValue, (*QStringMatcher).DestroyQStringMatcher)
	return tmpValue
}

func NewQStringMatcher4(other QStringMatcher_ITF) *QStringMatcher {
	tmpValue := NewQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher4(PointerFromQStringMatcher(other)))
	runtime.SetFinalizer(tmpValue, (*QStringMatcher).DestroyQStringMatcher)
	return tmpValue
}

func (ptr *QStringMatcher) CaseSensitivity() Qt__CaseSensitivity {
	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QStringMatcher_CaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStringMatcher) IndexIn(str string, from int) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QStringMatcher_IndexIn(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.int(int32(from)))))
	}
	return 0
}

func (ptr *QStringMatcher) IndexIn2(str QChar_ITF, length int, from int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringMatcher_IndexIn2(ptr.Pointer(), PointerFromQChar(str), C.int(int32(length)), C.int(int32(from)))))
	}
	return 0
}

func (ptr *QStringMatcher) Pattern() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStringMatcher_Pattern(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStringMatcher) SetCaseSensitivity(cs Qt__CaseSensitivity) {
	if ptr.Pointer() != nil {
		C.QStringMatcher_SetCaseSensitivity(ptr.Pointer(), C.longlong(cs))
	}
}

func (ptr *QStringMatcher) SetPattern(pattern string) {
	if ptr.Pointer() != nil {
		var patternC *C.char
		if pattern != "" {
			patternC = C.CString(pattern)
			defer C.free(unsafe.Pointer(patternC))
		}
		C.QStringMatcher_SetPattern(ptr.Pointer(), C.struct_QtCore_PackedString{data: patternC, len: C.longlong(len(pattern))})
	}
}

func (ptr *QStringMatcher) DestroyQStringMatcher() {
	if ptr.Pointer() != nil {
		C.QStringMatcher_DestroyQStringMatcher(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QStringRef struct {
	ptr unsafe.Pointer
}

type QStringRef_ITF interface {
	QStringRef_PTR() *QStringRef
}

func (ptr *QStringRef) QStringRef_PTR() *QStringRef {
	return ptr
}

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

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

func PointerFromQStringRef(ptr QStringRef_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringRef_PTR().Pointer()
	}
	return nil
}

func NewQStringRefFromPointer(ptr unsafe.Pointer) (n *QStringRef) {
	n = new(QStringRef)
	n.SetPointer(ptr)
	return
}
func NewQStringRef() *QStringRef {
	tmpValue := NewQStringRefFromPointer(C.QStringRef_NewQStringRef())
	runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
	return tmpValue
}

func NewQStringRef2(stri string, position int, length int) *QStringRef {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQStringRefFromPointer(C.QStringRef_NewQStringRef2(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.int(int32(position)), C.int(int32(length))))
	runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
	return tmpValue
}

func NewQStringRef3(stri string) *QStringRef {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQStringRefFromPointer(C.QStringRef_NewQStringRef3(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}))
	runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
	return tmpValue
}

func NewQStringRef4(other QStringRef_ITF) *QStringRef {
	tmpValue := NewQStringRefFromPointer(C.QStringRef_NewQStringRef4(PointerFromQStringRef(other)))
	runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
	return tmpValue
}

func (ptr *QStringRef) AppendTo(stri string) *QStringRef {
	if ptr.Pointer() != nil {
		var striC *C.char
		if stri != "" {
			striC = C.CString(stri)
			defer C.free(unsafe.Pointer(striC))
		}
		tmpValue := NewQStringRefFromPointer(C.QStringRef_AppendTo(ptr.Pointer(), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) At(position int) *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QStringRef_At(ptr.Pointer(), C.int(int32(position))))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) Back() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QStringRef_Back(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) Chop(n int) {
	if ptr.Pointer() != nil {
		C.QStringRef_Chop(ptr.Pointer(), C.int(int32(n)))
	}
}

func (ptr *QStringRef) Chopped(l int) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QStringRef_Chopped(ptr.Pointer(), C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) Clear() {
	if ptr.Pointer() != nil {
		C.QStringRef_Clear(ptr.Pointer())
	}
}

func QStringRef_Compare(s1 QStringRef_ITF, s2 string, cs Qt__CaseSensitivity) int {
	var s2C *C.char
	if s2 != "" {
		s2C = C.CString(s2)
		defer C.free(unsafe.Pointer(s2C))
	}
	return int(int32(C.QStringRef_QStringRef_Compare(PointerFromQStringRef(s1), C.struct_QtCore_PackedString{data: s2C, len: C.longlong(len(s2))}, C.longlong(cs))))
}

func (ptr *QStringRef) Compare(s1 QStringRef_ITF, s2 string, cs Qt__CaseSensitivity) int {
	var s2C *C.char
	if s2 != "" {
		s2C = C.CString(s2)
		defer C.free(unsafe.Pointer(s2C))
	}
	return int(int32(C.QStringRef_QStringRef_Compare(PointerFromQStringRef(s1), C.struct_QtCore_PackedString{data: s2C, len: C.longlong(len(s2))}, C.longlong(cs))))
}

func (ptr *QStringRef) Compare2(other string, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		var otherC *C.char
		if other != "" {
			otherC = C.CString(other)
			defer C.free(unsafe.Pointer(otherC))
		}
		return int(int32(C.QStringRef_Compare2(ptr.Pointer(), C.struct_QtCore_PackedString{data: otherC, len: C.longlong(len(other))}, C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) Compare3(other QStringRef_ITF, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_Compare3(ptr.Pointer(), PointerFromQStringRef(other), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) Compare4(other QLatin1String_ITF, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_Compare4(ptr.Pointer(), PointerFromQLatin1String(other), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) Compare5(other QByteArray_ITF, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_Compare5(ptr.Pointer(), PointerFromQByteArray(other), C.longlong(cs))))
	}
	return 0
}

func QStringRef_Compare6(s1 QStringRef_ITF, s2 QStringRef_ITF, cs Qt__CaseSensitivity) int {
	return int(int32(C.QStringRef_QStringRef_Compare6(PointerFromQStringRef(s1), PointerFromQStringRef(s2), C.longlong(cs))))
}

func (ptr *QStringRef) Compare6(s1 QStringRef_ITF, s2 QStringRef_ITF, cs Qt__CaseSensitivity) int {
	return int(int32(C.QStringRef_QStringRef_Compare6(PointerFromQStringRef(s1), PointerFromQStringRef(s2), C.longlong(cs))))
}

func QStringRef_Compare7(s1 QStringRef_ITF, s2 QLatin1String_ITF, cs Qt__CaseSensitivity) int {
	return int(int32(C.QStringRef_QStringRef_Compare7(PointerFromQStringRef(s1), PointerFromQLatin1String(s2), C.longlong(cs))))
}

func (ptr *QStringRef) Compare7(s1 QStringRef_ITF, s2 QLatin1String_ITF, cs Qt__CaseSensitivity) int {
	return int(int32(C.QStringRef_QStringRef_Compare7(PointerFromQStringRef(s1), PointerFromQLatin1String(s2), C.longlong(cs))))
}

func (ptr *QStringRef) ConstData() *QChar {
	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_ConstData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) Contains(str string, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int8(C.QStringRef_Contains(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) Contains2(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_Contains2(ptr.Pointer(), PointerFromQChar(ch), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) Contains3(str QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_Contains3(ptr.Pointer(), PointerFromQLatin1String(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) Contains4(str QStringRef_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_Contains4(ptr.Pointer(), PointerFromQStringRef(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStringRef) Count2(str string, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QStringRef_Count2(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) Count3(ch QChar_ITF, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_Count3(ptr.Pointer(), PointerFromQChar(ch), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) Count4(str QStringRef_ITF, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_Count4(ptr.Pointer(), PointerFromQStringRef(str), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) Data() *QChar {
	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_Data(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) EndsWith(str string, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int8(C.QStringRef_EndsWith(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) EndsWith2(str QStringView_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_EndsWith2(ptr.Pointer(), PointerFromQStringView(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) EndsWith3(str QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_EndsWith3(ptr.Pointer(), PointerFromQLatin1String(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) EndsWith4(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_EndsWith4(ptr.Pointer(), PointerFromQChar(ch), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) EndsWith5(str QStringRef_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_EndsWith5(ptr.Pointer(), PointerFromQStringRef(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) Front() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QStringRef_Front(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) IndexOf(str string, from int, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QStringRef_IndexOf(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.int(int32(from)), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) IndexOf2(ch QChar_ITF, from int, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_IndexOf2(ptr.Pointer(), PointerFromQChar(ch), C.int(int32(from)), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) IndexOf3(str QLatin1String_ITF, from int, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_IndexOf3(ptr.Pointer(), PointerFromQLatin1String(str), C.int(int32(from)), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) IndexOf4(str QStringRef_ITF, from int, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_IndexOf4(ptr.Pointer(), PointerFromQStringRef(str), C.int(int32(from)), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStringRef) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStringRef) IsRightToLeft() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_IsRightToLeft(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStringRef) LastIndexOf(str string, from int, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int(int32(C.QStringRef_LastIndexOf(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.int(int32(from)), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) LastIndexOf2(ch QChar_ITF, from int, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_LastIndexOf2(ptr.Pointer(), PointerFromQChar(ch), C.int(int32(from)), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) LastIndexOf3(str QLatin1String_ITF, from int, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_LastIndexOf3(ptr.Pointer(), PointerFromQLatin1String(str), C.int(int32(from)), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) LastIndexOf4(str QStringRef_ITF, from int, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_LastIndexOf4(ptr.Pointer(), PointerFromQStringRef(str), C.int(int32(from)), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringRef) Left(n int) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QStringRef_Left(ptr.Pointer(), C.int(int32(n))))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) Length() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_Length(ptr.Pointer())))
	}
	return 0
}

func QStringRef_LocaleAwareCompare(s1 QStringRef_ITF, s2 string) int {
	var s2C *C.char
	if s2 != "" {
		s2C = C.CString(s2)
		defer C.free(unsafe.Pointer(s2C))
	}
	return int(int32(C.QStringRef_QStringRef_LocaleAwareCompare(PointerFromQStringRef(s1), C.struct_QtCore_PackedString{data: s2C, len: C.longlong(len(s2))})))
}

func (ptr *QStringRef) LocaleAwareCompare(s1 QStringRef_ITF, s2 string) int {
	var s2C *C.char
	if s2 != "" {
		s2C = C.CString(s2)
		defer C.free(unsafe.Pointer(s2C))
	}
	return int(int32(C.QStringRef_QStringRef_LocaleAwareCompare(PointerFromQStringRef(s1), C.struct_QtCore_PackedString{data: s2C, len: C.longlong(len(s2))})))
}

func (ptr *QStringRef) LocaleAwareCompare2(other string) int {
	if ptr.Pointer() != nil {
		var otherC *C.char
		if other != "" {
			otherC = C.CString(other)
			defer C.free(unsafe.Pointer(otherC))
		}
		return int(int32(C.QStringRef_LocaleAwareCompare2(ptr.Pointer(), C.struct_QtCore_PackedString{data: otherC, len: C.longlong(len(other))})))
	}
	return 0
}

func (ptr *QStringRef) LocaleAwareCompare3(other QStringRef_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_LocaleAwareCompare3(ptr.Pointer(), PointerFromQStringRef(other))))
	}
	return 0
}

func QStringRef_LocaleAwareCompare4(s1 QStringRef_ITF, s2 QStringRef_ITF) int {
	return int(int32(C.QStringRef_QStringRef_LocaleAwareCompare4(PointerFromQStringRef(s1), PointerFromQStringRef(s2))))
}

func (ptr *QStringRef) LocaleAwareCompare4(s1 QStringRef_ITF, s2 QStringRef_ITF) int {
	return int(int32(C.QStringRef_QStringRef_LocaleAwareCompare4(PointerFromQStringRef(s1), PointerFromQStringRef(s2))))
}

func (ptr *QStringRef) Mid(position int, n int) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QStringRef_Mid(ptr.Pointer(), C.int(int32(position)), C.int(int32(n))))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) Position() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_Position(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStringRef) Right(n int) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QStringRef_Right(ptr.Pointer(), C.int(int32(n))))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringRef_Size(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStringRef) Split(sep string, behavior QString__SplitBehavior, cs Qt__CaseSensitivity) []*QStringRef {
	if ptr.Pointer() != nil {
		var sepC *C.char
		if sep != "" {
			sepC = C.CString(sep)
			defer C.free(unsafe.Pointer(sepC))
		}
		return func(l C.struct_QtCore_PackedList) []*QStringRef {
			out := make([]*QStringRef, int(l.len))
			tmpList := NewQStringRefFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__split_atList(i)
			}
			return out
		}(C.QStringRef_Split(ptr.Pointer(), C.struct_QtCore_PackedString{data: sepC, len: C.longlong(len(sep))}, C.longlong(behavior), C.longlong(cs)))
	}
	return make([]*QStringRef, 0)
}

func (ptr *QStringRef) Split2(sep QChar_ITF, behavior QString__SplitBehavior, cs Qt__CaseSensitivity) []*QStringRef {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QStringRef {
			out := make([]*QStringRef, int(l.len))
			tmpList := NewQStringRefFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__split_atList2(i)
			}
			return out
		}(C.QStringRef_Split2(ptr.Pointer(), PointerFromQChar(sep), C.longlong(behavior), C.longlong(cs)))
	}
	return make([]*QStringRef, 0)
}

func (ptr *QStringRef) StartsWith(str string, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		return int8(C.QStringRef_StartsWith(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}, C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) StartsWith2(str QStringView_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_StartsWith2(ptr.Pointer(), PointerFromQStringView(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) StartsWith3(str QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_StartsWith3(ptr.Pointer(), PointerFromQLatin1String(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) StartsWith4(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_StartsWith4(ptr.Pointer(), PointerFromQChar(ch), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) StartsWith5(str QStringRef_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringRef_StartsWith5(ptr.Pointer(), PointerFromQStringRef(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringRef) String() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStringRef_String(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStringRef) ToDouble(ok *bool) float64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float64(C.QStringRef_ToDouble(ptr.Pointer(), &okC))
	}
	return 0
}

func (ptr *QStringRef) ToFloat(ok *bool) float32 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float32(C.QStringRef_ToFloat(ptr.Pointer(), &okC))
	}
	return 0
}

func (ptr *QStringRef) ToInt(ok *bool, base int) int {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QStringRef_ToInt(ptr.Pointer(), &okC, C.int(int32(base)))))
	}
	return 0
}

func (ptr *QStringRef) ToLatin1() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QStringRef_ToLatin1(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) ToLocal8Bit() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QStringRef_ToLocal8Bit(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) ToLong(ok *bool, base int) int {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QStringRef_ToLong(ptr.Pointer(), &okC, C.int(int32(base)))))
	}
	return 0
}

func (ptr *QStringRef) ToLongLong(ok *bool, base int) int64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int64(C.QStringRef_ToLongLong(ptr.Pointer(), &okC, C.int(int32(base))))
	}
	return 0
}

func (ptr *QStringRef) ToShort(ok *bool, base int) int16 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int16(C.QStringRef_ToShort(ptr.Pointer(), &okC, C.int(int32(base))))
	}
	return 0
}

func (ptr *QStringRef) ToString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStringRef_ToString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStringRef) ToUInt(ok *bool, base int) uint {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QStringRef_ToUInt(ptr.Pointer(), &okC, C.int(int32(base)))))
	}
	return 0
}

func (ptr *QStringRef) ToULong(ok *bool, base int) uint {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QStringRef_ToULong(ptr.Pointer(), &okC, C.int(int32(base)))))
	}
	return 0
}

func (ptr *QStringRef) ToULongLong(ok *bool, base int) uint64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint64(C.QStringRef_ToULongLong(ptr.Pointer(), &okC, C.int(int32(base))))
	}
	return 0
}

func (ptr *QStringRef) ToUShort(ok *bool, base int) uint16 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint16(C.QStringRef_ToUShort(ptr.Pointer(), &okC, C.int(int32(base))))
	}
	return 0
}

func (ptr *QStringRef) ToUcs4() []uint {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []uint {
			out := make([]uint, int(l.len))
			tmpList := NewQStringRefFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__toUcs4_atList(i)
			}
			return out
		}(C.QStringRef_ToUcs4(ptr.Pointer()))
	}
	return make([]uint, 0)
}

func (ptr *QStringRef) ToUtf8() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QStringRef_ToUtf8(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) Trimmed() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QStringRef_Trimmed(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) Truncate(position int) {
	if ptr.Pointer() != nil {
		C.QStringRef_Truncate(ptr.Pointer(), C.int(int32(position)))
	}
}

func (ptr *QStringRef) Unicode() *QChar {
	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_Unicode(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) DestroyQStringRef() {
	if ptr.Pointer() != nil {
		C.QStringRef_DestroyQStringRef(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStringRef) __split_atList(i int) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QStringRef___split_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) __split_setList(i QStringRef_ITF) {
	if ptr.Pointer() != nil {
		C.QStringRef___split_setList(ptr.Pointer(), PointerFromQStringRef(i))
	}
}

func (ptr *QStringRef) __split_newList() unsafe.Pointer {
	return C.QStringRef___split_newList(ptr.Pointer())
}

func (ptr *QStringRef) __split_atList2(i int) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QStringRef___split_atList2(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QStringRef) __split_setList2(i QStringRef_ITF) {
	if ptr.Pointer() != nil {
		C.QStringRef___split_setList2(ptr.Pointer(), PointerFromQStringRef(i))
	}
}

func (ptr *QStringRef) __split_newList2() unsafe.Pointer {
	return C.QStringRef___split_newList2(ptr.Pointer())
}

func (ptr *QStringRef) __toUcs4_atList(i int) uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QStringRef___toUcs4_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QStringRef) __toUcs4_setList(i uint) {
	if ptr.Pointer() != nil {
		C.QStringRef___toUcs4_setList(ptr.Pointer(), C.uint(uint32(i)))
	}
}

func (ptr *QStringRef) __toUcs4_newList() unsafe.Pointer {
	return C.QStringRef___toUcs4_newList(ptr.Pointer())
}

type QStringView struct {
	ptr unsafe.Pointer
}

type QStringView_ITF interface {
	QStringView_PTR() *QStringView
}

func (ptr *QStringView) QStringView_PTR() *QStringView {
	return ptr
}

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

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

func PointerFromQStringView(ptr QStringView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringView_PTR().Pointer()
	}
	return nil
}

func NewQStringViewFromPointer(ptr unsafe.Pointer) (n *QStringView) {
	n = new(QStringView)
	n.SetPointer(ptr)
	return
}

func (ptr *QStringView) DestroyQStringView() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQStringView() *QStringView {
	tmpValue := NewQStringViewFromPointer(C.QStringView_NewQStringView())
	runtime.SetFinalizer(tmpValue, (*QStringView).DestroyQStringView)
	return tmpValue
}

func NewQStringView7(str string) *QStringView {
	var strC *C.char
	if str != "" {
		strC = C.CString(str)
		defer C.free(unsafe.Pointer(strC))
	}
	tmpValue := NewQStringViewFromPointer(C.QStringView_NewQStringView7(C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
	runtime.SetFinalizer(tmpValue, (*QStringView).DestroyQStringView)
	return tmpValue
}

func NewQStringView8(str QStringRef_ITF) *QStringView {
	tmpValue := NewQStringViewFromPointer(C.QStringView_NewQStringView8(PointerFromQStringRef(str)))
	runtime.SetFinalizer(tmpValue, (*QStringView).DestroyQStringView)
	return tmpValue
}

func (ptr *QStringView) Back() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QStringView_Back(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QStringView) Compare(other QStringView_ITF, cs Qt__CaseSensitivity) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringView_Compare(ptr.Pointer(), PointerFromQStringView(other), C.longlong(cs))))
	}
	return 0
}

func (ptr *QStringView) Empty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_Empty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStringView) EndsWith(str QStringView_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_EndsWith(ptr.Pointer(), PointerFromQStringView(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringView) EndsWith2(l1 QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_EndsWith2(ptr.Pointer(), PointerFromQLatin1String(l1), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringView) EndsWith3(ch QChar_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_EndsWith3(ptr.Pointer(), PointerFromQChar(ch))) != 0
	}
	return false
}

func (ptr *QStringView) EndsWith4(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_EndsWith4(ptr.Pointer(), PointerFromQChar(ch), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringView) First() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QStringView_First(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QStringView) Front() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QStringView_Front(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QStringView) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStringView) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStringView) IsRightToLeft() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_IsRightToLeft(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStringView) Last() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QStringView_Last(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QStringView) Length() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStringView_Length(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStringView) StartsWith(str QStringView_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_StartsWith(ptr.Pointer(), PointerFromQStringView(str), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringView) StartsWith2(l1 QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_StartsWith2(ptr.Pointer(), PointerFromQLatin1String(l1), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringView) StartsWith3(ch QChar_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_StartsWith3(ptr.Pointer(), PointerFromQChar(ch))) != 0
	}
	return false
}

func (ptr *QStringView) StartsWith4(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStringView_StartsWith4(ptr.Pointer(), PointerFromQChar(ch), C.longlong(cs))) != 0
	}
	return false
}

func (ptr *QStringView) ToLatin1() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QStringView_ToLatin1(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStringView) ToLocal8Bit() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QStringView_ToLocal8Bit(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStringView) ToString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStringView_ToString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStringView) ToUcs4() []uint {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []uint {
			out := make([]uint, int(l.len))
			tmpList := NewQStringViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__toUcs4_atList(i)
			}
			return out
		}(C.QStringView_ToUcs4(ptr.Pointer()))
	}
	return make([]uint, 0)
}

func (ptr *QStringView) ToUtf8() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QStringView_ToUtf8(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStringView) Trimmed() *QStringView {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringViewFromPointer(C.QStringView_Trimmed(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringView).DestroyQStringView)
		return tmpValue
	}
	return nil
}

func (ptr *QStringView) __convertToUcs4_atList(i int) uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QStringView___convertToUcs4_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QStringView) __convertToUcs4_setList(i uint) {
	if ptr.Pointer() != nil {
		C.QStringView___convertToUcs4_setList(ptr.Pointer(), C.uint(uint32(i)))
	}
}

func (ptr *QStringView) __convertToUcs4_newList() unsafe.Pointer {
	return C.QStringView___convertToUcs4_newList(ptr.Pointer())
}

func (ptr *QStringView) __toUcs4_atList(i int) uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QStringView___toUcs4_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QStringView) __toUcs4_setList(i uint) {
	if ptr.Pointer() != nil {
		C.QStringView___toUcs4_setList(ptr.Pointer(), C.uint(uint32(i)))
	}
}

func (ptr *QStringView) __toUcs4_newList() unsafe.Pointer {
	return C.QStringView___toUcs4_newList(ptr.Pointer())
}

type QSysInfo struct {
	ptr unsafe.Pointer
}

type QSysInfo_ITF interface {
	QSysInfo_PTR() *QSysInfo
}

func (ptr *QSysInfo) QSysInfo_PTR() *QSysInfo {
	return ptr
}

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

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

func PointerFromQSysInfo(ptr QSysInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSysInfo_PTR().Pointer()
	}
	return nil
}

func NewQSysInfoFromPointer(ptr unsafe.Pointer) (n *QSysInfo) {
	n = new(QSysInfo)
	n.SetPointer(ptr)
	return
}

func (ptr *QSysInfo) DestroyQSysInfo() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QSysInfo__Sizes
//QSysInfo::Sizes
type QSysInfo__Sizes int64

var (
	QSysInfo__WordSize QSysInfo__Sizes = QSysInfo__Sizes(C.QSysInfo_WordSize_Type())
)

//go:generate stringer -type=QSysInfo__Endian
//QSysInfo::Endian
type QSysInfo__Endian int64

const (
	QSysInfo__BigEndian    QSysInfo__Endian = QSysInfo__Endian(0)
	QSysInfo__LittleEndian QSysInfo__Endian = QSysInfo__Endian(1)
)

func QSysInfo_BootUniqueId() *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QSysInfo_QSysInfo_BootUniqueId())
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QSysInfo) BootUniqueId() *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QSysInfo_QSysInfo_BootUniqueId())
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QSysInfo_BuildAbi() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_BuildAbi())
}

func (ptr *QSysInfo) BuildAbi() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_BuildAbi())
}

func QSysInfo_BuildCpuArchitecture() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_BuildCpuArchitecture())
}

func (ptr *QSysInfo) BuildCpuArchitecture() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_BuildCpuArchitecture())
}

func QSysInfo_CurrentCpuArchitecture() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_CurrentCpuArchitecture())
}

func (ptr *QSysInfo) CurrentCpuArchitecture() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_CurrentCpuArchitecture())
}

func QSysInfo_KernelType() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_KernelType())
}

func (ptr *QSysInfo) KernelType() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_KernelType())
}

func QSysInfo_KernelVersion() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_KernelVersion())
}

func (ptr *QSysInfo) KernelVersion() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_KernelVersion())
}

func QSysInfo_MachineHostName() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_MachineHostName())
}

func (ptr *QSysInfo) MachineHostName() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_MachineHostName())
}

func QSysInfo_MachineUniqueId() *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QSysInfo_QSysInfo_MachineUniqueId())
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QSysInfo) MachineUniqueId() *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QSysInfo_QSysInfo_MachineUniqueId())
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QSysInfo_PrettyProductName() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_PrettyProductName())
}

func (ptr *QSysInfo) PrettyProductName() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_PrettyProductName())
}

func QSysInfo_ProductType() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_ProductType())
}

func (ptr *QSysInfo) ProductType() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_ProductType())
}

func QSysInfo_ProductVersion() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_ProductVersion())
}

func (ptr *QSysInfo) ProductVersion() string {
	return cGoUnpackString(C.QSysInfo_QSysInfo_ProductVersion())
}

type QSystemSemaphore struct {
	ptr unsafe.Pointer
}

type QSystemSemaphore_ITF interface {
	QSystemSemaphore_PTR() *QSystemSemaphore
}

func (ptr *QSystemSemaphore) QSystemSemaphore_PTR() *QSystemSemaphore {
	return ptr
}

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

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

func PointerFromQSystemSemaphore(ptr QSystemSemaphore_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSystemSemaphore_PTR().Pointer()
	}
	return nil
}

func NewQSystemSemaphoreFromPointer(ptr unsafe.Pointer) (n *QSystemSemaphore) {
	n = new(QSystemSemaphore)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QSystemSemaphore__AccessMode
//QSystemSemaphore::AccessMode
type QSystemSemaphore__AccessMode int64

const (
	QSystemSemaphore__Open   QSystemSemaphore__AccessMode = QSystemSemaphore__AccessMode(0)
	QSystemSemaphore__Create QSystemSemaphore__AccessMode = QSystemSemaphore__AccessMode(1)
)

//go:generate stringer -type=QSystemSemaphore__SystemSemaphoreError
//QSystemSemaphore::SystemSemaphoreError
type QSystemSemaphore__SystemSemaphoreError int64

const (
	QSystemSemaphore__NoError          QSystemSemaphore__SystemSemaphoreError = QSystemSemaphore__SystemSemaphoreError(0)
	QSystemSemaphore__PermissionDenied QSystemSemaphore__SystemSemaphoreError = QSystemSemaphore__SystemSemaphoreError(1)
	QSystemSemaphore__KeyError         QSystemSemaphore__SystemSemaphoreError = QSystemSemaphore__SystemSemaphoreError(2)
	QSystemSemaphore__AlreadyExists    QSystemSemaphore__SystemSemaphoreError = QSystemSemaphore__SystemSemaphoreError(3)
	QSystemSemaphore__NotFound         QSystemSemaphore__SystemSemaphoreError = QSystemSemaphore__SystemSemaphoreError(4)
	QSystemSemaphore__OutOfResources   QSystemSemaphore__SystemSemaphoreError = QSystemSemaphore__SystemSemaphoreError(5)
	QSystemSemaphore__UnknownError     QSystemSemaphore__SystemSemaphoreError = QSystemSemaphore__SystemSemaphoreError(6)
)

func NewQSystemSemaphore(key string, initialValue int, mode QSystemSemaphore__AccessMode) *QSystemSemaphore {
	var keyC *C.char
	if key != "" {
		keyC = C.CString(key)
		defer C.free(unsafe.Pointer(keyC))
	}
	tmpValue := NewQSystemSemaphoreFromPointer(C.QSystemSemaphore_NewQSystemSemaphore(C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, C.int(int32(initialValue)), C.longlong(mode)))
	runtime.SetFinalizer(tmpValue, (*QSystemSemaphore).DestroyQSystemSemaphore)
	return tmpValue
}

func (ptr *QSystemSemaphore) Acquire() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSystemSemaphore_Acquire(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSystemSemaphore) Error() QSystemSemaphore__SystemSemaphoreError {
	if ptr.Pointer() != nil {
		return QSystemSemaphore__SystemSemaphoreError(C.QSystemSemaphore_Error(ptr.Pointer()))
	}
	return 0
}

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

func (ptr *QSystemSemaphore) Key() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSystemSemaphore_Key(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSystemSemaphore) Release(n int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSystemSemaphore_Release(ptr.Pointer(), C.int(int32(n)))) != 0
	}
	return false
}

func (ptr *QSystemSemaphore) SetKey(key string, initialValue int, mode QSystemSemaphore__AccessMode) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QSystemSemaphore_SetKey(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, C.int(int32(initialValue)), C.longlong(mode))
	}
}

func (ptr *QSystemSemaphore) DestroyQSystemSemaphore() {
	if ptr.Pointer() != nil {
		C.QSystemSemaphore_DestroyQSystemSemaphore(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTemporaryDir struct {
	ptr unsafe.Pointer
}

type QTemporaryDir_ITF interface {
	QTemporaryDir_PTR() *QTemporaryDir
}

func (ptr *QTemporaryDir) QTemporaryDir_PTR() *QTemporaryDir {
	return ptr
}

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

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

func PointerFromQTemporaryDir(ptr QTemporaryDir_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTemporaryDir_PTR().Pointer()
	}
	return nil
}

func NewQTemporaryDirFromPointer(ptr unsafe.Pointer) (n *QTemporaryDir) {
	n = new(QTemporaryDir)
	n.SetPointer(ptr)
	return
}
func NewQTemporaryDir() *QTemporaryDir {
	tmpValue := NewQTemporaryDirFromPointer(C.QTemporaryDir_NewQTemporaryDir())
	runtime.SetFinalizer(tmpValue, (*QTemporaryDir).DestroyQTemporaryDir)
	return tmpValue
}

func NewQTemporaryDir2(templatePath string) *QTemporaryDir {
	var templatePathC *C.char
	if templatePath != "" {
		templatePathC = C.CString(templatePath)
		defer C.free(unsafe.Pointer(templatePathC))
	}
	tmpValue := NewQTemporaryDirFromPointer(C.QTemporaryDir_NewQTemporaryDir2(C.struct_QtCore_PackedString{data: templatePathC, len: C.longlong(len(templatePath))}))
	runtime.SetFinalizer(tmpValue, (*QTemporaryDir).DestroyQTemporaryDir)
	return tmpValue
}

func (ptr *QTemporaryDir) AutoRemove() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTemporaryDir_AutoRemove(ptr.Pointer())) != 0
	}
	return false
}

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

func (ptr *QTemporaryDir) FilePath(fileName string) string {
	if ptr.Pointer() != nil {
		var fileNameC *C.char
		if fileName != "" {
			fileNameC = C.CString(fileName)
			defer C.free(unsafe.Pointer(fileNameC))
		}
		return cGoUnpackString(C.QTemporaryDir_FilePath(ptr.Pointer(), C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	}
	return ""
}

func (ptr *QTemporaryDir) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTemporaryDir_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTemporaryDir) Path() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTemporaryDir_Path(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTemporaryDir) Remove() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTemporaryDir_Remove(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTemporaryDir) SetAutoRemove(b bool) {
	if ptr.Pointer() != nil {
		C.QTemporaryDir_SetAutoRemove(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QTemporaryDir) DestroyQTemporaryDir() {
	if ptr.Pointer() != nil {
		C.QTemporaryDir_DestroyQTemporaryDir(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTemporaryFile struct {
	QFile
}

type QTemporaryFile_ITF interface {
	QFile_ITF
	QTemporaryFile_PTR() *QTemporaryFile
}

func (ptr *QTemporaryFile) QTemporaryFile_PTR() *QTemporaryFile {
	return ptr
}

func (ptr *QTemporaryFile) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QFile_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQTemporaryFile(ptr QTemporaryFile_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTemporaryFile_PTR().Pointer()
	}
	return nil
}

func NewQTemporaryFileFromPointer(ptr unsafe.Pointer) (n *QTemporaryFile) {
	n = new(QTemporaryFile)
	n.SetPointer(ptr)
	return
}
func NewQTemporaryFile() *QTemporaryFile {
	tmpValue := NewQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQTemporaryFile2(templateName string) *QTemporaryFile {
	var templateNameC *C.char
	if templateName != "" {
		templateNameC = C.CString(templateName)
		defer C.free(unsafe.Pointer(templateNameC))
	}
	tmpValue := NewQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile2(C.struct_QtCore_PackedString{data: templateNameC, len: C.longlong(len(templateName))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQTemporaryFile3(parent QObject_ITF) *QTemporaryFile {
	tmpValue := NewQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile3(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQTemporaryFile4(templateName string, parent QObject_ITF) *QTemporaryFile {
	var templateNameC *C.char
	if templateName != "" {
		templateNameC = C.CString(templateName)
		defer C.free(unsafe.Pointer(templateNameC))
	}
	tmpValue := NewQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile4(C.struct_QtCore_PackedString{data: templateNameC, len: C.longlong(len(templateName))}, PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTemporaryFile) AutoRemove() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTemporaryFile_AutoRemove(ptr.Pointer())) != 0
	}
	return false
}

func QTemporaryFile_CreateNativeFile(file QFile_ITF) *QTemporaryFile {
	tmpValue := NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile(PointerFromQFile(file)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTemporaryFile) CreateNativeFile(file QFile_ITF) *QTemporaryFile {
	tmpValue := NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile(PointerFromQFile(file)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QTemporaryFile_CreateNativeFile2(fileName string) *QTemporaryFile {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	tmpValue := NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTemporaryFile) CreateNativeFile2(fileName string) *QTemporaryFile {
	var fileNameC *C.char
	if fileName != "" {
		fileNameC = C.CString(fileName)
		defer C.free(unsafe.Pointer(fileNameC))
	}
	tmpValue := NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile2(C.struct_QtCore_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTemporaryFile) FileTemplate() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTemporaryFile_FileTemplate(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTemporaryFile) Open() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTemporaryFile_Open(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTemporaryFile) SetAutoRemove(b bool) {
	if ptr.Pointer() != nil {
		C.QTemporaryFile_SetAutoRemove(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QTemporaryFile) SetFileTemplate(name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QTemporaryFile_SetFileTemplate(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

//export callbackQTemporaryFile_DestroyQTemporaryFile
func callbackQTemporaryFile_DestroyQTemporaryFile(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTemporaryFile"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTemporaryFileFromPointer(ptr).DestroyQTemporaryFileDefault()
	}
}

func (ptr *QTemporaryFile) ConnectDestroyQTemporaryFile(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTemporaryFile"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTemporaryFile", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTemporaryFile", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTemporaryFile) DisconnectDestroyQTemporaryFile() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTemporaryFile")
	}
}

func (ptr *QTemporaryFile) DestroyQTemporaryFile() {
	if ptr.Pointer() != nil {
		C.QTemporaryFile_DestroyQTemporaryFile(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTemporaryFile) DestroyQTemporaryFileDefault() {
	if ptr.Pointer() != nil {
		C.QTemporaryFile_DestroyQTemporaryFileDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTextBoundaryFinder struct {
	ptr unsafe.Pointer
}

type QTextBoundaryFinder_ITF interface {
	QTextBoundaryFinder_PTR() *QTextBoundaryFinder
}

func (ptr *QTextBoundaryFinder) QTextBoundaryFinder_PTR() *QTextBoundaryFinder {
	return ptr
}

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

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

func PointerFromQTextBoundaryFinder(ptr QTextBoundaryFinder_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextBoundaryFinder_PTR().Pointer()
	}
	return nil
}

func NewQTextBoundaryFinderFromPointer(ptr unsafe.Pointer) (n *QTextBoundaryFinder) {
	n = new(QTextBoundaryFinder)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTextBoundaryFinder__BoundaryType
//QTextBoundaryFinder::BoundaryType
type QTextBoundaryFinder__BoundaryType int64

const (
	QTextBoundaryFinder__Grapheme QTextBoundaryFinder__BoundaryType = QTextBoundaryFinder__BoundaryType(0)
	QTextBoundaryFinder__Word     QTextBoundaryFinder__BoundaryType = QTextBoundaryFinder__BoundaryType(1)
	QTextBoundaryFinder__Sentence QTextBoundaryFinder__BoundaryType = QTextBoundaryFinder__BoundaryType(2)
	QTextBoundaryFinder__Line     QTextBoundaryFinder__BoundaryType = QTextBoundaryFinder__BoundaryType(3)
)

//go:generate stringer -type=QTextBoundaryFinder__BoundaryReason
//QTextBoundaryFinder::BoundaryReason
type QTextBoundaryFinder__BoundaryReason int64

const (
	QTextBoundaryFinder__NotAtBoundary    QTextBoundaryFinder__BoundaryReason = QTextBoundaryFinder__BoundaryReason(0)
	QTextBoundaryFinder__BreakOpportunity QTextBoundaryFinder__BoundaryReason = QTextBoundaryFinder__BoundaryReason(0x1f)
	QTextBoundaryFinder__StartOfItem      QTextBoundaryFinder__BoundaryReason = QTextBoundaryFinder__BoundaryReason(0x20)
	QTextBoundaryFinder__EndOfItem        QTextBoundaryFinder__BoundaryReason = QTextBoundaryFinder__BoundaryReason(0x40)
	QTextBoundaryFinder__MandatoryBreak   QTextBoundaryFinder__BoundaryReason = QTextBoundaryFinder__BoundaryReason(0x80)
	QTextBoundaryFinder__SoftHyphen       QTextBoundaryFinder__BoundaryReason = QTextBoundaryFinder__BoundaryReason(0x100)
)

func NewQTextBoundaryFinder() *QTextBoundaryFinder {
	tmpValue := NewQTextBoundaryFinderFromPointer(C.QTextBoundaryFinder_NewQTextBoundaryFinder())
	runtime.SetFinalizer(tmpValue, (*QTextBoundaryFinder).DestroyQTextBoundaryFinder)
	return tmpValue
}

func NewQTextBoundaryFinder2(other QTextBoundaryFinder_ITF) *QTextBoundaryFinder {
	tmpValue := NewQTextBoundaryFinderFromPointer(C.QTextBoundaryFinder_NewQTextBoundaryFinder2(PointerFromQTextBoundaryFinder(other)))
	runtime.SetFinalizer(tmpValue, (*QTextBoundaryFinder).DestroyQTextBoundaryFinder)
	return tmpValue
}

func NewQTextBoundaryFinder3(ty QTextBoundaryFinder__BoundaryType, stri string) *QTextBoundaryFinder {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQTextBoundaryFinderFromPointer(C.QTextBoundaryFinder_NewQTextBoundaryFinder3(C.longlong(ty), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}))
	runtime.SetFinalizer(tmpValue, (*QTextBoundaryFinder).DestroyQTextBoundaryFinder)
	return tmpValue
}

func (ptr *QTextBoundaryFinder) BoundaryReasons() QTextBoundaryFinder__BoundaryReason {
	if ptr.Pointer() != nil {
		return QTextBoundaryFinder__BoundaryReason(C.QTextBoundaryFinder_BoundaryReasons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) IsAtBoundary() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextBoundaryFinder_IsAtBoundary(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextBoundaryFinder) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextBoundaryFinder_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextBoundaryFinder) Position() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextBoundaryFinder_Position(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) SetPosition(position int) {
	if ptr.Pointer() != nil {
		C.QTextBoundaryFinder_SetPosition(ptr.Pointer(), C.int(int32(position)))
	}
}

func (ptr *QTextBoundaryFinder) String() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextBoundaryFinder_String(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextBoundaryFinder) ToEnd() {
	if ptr.Pointer() != nil {
		C.QTextBoundaryFinder_ToEnd(ptr.Pointer())
	}
}

func (ptr *QTextBoundaryFinder) ToNextBoundary() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextBoundaryFinder_ToNextBoundary(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) ToPreviousBoundary() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextBoundaryFinder_ToPreviousBoundary(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) ToStart() {
	if ptr.Pointer() != nil {
		C.QTextBoundaryFinder_ToStart(ptr.Pointer())
	}
}

func (ptr *QTextBoundaryFinder) Type() QTextBoundaryFinder__BoundaryType {
	if ptr.Pointer() != nil {
		return QTextBoundaryFinder__BoundaryType(C.QTextBoundaryFinder_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) DestroyQTextBoundaryFinder() {
	if ptr.Pointer() != nil {
		C.QTextBoundaryFinder_DestroyQTextBoundaryFinder(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTextCodec struct {
	ptr unsafe.Pointer
}

type QTextCodec_ITF interface {
	QTextCodec_PTR() *QTextCodec
}

func (ptr *QTextCodec) QTextCodec_PTR() *QTextCodec {
	return ptr
}

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

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

func PointerFromQTextCodec(ptr QTextCodec_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextCodec_PTR().Pointer()
	}
	return nil
}

func NewQTextCodecFromPointer(ptr unsafe.Pointer) (n *QTextCodec) {
	n = new(QTextCodec)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTextCodec__ConversionFlag
//QTextCodec::ConversionFlag
type QTextCodec__ConversionFlag int64

const (
	QTextCodec__DefaultConversion    QTextCodec__ConversionFlag = QTextCodec__ConversionFlag(0)
	QTextCodec__ConvertInvalidToNull QTextCodec__ConversionFlag = QTextCodec__ConversionFlag(0x80000000)
	QTextCodec__IgnoreHeader         QTextCodec__ConversionFlag = QTextCodec__ConversionFlag(0x1)
	QTextCodec__FreeFunction         QTextCodec__ConversionFlag = QTextCodec__ConversionFlag(0x2)
)

//export callbackQTextCodec_Aliases
func callbackQTextCodec_Aliases(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "aliases"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQTextCodecFromPointer(NewQTextCodecFromPointer(nil).__aliases_newList())
			for _, v := range (*(*func() []*QByteArray)(signal))() {
				tmpList.__aliases_setList(v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQTextCodecFromPointer(NewQTextCodecFromPointer(nil).__aliases_newList())
		for _, v := range NewQTextCodecFromPointer(ptr).AliasesDefault() {
			tmpList.__aliases_setList(v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QTextCodec) ConnectAliases(f func() []*QByteArray) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "aliases"); signal != nil {
			f := func() []*QByteArray {
				(*(*func() []*QByteArray)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "aliases", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "aliases", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextCodec) DisconnectAliases() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "aliases")
	}
}

func (ptr *QTextCodec) Aliases() []*QByteArray {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QByteArray {
			out := make([]*QByteArray, int(l.len))
			tmpList := NewQTextCodecFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__aliases_atList(i)
			}
			return out
		}(C.QTextCodec_Aliases(ptr.Pointer()))
	}
	return make([]*QByteArray, 0)
}

func (ptr *QTextCodec) AliasesDefault() []*QByteArray {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QByteArray {
			out := make([]*QByteArray, int(l.len))
			tmpList := NewQTextCodecFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__aliases_atList(i)
			}
			return out
		}(C.QTextCodec_AliasesDefault(ptr.Pointer()))
	}
	return make([]*QByteArray, 0)
}

func QTextCodec_AvailableCodecs() []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTextCodecFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableCodecs_atList(i)
		}
		return out
	}(C.QTextCodec_QTextCodec_AvailableCodecs())
}

func (ptr *QTextCodec) AvailableCodecs() []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTextCodecFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableCodecs_atList(i)
		}
		return out
	}(C.QTextCodec_QTextCodec_AvailableCodecs())
}

func QTextCodec_AvailableMibs() []int {
	return func(l C.struct_QtCore_PackedList) []int {
		out := make([]int, int(l.len))
		tmpList := NewQTextCodecFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableMibs_atList(i)
		}
		return out
	}(C.QTextCodec_QTextCodec_AvailableMibs())
}

func (ptr *QTextCodec) AvailableMibs() []int {
	return func(l C.struct_QtCore_PackedList) []int {
		out := make([]int, int(l.len))
		tmpList := NewQTextCodecFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableMibs_atList(i)
		}
		return out
	}(C.QTextCodec_QTextCodec_AvailableMibs())
}

func (ptr *QTextCodec) CanEncode(ch QChar_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextCodec_CanEncode(ptr.Pointer(), PointerFromQChar(ch))) != 0
	}
	return false
}

func (ptr *QTextCodec) CanEncode2(s string) bool {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		return int8(C.QTextCodec_CanEncode2(ptr.Pointer(), C.struct_QtCore_PackedString{data: sC, len: C.longlong(len(s))})) != 0
	}
	return false
}

func (ptr *QTextCodec) CanEncode3(s QStringView_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextCodec_CanEncode3(ptr.Pointer(), PointerFromQStringView(s))) != 0
	}
	return false
}

func QTextCodec_CodecForHtml(ba QByteArray_ITF, defaultCodec QTextCodec_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml(PointerFromQByteArray(ba), PointerFromQTextCodec(defaultCodec)))
}

func (ptr *QTextCodec) CodecForHtml(ba QByteArray_ITF, defaultCodec QTextCodec_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml(PointerFromQByteArray(ba), PointerFromQTextCodec(defaultCodec)))
}

func QTextCodec_CodecForHtml2(ba QByteArray_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml2(PointerFromQByteArray(ba)))
}

func (ptr *QTextCodec) CodecForHtml2(ba QByteArray_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml2(PointerFromQByteArray(ba)))
}

func QTextCodec_CodecForLocale() *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForLocale())
}

func (ptr *QTextCodec) CodecForLocale() *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForLocale())
}

func QTextCodec_CodecForMib(mib int) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForMib(C.int(int32(mib))))
}

func (ptr *QTextCodec) CodecForMib(mib int) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForMib(C.int(int32(mib))))
}

func QTextCodec_CodecForName(name QByteArray_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName(PointerFromQByteArray(name)))
}

func (ptr *QTextCodec) CodecForName(name QByteArray_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName(PointerFromQByteArray(name)))
}

func QTextCodec_CodecForName2(name string) *QTextCodec {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName2(nameC))
}

func (ptr *QTextCodec) CodecForName2(name string) *QTextCodec {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName2(nameC))
}

func QTextCodec_CodecForUtfText(ba QByteArray_ITF, defaultCodec QTextCodec_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText(PointerFromQByteArray(ba), PointerFromQTextCodec(defaultCodec)))
}

func (ptr *QTextCodec) CodecForUtfText(ba QByteArray_ITF, defaultCodec QTextCodec_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText(PointerFromQByteArray(ba), PointerFromQTextCodec(defaultCodec)))
}

func QTextCodec_CodecForUtfText2(ba QByteArray_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText2(PointerFromQByteArray(ba)))
}

func (ptr *QTextCodec) CodecForUtfText2(ba QByteArray_ITF) *QTextCodec {
	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText2(PointerFromQByteArray(ba)))
}

func (ptr *QTextCodec) FromUnicode(str string) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QTextCodec_FromUnicode(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTextCodec) FromUnicode2(str QStringView_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTextCodec_FromUnicode2(ptr.Pointer(), PointerFromQStringView(str)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTextCodec) MakeDecoder(flags QTextCodec__ConversionFlag) *QTextDecoder {
	if ptr.Pointer() != nil {
		return NewQTextDecoderFromPointer(C.QTextCodec_MakeDecoder(ptr.Pointer(), C.longlong(flags)))
	}
	return nil
}

func (ptr *QTextCodec) MakeEncoder(flags QTextCodec__ConversionFlag) *QTextEncoder {
	if ptr.Pointer() != nil {
		return NewQTextEncoderFromPointer(C.QTextCodec_MakeEncoder(ptr.Pointer(), C.longlong(flags)))
	}
	return nil
}

//export callbackQTextCodec_MibEnum
func callbackQTextCodec_MibEnum(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "mibEnum"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(0))
}

func (ptr *QTextCodec) ConnectMibEnum(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mibEnum"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "mibEnum", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mibEnum", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextCodec) DisconnectMibEnum() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mibEnum")
	}
}

func (ptr *QTextCodec) MibEnum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextCodec_MibEnum(ptr.Pointer())))
	}
	return 0
}

//export callbackQTextCodec_Name
func callbackQTextCodec_Name(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "name"); signal != nil {
		return PointerFromQByteArray((*(*func() *QByteArray)(signal))())
	}

	return PointerFromQByteArray(NewQByteArray())
}

func (ptr *QTextCodec) ConnectName(f func() *QByteArray) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "name"); signal != nil {
			f := func() *QByteArray {
				(*(*func() *QByteArray)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "name", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "name", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextCodec) DisconnectName() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "name")
	}
}

func (ptr *QTextCodec) Name() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTextCodec_Name(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func QTextCodec_SetCodecForLocale(c QTextCodec_ITF) {
	C.QTextCodec_QTextCodec_SetCodecForLocale(PointerFromQTextCodec(c))
}

func (ptr *QTextCodec) SetCodecForLocale(c QTextCodec_ITF) {
	C.QTextCodec_QTextCodec_SetCodecForLocale(PointerFromQTextCodec(c))
}

func (ptr *QTextCodec) ToUnicode(a QByteArray_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextCodec_ToUnicode(ptr.Pointer(), PointerFromQByteArray(a)))
	}
	return ""
}

func (ptr *QTextCodec) ToUnicode2(chars string) string {
	if ptr.Pointer() != nil {
		var charsC *C.char
		if chars != "" {
			charsC = C.CString(chars)
			defer C.free(unsafe.Pointer(charsC))
		}
		return cGoUnpackString(C.QTextCodec_ToUnicode2(ptr.Pointer(), charsC))
	}
	return ""
}

//export callbackQTextCodec_DestroyQTextCodec
func callbackQTextCodec_DestroyQTextCodec(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTextCodec"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextCodecFromPointer(ptr).DestroyQTextCodecDefault()
	}
}

func (ptr *QTextCodec) ConnectDestroyQTextCodec(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTextCodec"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTextCodec", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTextCodec", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextCodec) DisconnectDestroyQTextCodec() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTextCodec")
	}
}

func (ptr *QTextCodec) DestroyQTextCodec() {
	if ptr.Pointer() != nil {
		C.QTextCodec_DestroyQTextCodec(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTextCodec) DestroyQTextCodecDefault() {
	if ptr.Pointer() != nil {
		C.QTextCodec_DestroyQTextCodecDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTextCodec) __aliases_atList(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTextCodec___aliases_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTextCodec) __aliases_setList(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QTextCodec___aliases_setList(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QTextCodec) __aliases_newList() unsafe.Pointer {
	return C.QTextCodec___aliases_newList(ptr.Pointer())
}

func (ptr *QTextCodec) __availableCodecs_atList(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTextCodec___availableCodecs_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTextCodec) __availableCodecs_setList(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QTextCodec___availableCodecs_setList(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QTextCodec) __availableCodecs_newList() unsafe.Pointer {
	return C.QTextCodec___availableCodecs_newList(ptr.Pointer())
}

func (ptr *QTextCodec) __availableMibs_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextCodec___availableMibs_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QTextCodec) __availableMibs_setList(i int) {
	if ptr.Pointer() != nil {
		C.QTextCodec___availableMibs_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QTextCodec) __availableMibs_newList() unsafe.Pointer {
	return C.QTextCodec___availableMibs_newList(ptr.Pointer())
}

type QTextDecoder struct {
	ptr unsafe.Pointer
}

type QTextDecoder_ITF interface {
	QTextDecoder_PTR() *QTextDecoder
}

func (ptr *QTextDecoder) QTextDecoder_PTR() *QTextDecoder {
	return ptr
}

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

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

func PointerFromQTextDecoder(ptr QTextDecoder_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextDecoder_PTR().Pointer()
	}
	return nil
}

func NewQTextDecoderFromPointer(ptr unsafe.Pointer) (n *QTextDecoder) {
	n = new(QTextDecoder)
	n.SetPointer(ptr)
	return
}
func NewQTextDecoder2(codec QTextCodec_ITF) *QTextDecoder {
	tmpValue := NewQTextDecoderFromPointer(C.QTextDecoder_NewQTextDecoder2(PointerFromQTextCodec(codec)))
	runtime.SetFinalizer(tmpValue, (*QTextDecoder).DestroyQTextDecoder)
	return tmpValue
}

func NewQTextDecoder3(codec QTextCodec_ITF, flags QTextCodec__ConversionFlag) *QTextDecoder {
	tmpValue := NewQTextDecoderFromPointer(C.QTextDecoder_NewQTextDecoder3(PointerFromQTextCodec(codec), C.longlong(flags)))
	runtime.SetFinalizer(tmpValue, (*QTextDecoder).DestroyQTextDecoder)
	return tmpValue
}

func (ptr *QTextDecoder) ToUnicode(chars string, l int) string {
	if ptr.Pointer() != nil {
		var charsC *C.char
		if chars != "" {
			charsC = C.CString(chars)
			defer C.free(unsafe.Pointer(charsC))
		}
		return cGoUnpackString(C.QTextDecoder_ToUnicode(ptr.Pointer(), charsC, C.int(int32(l))))
	}
	return ""
}

func (ptr *QTextDecoder) ToUnicode2(ba QByteArray_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextDecoder_ToUnicode2(ptr.Pointer(), PointerFromQByteArray(ba)))
	}
	return ""
}

func (ptr *QTextDecoder) ToUnicode3(target string, chars string, l int) {
	if ptr.Pointer() != nil {
		var targetC *C.char
		if target != "" {
			targetC = C.CString(target)
			defer C.free(unsafe.Pointer(targetC))
		}
		var charsC *C.char
		if chars != "" {
			charsC = C.CString(chars)
			defer C.free(unsafe.Pointer(charsC))
		}
		C.QTextDecoder_ToUnicode3(ptr.Pointer(), C.struct_QtCore_PackedString{data: targetC, len: C.longlong(len(target))}, charsC, C.int(int32(l)))
	}
}

func (ptr *QTextDecoder) DestroyQTextDecoder() {
	if ptr.Pointer() != nil {
		C.QTextDecoder_DestroyQTextDecoder(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTextEncoder struct {
	ptr unsafe.Pointer
}

type QTextEncoder_ITF interface {
	QTextEncoder_PTR() *QTextEncoder
}

func (ptr *QTextEncoder) QTextEncoder_PTR() *QTextEncoder {
	return ptr
}

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

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

func PointerFromQTextEncoder(ptr QTextEncoder_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextEncoder_PTR().Pointer()
	}
	return nil
}

func NewQTextEncoderFromPointer(ptr unsafe.Pointer) (n *QTextEncoder) {
	n = new(QTextEncoder)
	n.SetPointer(ptr)
	return
}
func NewQTextEncoder2(codec QTextCodec_ITF) *QTextEncoder {
	tmpValue := NewQTextEncoderFromPointer(C.QTextEncoder_NewQTextEncoder2(PointerFromQTextCodec(codec)))
	runtime.SetFinalizer(tmpValue, (*QTextEncoder).DestroyQTextEncoder)
	return tmpValue
}

func NewQTextEncoder3(codec QTextCodec_ITF, flags QTextCodec__ConversionFlag) *QTextEncoder {
	tmpValue := NewQTextEncoderFromPointer(C.QTextEncoder_NewQTextEncoder3(PointerFromQTextCodec(codec), C.longlong(flags)))
	runtime.SetFinalizer(tmpValue, (*QTextEncoder).DestroyQTextEncoder)
	return tmpValue
}

func (ptr *QTextEncoder) FromUnicode(str string) *QByteArray {
	if ptr.Pointer() != nil {
		var strC *C.char
		if str != "" {
			strC = C.CString(str)
			defer C.free(unsafe.Pointer(strC))
		}
		tmpValue := NewQByteArrayFromPointer(C.QTextEncoder_FromUnicode(ptr.Pointer(), C.struct_QtCore_PackedString{data: strC, len: C.longlong(len(str))}))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEncoder) FromUnicode2(str QStringView_ITF) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTextEncoder_FromUnicode2(ptr.Pointer(), PointerFromQStringView(str)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEncoder) FromUnicode3(uc QChar_ITF, l int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTextEncoder_FromUnicode3(ptr.Pointer(), PointerFromQChar(uc), C.int(int32(l))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEncoder) DestroyQTextEncoder() {
	if ptr.Pointer() != nil {
		C.QTextEncoder_DestroyQTextEncoder(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTextStream struct {
	ptr unsafe.Pointer
}

type QTextStream_ITF interface {
	QTextStream_PTR() *QTextStream
}

func (ptr *QTextStream) QTextStream_PTR() *QTextStream {
	return ptr
}

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

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

func PointerFromQTextStream(ptr QTextStream_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextStream_PTR().Pointer()
	}
	return nil
}

func NewQTextStreamFromPointer(ptr unsafe.Pointer) (n *QTextStream) {
	n = new(QTextStream)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTextStream__RealNumberNotation
//QTextStream::RealNumberNotation
type QTextStream__RealNumberNotation int64

const (
	QTextStream__SmartNotation      QTextStream__RealNumberNotation = QTextStream__RealNumberNotation(0)
	QTextStream__FixedNotation      QTextStream__RealNumberNotation = QTextStream__RealNumberNotation(1)
	QTextStream__ScientificNotation QTextStream__RealNumberNotation = QTextStream__RealNumberNotation(2)
)

//go:generate stringer -type=QTextStream__FieldAlignment
//QTextStream::FieldAlignment
type QTextStream__FieldAlignment int64

const (
	QTextStream__AlignLeft            QTextStream__FieldAlignment = QTextStream__FieldAlignment(0)
	QTextStream__AlignRight           QTextStream__FieldAlignment = QTextStream__FieldAlignment(1)
	QTextStream__AlignCenter          QTextStream__FieldAlignment = QTextStream__FieldAlignment(2)
	QTextStream__AlignAccountingStyle QTextStream__FieldAlignment = QTextStream__FieldAlignment(3)
)

//go:generate stringer -type=QTextStream__Status
//QTextStream::Status
type QTextStream__Status int64

const (
	QTextStream__Ok              QTextStream__Status = QTextStream__Status(0)
	QTextStream__ReadPastEnd     QTextStream__Status = QTextStream__Status(1)
	QTextStream__ReadCorruptData QTextStream__Status = QTextStream__Status(2)
	QTextStream__WriteFailed     QTextStream__Status = QTextStream__Status(3)
)

//go:generate stringer -type=QTextStream__NumberFlag
//QTextStream::NumberFlag
type QTextStream__NumberFlag int64

const (
	QTextStream__ShowBase        QTextStream__NumberFlag = QTextStream__NumberFlag(0x1)
	QTextStream__ForcePoint      QTextStream__NumberFlag = QTextStream__NumberFlag(0x2)
	QTextStream__ForceSign       QTextStream__NumberFlag = QTextStream__NumberFlag(0x4)
	QTextStream__UppercaseBase   QTextStream__NumberFlag = QTextStream__NumberFlag(0x8)
	QTextStream__UppercaseDigits QTextStream__NumberFlag = QTextStream__NumberFlag(0x10)
)

func NewQTextStream() *QTextStream {
	tmpValue := NewQTextStreamFromPointer(C.QTextStream_NewQTextStream())
	runtime.SetFinalizer(tmpValue, (*QTextStream).DestroyQTextStream)
	return tmpValue
}

func NewQTextStream2(device QIODevice_ITF) *QTextStream {
	tmpValue := NewQTextStreamFromPointer(C.QTextStream_NewQTextStream2(PointerFromQIODevice(device)))
	runtime.SetFinalizer(tmpValue, (*QTextStream).DestroyQTextStream)
	return tmpValue
}

func NewQTextStream4(stri string, openMode QIODevice__OpenModeFlag) *QTextStream {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQTextStreamFromPointer(C.QTextStream_NewQTextStream4(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(openMode)))
	runtime.SetFinalizer(tmpValue, (*QTextStream).DestroyQTextStream)
	return tmpValue
}

func NewQTextStream5(array QByteArray_ITF, openMode QIODevice__OpenModeFlag) *QTextStream {
	tmpValue := NewQTextStreamFromPointer(C.QTextStream_NewQTextStream5(PointerFromQByteArray(array), C.longlong(openMode)))
	runtime.SetFinalizer(tmpValue, (*QTextStream).DestroyQTextStream)
	return tmpValue
}

func NewQTextStream6(array QByteArray_ITF, openMode QIODevice__OpenModeFlag) *QTextStream {
	tmpValue := NewQTextStreamFromPointer(C.QTextStream_NewQTextStream6(PointerFromQByteArray(array), C.longlong(openMode)))
	runtime.SetFinalizer(tmpValue, (*QTextStream).DestroyQTextStream)
	return tmpValue
}

func (ptr *QTextStream) AtEnd() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextStream_AtEnd(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextStream) AutoDetectUnicode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextStream_AutoDetectUnicode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextStream) Codec() *QTextCodec {
	if ptr.Pointer() != nil {
		return NewQTextCodecFromPointer(C.QTextStream_Codec(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextStream) Device() *QIODevice {
	if ptr.Pointer() != nil {
		tmpValue := NewQIODeviceFromPointer(C.QTextStream_Device(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTextStream) FieldAlignment() QTextStream__FieldAlignment {
	if ptr.Pointer() != nil {
		return QTextStream__FieldAlignment(C.QTextStream_FieldAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) FieldWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextStream_FieldWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextStream) Flush() {
	if ptr.Pointer() != nil {
		C.QTextStream_Flush(ptr.Pointer())
	}
}

func (ptr *QTextStream) GenerateByteOrderMark() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextStream_GenerateByteOrderMark(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextStream) IntegerBase() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextStream_IntegerBase(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextStream) Locale() *QLocale {
	if ptr.Pointer() != nil {
		tmpValue := NewQLocaleFromPointer(C.QTextStream_Locale(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
		return tmpValue
	}
	return nil
}

func (ptr *QTextStream) NumberFlags() QTextStream__NumberFlag {
	if ptr.Pointer() != nil {
		return QTextStream__NumberFlag(C.QTextStream_NumberFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) PadChar() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QTextStream_PadChar(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QTextStream) Pos() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QTextStream_Pos(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) Read(maxlen int64) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextStream_Read(ptr.Pointer(), C.longlong(maxlen)))
	}
	return ""
}

func (ptr *QTextStream) ReadAll() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextStream_ReadAll(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextStream) ReadLine(maxlen int64) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextStream_ReadLine(ptr.Pointer(), C.longlong(maxlen)))
	}
	return ""
}

func (ptr *QTextStream) ReadLineInto(line string, maxlen int64) bool {
	if ptr.Pointer() != nil {
		var lineC *C.char
		if line != "" {
			lineC = C.CString(line)
			defer C.free(unsafe.Pointer(lineC))
		}
		return int8(C.QTextStream_ReadLineInto(ptr.Pointer(), C.struct_QtCore_PackedString{data: lineC, len: C.longlong(len(line))}, C.longlong(maxlen))) != 0
	}
	return false
}

func (ptr *QTextStream) RealNumberNotation() QTextStream__RealNumberNotation {
	if ptr.Pointer() != nil {
		return QTextStream__RealNumberNotation(C.QTextStream_RealNumberNotation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) RealNumberPrecision() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextStream_RealNumberPrecision(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextStream) Reset() {
	if ptr.Pointer() != nil {
		C.QTextStream_Reset(ptr.Pointer())
	}
}

func (ptr *QTextStream) ResetStatus() {
	if ptr.Pointer() != nil {
		C.QTextStream_ResetStatus(ptr.Pointer())
	}
}

func (ptr *QTextStream) Seek(pos int64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextStream_Seek(ptr.Pointer(), C.longlong(pos))) != 0
	}
	return false
}

func (ptr *QTextStream) SetAutoDetectUnicode(enabled bool) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetAutoDetectUnicode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QTextStream) SetCodec(codec QTextCodec_ITF) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetCodec(ptr.Pointer(), PointerFromQTextCodec(codec))
	}
}

func (ptr *QTextStream) SetCodec2(codecName string) {
	if ptr.Pointer() != nil {
		var codecNameC *C.char
		if codecName != "" {
			codecNameC = C.CString(codecName)
			defer C.free(unsafe.Pointer(codecNameC))
		}
		C.QTextStream_SetCodec2(ptr.Pointer(), codecNameC)
	}
}

func (ptr *QTextStream) SetDevice(device QIODevice_ITF) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetDevice(ptr.Pointer(), PointerFromQIODevice(device))
	}
}

func (ptr *QTextStream) SetFieldAlignment(mode QTextStream__FieldAlignment) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetFieldAlignment(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QTextStream) SetFieldWidth(width int) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetFieldWidth(ptr.Pointer(), C.int(int32(width)))
	}
}

func (ptr *QTextStream) SetGenerateByteOrderMark(generate bool) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetGenerateByteOrderMark(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(generate))))
	}
}

func (ptr *QTextStream) SetIntegerBase(base int) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetIntegerBase(ptr.Pointer(), C.int(int32(base)))
	}
}

func (ptr *QTextStream) SetLocale(locale QLocale_ITF) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetLocale(ptr.Pointer(), PointerFromQLocale(locale))
	}
}

func (ptr *QTextStream) SetNumberFlags(flags QTextStream__NumberFlag) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetNumberFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QTextStream) SetPadChar(ch QChar_ITF) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetPadChar(ptr.Pointer(), PointerFromQChar(ch))
	}
}

func (ptr *QTextStream) SetRealNumberNotation(notation QTextStream__RealNumberNotation) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetRealNumberNotation(ptr.Pointer(), C.longlong(notation))
	}
}

func (ptr *QTextStream) SetRealNumberPrecision(precision int) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetRealNumberPrecision(ptr.Pointer(), C.int(int32(precision)))
	}
}

func (ptr *QTextStream) SetStatus(status QTextStream__Status) {
	if ptr.Pointer() != nil {
		C.QTextStream_SetStatus(ptr.Pointer(), C.longlong(status))
	}
}

func (ptr *QTextStream) SetString(stri string, openMode QIODevice__OpenModeFlag) {
	if ptr.Pointer() != nil {
		var striC *C.char
		if stri != "" {
			striC = C.CString(stri)
			defer C.free(unsafe.Pointer(striC))
		}
		C.QTextStream_SetString(ptr.Pointer(), C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(openMode))
	}
}

func (ptr *QTextStream) SkipWhiteSpace() {
	if ptr.Pointer() != nil {
		C.QTextStream_SkipWhiteSpace(ptr.Pointer())
	}
}

func (ptr *QTextStream) Status() QTextStream__Status {
	if ptr.Pointer() != nil {
		return QTextStream__Status(C.QTextStream_Status(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) String() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextStream_String(ptr.Pointer()))
	}
	return ""
}

//export callbackQTextStream_DestroyQTextStream
func callbackQTextStream_DestroyQTextStream(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTextStream"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextStreamFromPointer(ptr).DestroyQTextStreamDefault()
	}
}

func (ptr *QTextStream) ConnectDestroyQTextStream(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTextStream"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTextStream", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTextStream", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextStream) DisconnectDestroyQTextStream() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTextStream")
	}
}

func (ptr *QTextStream) DestroyQTextStream() {
	if ptr.Pointer() != nil {
		C.QTextStream_DestroyQTextStream(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTextStream) DestroyQTextStreamDefault() {
	if ptr.Pointer() != nil {
		C.QTextStream_DestroyQTextStreamDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTextStreamManipulator struct {
	ptr unsafe.Pointer
}

type QTextStreamManipulator_ITF interface {
	QTextStreamManipulator_PTR() *QTextStreamManipulator
}

func (ptr *QTextStreamManipulator) QTextStreamManipulator_PTR() *QTextStreamManipulator {
	return ptr
}

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

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

func PointerFromQTextStreamManipulator(ptr QTextStreamManipulator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextStreamManipulator_PTR().Pointer()
	}
	return nil
}

func NewQTextStreamManipulatorFromPointer(ptr unsafe.Pointer) (n *QTextStreamManipulator) {
	n = new(QTextStreamManipulator)
	n.SetPointer(ptr)
	return
}

func (ptr *QTextStreamManipulator) DestroyQTextStreamManipulator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QThread struct {
	QObject
}

type QThread_ITF interface {
	QObject_ITF
	QThread_PTR() *QThread
}

func (ptr *QThread) QThread_PTR() *QThread {
	return ptr
}

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

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

func PointerFromQThread(ptr QThread_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QThread_PTR().Pointer()
	}
	return nil
}

func NewQThreadFromPointer(ptr unsafe.Pointer) (n *QThread) {
	n = new(QThread)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QThread__Priority
//QThread::Priority
type QThread__Priority int64

const (
	QThread__IdlePriority         QThread__Priority = QThread__Priority(0)
	QThread__LowestPriority       QThread__Priority = QThread__Priority(1)
	QThread__LowPriority          QThread__Priority = QThread__Priority(2)
	QThread__NormalPriority       QThread__Priority = QThread__Priority(3)
	QThread__HighPriority         QThread__Priority = QThread__Priority(4)
	QThread__HighestPriority      QThread__Priority = QThread__Priority(5)
	QThread__TimeCriticalPriority QThread__Priority = QThread__Priority(6)
	QThread__InheritPriority      QThread__Priority = QThread__Priority(7)
)

func NewQThread(parent QObject_ITF) *QThread {
	tmpValue := NewQThreadFromPointer(C.QThread_NewQThread(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QThread_CurrentThread() *QThread {
	tmpValue := NewQThreadFromPointer(C.QThread_QThread_CurrentThread())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QThread) CurrentThread() *QThread {
	tmpValue := NewQThreadFromPointer(C.QThread_QThread_CurrentThread())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QThread) EventDispatcher() *QAbstractEventDispatcher {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractEventDispatcherFromPointer(C.QThread_EventDispatcher(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QThread) Exec() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QThread_Exec(ptr.Pointer())))
	}
	return 0
}

func (ptr *QThread) Exit(returnCode int) {
	if ptr.Pointer() != nil {
		C.QThread_Exit(ptr.Pointer(), C.int(int32(returnCode)))
	}
}

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

}

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

		if !qt.ExistsSignal(ptr.Pointer(), "finished") {
			C.QThread_ConnectFinished(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "finished")))
		}

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

func (ptr *QThread) DisconnectFinished() {
	if ptr.Pointer() != nil {
		C.QThread_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "finished")
	}
}

func QThread_IdealThreadCount() int {
	return int(int32(C.QThread_QThread_IdealThreadCount()))
}

func (ptr *QThread) IdealThreadCount() int {
	return int(int32(C.QThread_QThread_IdealThreadCount()))
}

func (ptr *QThread) IsFinished() bool {
	if ptr.Pointer() != nil {
		return int8(C.QThread_IsFinished(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QThread) IsInterruptionRequested() bool {
	if ptr.Pointer() != nil {
		return int8(C.QThread_IsInterruptionRequested(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QThread) IsRunning() bool {
	if ptr.Pointer() != nil {
		return int8(C.QThread_IsRunning(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QThread) LoopLevel() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QThread_LoopLevel(ptr.Pointer())))
	}
	return 0
}

func QThread_Msleep(msecs uint) {
	C.QThread_QThread_Msleep(C.ulong(uint32(msecs)))
}

func (ptr *QThread) Msleep(msecs uint) {
	C.QThread_QThread_Msleep(C.ulong(uint32(msecs)))
}

func (ptr *QThread) Priority() QThread__Priority {
	if ptr.Pointer() != nil {
		return QThread__Priority(C.QThread_Priority(ptr.Pointer()))
	}
	return 0
}

//export callbackQThread_Quit
func callbackQThread_Quit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "quit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQThreadFromPointer(ptr).QuitDefault()
	}
}

func (ptr *QThread) ConnectQuit(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "quit"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "quit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "quit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QThread) DisconnectQuit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "quit")
	}
}

func (ptr *QThread) Quit() {
	if ptr.Pointer() != nil {
		C.QThread_Quit(ptr.Pointer())
	}
}

func (ptr *QThread) QuitDefault() {
	if ptr.Pointer() != nil {
		C.QThread_QuitDefault(ptr.Pointer())
	}
}

func (ptr *QThread) RequestInterruption() {
	if ptr.Pointer() != nil {
		C.QThread_RequestInterruption(ptr.Pointer())
	}
}

//export callbackQThread_Run
func callbackQThread_Run(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "run"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQThreadFromPointer(ptr).RunDefault()
	}
}

func (ptr *QThread) ConnectRun(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "run"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "run", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "run", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QThread) DisconnectRun() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "run")
	}
}

func (ptr *QThread) Run() {
	if ptr.Pointer() != nil {
		C.QThread_Run(ptr.Pointer())
	}
}

func (ptr *QThread) RunDefault() {
	if ptr.Pointer() != nil {
		C.QThread_RunDefault(ptr.Pointer())
	}
}

func (ptr *QThread) SetEventDispatcher(eventDispatcher QAbstractEventDispatcher_ITF) {
	if ptr.Pointer() != nil {
		C.QThread_SetEventDispatcher(ptr.Pointer(), PointerFromQAbstractEventDispatcher(eventDispatcher))
	}
}

func (ptr *QThread) SetPriority(priority QThread__Priority) {
	if ptr.Pointer() != nil {
		C.QThread_SetPriority(ptr.Pointer(), C.longlong(priority))
	}
}

func (ptr *QThread) SetStackSize(stackSize uint) {
	if ptr.Pointer() != nil {
		C.QThread_SetStackSize(ptr.Pointer(), C.uint(uint32(stackSize)))
	}
}

func QThread_SetTerminationEnabled(enabled bool) {
	C.QThread_QThread_SetTerminationEnabled(C.char(int8(qt.GoBoolToInt(enabled))))
}

func (ptr *QThread) SetTerminationEnabled(enabled bool) {
	C.QThread_QThread_SetTerminationEnabled(C.char(int8(qt.GoBoolToInt(enabled))))
}

func QThread_Sleep(secs uint) {
	C.QThread_QThread_Sleep(C.ulong(uint32(secs)))
}

func (ptr *QThread) Sleep(secs uint) {
	C.QThread_QThread_Sleep(C.ulong(uint32(secs)))
}

func (ptr *QThread) StackSize() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QThread_StackSize(ptr.Pointer())))
	}
	return 0
}

//export callbackQThread_Start
func callbackQThread_Start(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "start"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQThreadFromPointer(ptr).StartDefault()
	}
}

func (ptr *QThread) ConnectStart(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QThread) DisconnectStart() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "start")
	}
}

func (ptr *QThread) Start() {
	if ptr.Pointer() != nil {
		C.QThread_Start(ptr.Pointer())
	}
}

func (ptr *QThread) StartDefault() {
	if ptr.Pointer() != nil {
		C.QThread_StartDefault(ptr.Pointer())
	}
}

//export callbackQThread_Started
func callbackQThread_Started(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "started"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QThread) ConnectStarted(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "started") {
			C.QThread_ConnectStarted(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "started")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "started"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "started", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "started", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QThread) DisconnectStarted() {
	if ptr.Pointer() != nil {
		C.QThread_DisconnectStarted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "started")
	}
}

//export callbackQThread_Terminate
func callbackQThread_Terminate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "terminate"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQThreadFromPointer(ptr).TerminateDefault()
	}
}

func (ptr *QThread) ConnectTerminate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "terminate"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "terminate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "terminate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QThread) DisconnectTerminate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "terminate")
	}
}

func (ptr *QThread) Terminate() {
	if ptr.Pointer() != nil {
		C.QThread_Terminate(ptr.Pointer())
	}
}

func (ptr *QThread) TerminateDefault() {
	if ptr.Pointer() != nil {
		C.QThread_TerminateDefault(ptr.Pointer())
	}
}

func QThread_Usleep(usecs uint) {
	C.QThread_QThread_Usleep(C.ulong(uint32(usecs)))
}

func (ptr *QThread) Usleep(usecs uint) {
	C.QThread_QThread_Usleep(C.ulong(uint32(usecs)))
}

func (ptr *QThread) Wait(ti uint) bool {
	if ptr.Pointer() != nil {
		return int8(C.QThread_Wait(ptr.Pointer(), C.ulong(uint32(ti)))) != 0
	}
	return false
}

func QThread_YieldCurrentThread() {
	C.QThread_QThread_YieldCurrentThread()
}

func (ptr *QThread) YieldCurrentThread() {
	C.QThread_QThread_YieldCurrentThread()
}

//export callbackQThread_DestroyQThread
func callbackQThread_DestroyQThread(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QThread"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQThreadFromPointer(ptr).DestroyQThreadDefault()
	}
}

func (ptr *QThread) ConnectDestroyQThread(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QThread"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QThread", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QThread", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QThread) DisconnectDestroyQThread() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QThread")
	}
}

func (ptr *QThread) DestroyQThread() {
	if ptr.Pointer() != nil {
		C.QThread_DestroyQThread(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QThread) DestroyQThreadDefault() {
	if ptr.Pointer() != nil {
		C.QThread_DestroyQThreadDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QThreadPool struct {
	QObject
}

type QThreadPool_ITF interface {
	QObject_ITF
	QThreadPool_PTR() *QThreadPool
}

func (ptr *QThreadPool) QThreadPool_PTR() *QThreadPool {
	return ptr
}

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

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

func PointerFromQThreadPool(ptr QThreadPool_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QThreadPool_PTR().Pointer()
	}
	return nil
}

func NewQThreadPoolFromPointer(ptr unsafe.Pointer) (n *QThreadPool) {
	n = new(QThreadPool)
	n.SetPointer(ptr)
	return
}
func NewQThreadPool(parent QObject_ITF) *QThreadPool {
	tmpValue := NewQThreadPoolFromPointer(C.QThreadPool_NewQThreadPool(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QThreadPool) ActiveThreadCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QThreadPool_ActiveThreadCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QThreadPool) Clear() {
	if ptr.Pointer() != nil {
		C.QThreadPool_Clear(ptr.Pointer())
	}
}

func (ptr *QThreadPool) ExpiryTimeout() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QThreadPool_ExpiryTimeout(ptr.Pointer())))
	}
	return 0
}

func QThreadPool_GlobalInstance() *QThreadPool {
	tmpValue := NewQThreadPoolFromPointer(C.QThreadPool_QThreadPool_GlobalInstance())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QThreadPool) GlobalInstance() *QThreadPool {
	tmpValue := NewQThreadPoolFromPointer(C.QThreadPool_QThreadPool_GlobalInstance())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QThreadPool) MaxThreadCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QThreadPool_MaxThreadCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QThreadPool) ReleaseThread() {
	if ptr.Pointer() != nil {
		C.QThreadPool_ReleaseThread(ptr.Pointer())
	}
}

func (ptr *QThreadPool) ReserveThread() {
	if ptr.Pointer() != nil {
		C.QThreadPool_ReserveThread(ptr.Pointer())
	}
}

func (ptr *QThreadPool) SetExpiryTimeout(expiryTimeout int) {
	if ptr.Pointer() != nil {
		C.QThreadPool_SetExpiryTimeout(ptr.Pointer(), C.int(int32(expiryTimeout)))
	}
}

func (ptr *QThreadPool) SetMaxThreadCount(maxThreadCount int) {
	if ptr.Pointer() != nil {
		C.QThreadPool_SetMaxThreadCount(ptr.Pointer(), C.int(int32(maxThreadCount)))
	}
}

func (ptr *QThreadPool) SetStackSize(stackSize uint) {
	if ptr.Pointer() != nil {
		C.QThreadPool_SetStackSize(ptr.Pointer(), C.uint(uint32(stackSize)))
	}
}

func (ptr *QThreadPool) StackSize() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QThreadPool_StackSize(ptr.Pointer())))
	}
	return 0
}

func (ptr *QThreadPool) Start(runnable QRunnable_ITF, priority int) {
	if ptr.Pointer() != nil {
		C.QThreadPool_Start(ptr.Pointer(), PointerFromQRunnable(runnable), C.int(int32(priority)))
	}
}

func (ptr *QThreadPool) TryStart(runnable QRunnable_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QThreadPool_TryStart(ptr.Pointer(), PointerFromQRunnable(runnable))) != 0
	}
	return false
}

func (ptr *QThreadPool) TryTake(runnable QRunnable_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QThreadPool_TryTake(ptr.Pointer(), PointerFromQRunnable(runnable))) != 0
	}
	return false
}

func (ptr *QThreadPool) WaitForDone(msecs int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QThreadPool_WaitForDone(ptr.Pointer(), C.int(int32(msecs)))) != 0
	}
	return false
}

//export callbackQThreadPool_DestroyQThreadPool
func callbackQThreadPool_DestroyQThreadPool(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QThreadPool"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQThreadPoolFromPointer(ptr).DestroyQThreadPoolDefault()
	}
}

func (ptr *QThreadPool) ConnectDestroyQThreadPool(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QThreadPool"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QThreadPool", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QThreadPool", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QThreadPool) DisconnectDestroyQThreadPool() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QThreadPool")
	}
}

func (ptr *QThreadPool) DestroyQThreadPool() {
	if ptr.Pointer() != nil {
		C.QThreadPool_DestroyQThreadPool(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QThreadPool) DestroyQThreadPoolDefault() {
	if ptr.Pointer() != nil {
		C.QThreadPool_DestroyQThreadPoolDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QThreadStorage struct {
	ptr unsafe.Pointer
}

type QThreadStorage_ITF interface {
	QThreadStorage_PTR() *QThreadStorage
}

func (ptr *QThreadStorage) QThreadStorage_PTR() *QThreadStorage {
	return ptr
}

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

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

func PointerFromQThreadStorage(ptr QThreadStorage_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QThreadStorage_PTR().Pointer()
	}
	return nil
}

func NewQThreadStorageFromPointer(ptr unsafe.Pointer) (n *QThreadStorage) {
	n = new(QThreadStorage)
	n.SetPointer(ptr)
	return
}

type QThreadStorageData struct {
	ptr unsafe.Pointer
}

type QThreadStorageData_ITF interface {
	QThreadStorageData_PTR() *QThreadStorageData
}

func (ptr *QThreadStorageData) QThreadStorageData_PTR() *QThreadStorageData {
	return ptr
}

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

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

func PointerFromQThreadStorageData(ptr QThreadStorageData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QThreadStorageData_PTR().Pointer()
	}
	return nil
}

func NewQThreadStorageDataFromPointer(ptr unsafe.Pointer) (n *QThreadStorageData) {
	n = new(QThreadStorageData)
	n.SetPointer(ptr)
	return
}

func (ptr *QThreadStorageData) DestroyQThreadStorageData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTime struct {
	ptr unsafe.Pointer
}

type QTime_ITF interface {
	QTime_PTR() *QTime
}

func (ptr *QTime) QTime_PTR() *QTime {
	return ptr
}

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

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

func PointerFromQTime(ptr QTime_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTime_PTR().Pointer()
	}
	return nil
}

func NewQTimeFromPointer(ptr unsafe.Pointer) (n *QTime) {
	n = new(QTime)
	n.SetPointer(ptr)
	return
}

func (ptr *QTime) DestroyQTime() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQTime2() *QTime {
	tmpValue := NewQTimeFromPointer(C.QTime_NewQTime2())
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func NewQTime3(h int, m int, s int, ms int) *QTime {
	tmpValue := NewQTimeFromPointer(C.QTime_NewQTime3(C.int(int32(h)), C.int(int32(m)), C.int(int32(s)), C.int(int32(ms))))
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func (ptr *QTime) AddMSecs(ms int) *QTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQTimeFromPointer(C.QTime_AddMSecs(ptr.Pointer(), C.int(int32(ms))))
		runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
		return tmpValue
	}
	return nil
}

func (ptr *QTime) AddSecs(s int) *QTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQTimeFromPointer(C.QTime_AddSecs(ptr.Pointer(), C.int(int32(s))))
		runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
		return tmpValue
	}
	return nil
}

func QTime_CurrentTime() *QTime {
	tmpValue := NewQTimeFromPointer(C.QTime_QTime_CurrentTime())
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func (ptr *QTime) CurrentTime() *QTime {
	tmpValue := NewQTimeFromPointer(C.QTime_QTime_CurrentTime())
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func (ptr *QTime) Elapsed() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTime_Elapsed(ptr.Pointer())))
	}
	return 0
}

func QTime_FromMSecsSinceStartOfDay(msecs int) *QTime {
	tmpValue := NewQTimeFromPointer(C.QTime_QTime_FromMSecsSinceStartOfDay(C.int(int32(msecs))))
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func (ptr *QTime) FromMSecsSinceStartOfDay(msecs int) *QTime {
	tmpValue := NewQTimeFromPointer(C.QTime_QTime_FromMSecsSinceStartOfDay(C.int(int32(msecs))))
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func QTime_FromString(stri string, format Qt__DateFormat) *QTime {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQTimeFromPointer(C.QTime_QTime_FromString(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(format)))
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func (ptr *QTime) FromString(stri string, format Qt__DateFormat) *QTime {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQTimeFromPointer(C.QTime_QTime_FromString(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.longlong(format)))
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func QTime_FromString2(stri string, format string) *QTime {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	var formatC *C.char
	if format != "" {
		formatC = C.CString(format)
		defer C.free(unsafe.Pointer(formatC))
	}
	tmpValue := NewQTimeFromPointer(C.QTime_QTime_FromString2(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func (ptr *QTime) FromString2(stri string, format string) *QTime {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	var formatC *C.char
	if format != "" {
		formatC = C.CString(format)
		defer C.free(unsafe.Pointer(formatC))
	}
	tmpValue := NewQTimeFromPointer(C.QTime_QTime_FromString2(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
	return tmpValue
}

func (ptr *QTime) Hour() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTime_Hour(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTime) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTime_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTime) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTime_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func QTime_IsValid2(h int, m int, s int, ms int) bool {
	return int8(C.QTime_QTime_IsValid2(C.int(int32(h)), C.int(int32(m)), C.int(int32(s)), C.int(int32(ms)))) != 0
}

func (ptr *QTime) IsValid2(h int, m int, s int, ms int) bool {
	return int8(C.QTime_QTime_IsValid2(C.int(int32(h)), C.int(int32(m)), C.int(int32(s)), C.int(int32(ms)))) != 0
}

func (ptr *QTime) Minute() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTime_Minute(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTime) Msec() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTime_Msec(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTime) MsecsSinceStartOfDay() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTime_MsecsSinceStartOfDay(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTime) MsecsTo(t QTime_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTime_MsecsTo(ptr.Pointer(), PointerFromQTime(t))))
	}
	return 0
}

func (ptr *QTime) Restart() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTime_Restart(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTime) Second() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTime_Second(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTime) SecsTo(t QTime_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTime_SecsTo(ptr.Pointer(), PointerFromQTime(t))))
	}
	return 0
}

func (ptr *QTime) SetHMS(h int, m int, s int, ms int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTime_SetHMS(ptr.Pointer(), C.int(int32(h)), C.int(int32(m)), C.int(int32(s)), C.int(int32(ms)))) != 0
	}
	return false
}

func (ptr *QTime) Start() {
	if ptr.Pointer() != nil {
		C.QTime_Start(ptr.Pointer())
	}
}

func (ptr *QTime) ToString(format string) string {
	if ptr.Pointer() != nil {
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		return cGoUnpackString(C.QTime_ToString(ptr.Pointer(), C.struct_QtCore_PackedString{data: formatC, len: C.longlong(len(format))}))
	}
	return ""
}

func (ptr *QTime) ToString2(format Qt__DateFormat) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTime_ToString2(ptr.Pointer(), C.longlong(format)))
	}
	return ""
}

func (ptr *QTime) ToString3(format QStringView_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTime_ToString3(ptr.Pointer(), PointerFromQStringView(format)))
	}
	return ""
}

type QTimeLine struct {
	QObject
}

type QTimeLine_ITF interface {
	QObject_ITF
	QTimeLine_PTR() *QTimeLine
}

func (ptr *QTimeLine) QTimeLine_PTR() *QTimeLine {
	return ptr
}

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

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

func PointerFromQTimeLine(ptr QTimeLine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTimeLine_PTR().Pointer()
	}
	return nil
}

func NewQTimeLineFromPointer(ptr unsafe.Pointer) (n *QTimeLine) {
	n = new(QTimeLine)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTimeLine__State
//QTimeLine::State
type QTimeLine__State int64

const (
	QTimeLine__NotRunning QTimeLine__State = QTimeLine__State(0)
	QTimeLine__Paused     QTimeLine__State = QTimeLine__State(1)
	QTimeLine__Running    QTimeLine__State = QTimeLine__State(2)
)

//go:generate stringer -type=QTimeLine__Direction
//QTimeLine::Direction
type QTimeLine__Direction int64

const (
	QTimeLine__Forward  QTimeLine__Direction = QTimeLine__Direction(0)
	QTimeLine__Backward QTimeLine__Direction = QTimeLine__Direction(1)
)

//go:generate stringer -type=QTimeLine__CurveShape
//QTimeLine::CurveShape
type QTimeLine__CurveShape int64

const (
	QTimeLine__EaseInCurve    QTimeLine__CurveShape = QTimeLine__CurveShape(0)
	QTimeLine__EaseOutCurve   QTimeLine__CurveShape = QTimeLine__CurveShape(1)
	QTimeLine__EaseInOutCurve QTimeLine__CurveShape = QTimeLine__CurveShape(2)
	QTimeLine__LinearCurve    QTimeLine__CurveShape = QTimeLine__CurveShape(3)
	QTimeLine__SineCurve      QTimeLine__CurveShape = QTimeLine__CurveShape(4)
	QTimeLine__CosineCurve    QTimeLine__CurveShape = QTimeLine__CurveShape(5)
)

func NewQTimeLine(duration int, parent QObject_ITF) *QTimeLine {
	tmpValue := NewQTimeLineFromPointer(C.QTimeLine_NewQTimeLine(C.int(int32(duration)), PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTimeLine) CurrentFrame() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeLine_CurrentFrame(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTimeLine) CurrentTime() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeLine_CurrentTime(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTimeLine) CurrentValue() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QTimeLine_CurrentValue(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) CurveShape() QTimeLine__CurveShape {
	if ptr.Pointer() != nil {
		return QTimeLine__CurveShape(C.QTimeLine_CurveShape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) Direction() QTimeLine__Direction {
	if ptr.Pointer() != nil {
		return QTimeLine__Direction(C.QTimeLine_Direction(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) Duration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeLine_Duration(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTimeLine) EasingCurve() *QEasingCurve {
	if ptr.Pointer() != nil {
		tmpValue := NewQEasingCurveFromPointer(C.QTimeLine_EasingCurve(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QEasingCurve).DestroyQEasingCurve)
		return tmpValue
	}
	return nil
}

func (ptr *QTimeLine) EndFrame() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeLine_EndFrame(ptr.Pointer())))
	}
	return 0
}

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

}

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

		if !qt.ExistsSignal(ptr.Pointer(), "finished") {
			C.QTimeLine_ConnectFinished(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "finished")))
		}

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

func (ptr *QTimeLine) DisconnectFinished() {
	if ptr.Pointer() != nil {
		C.QTimeLine_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "finished")
	}
}

//export callbackQTimeLine_FrameChanged
func callbackQTimeLine_FrameChanged(ptr unsafe.Pointer, frame C.int) {
	if signal := qt.GetSignal(ptr, "frameChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(frame)))
	}

}

func (ptr *QTimeLine) ConnectFrameChanged(f func(frame int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "frameChanged") {
			C.QTimeLine_ConnectFrameChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "frameChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "frameChanged"); signal != nil {
			f := func(frame int) {
				(*(*func(int))(signal))(frame)
				f(frame)
			}
			qt.ConnectSignal(ptr.Pointer(), "frameChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "frameChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectFrameChanged() {
	if ptr.Pointer() != nil {
		C.QTimeLine_DisconnectFrameChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "frameChanged")
	}
}

func (ptr *QTimeLine) FrameForTime(msec int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeLine_FrameForTime(ptr.Pointer(), C.int(int32(msec)))))
	}
	return 0
}

func (ptr *QTimeLine) LoopCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeLine_LoopCount(ptr.Pointer())))
	}
	return 0
}

//export callbackQTimeLine_Resume
func callbackQTimeLine_Resume(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resume"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTimeLineFromPointer(ptr).ResumeDefault()
	}
}

func (ptr *QTimeLine) ConnectResume(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resume"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "resume", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resume", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectResume() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resume")
	}
}

func (ptr *QTimeLine) Resume() {
	if ptr.Pointer() != nil {
		C.QTimeLine_Resume(ptr.Pointer())
	}
}

func (ptr *QTimeLine) ResumeDefault() {
	if ptr.Pointer() != nil {
		C.QTimeLine_ResumeDefault(ptr.Pointer())
	}
}

//export callbackQTimeLine_SetCurrentTime
func callbackQTimeLine_SetCurrentTime(ptr unsafe.Pointer, msec C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentTime"); signal != nil {
		(*(*func(int))(signal))(int(int32(msec)))
	} else {
		NewQTimeLineFromPointer(ptr).SetCurrentTimeDefault(int(int32(msec)))
	}
}

func (ptr *QTimeLine) ConnectSetCurrentTime(f func(msec int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentTime"); signal != nil {
			f := func(msec int) {
				(*(*func(int))(signal))(msec)
				f(msec)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectSetCurrentTime() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentTime")
	}
}

func (ptr *QTimeLine) SetCurrentTime(msec int) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetCurrentTime(ptr.Pointer(), C.int(int32(msec)))
	}
}

func (ptr *QTimeLine) SetCurrentTimeDefault(msec int) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetCurrentTimeDefault(ptr.Pointer(), C.int(int32(msec)))
	}
}

func (ptr *QTimeLine) SetCurveShape(shape QTimeLine__CurveShape) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetCurveShape(ptr.Pointer(), C.longlong(shape))
	}
}

func (ptr *QTimeLine) SetDirection(direction QTimeLine__Direction) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetDirection(ptr.Pointer(), C.longlong(direction))
	}
}

func (ptr *QTimeLine) SetDuration(duration int) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetDuration(ptr.Pointer(), C.int(int32(duration)))
	}
}

func (ptr *QTimeLine) SetEasingCurve(curve QEasingCurve_ITF) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetEasingCurve(ptr.Pointer(), PointerFromQEasingCurve(curve))
	}
}

func (ptr *QTimeLine) SetEndFrame(frame int) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetEndFrame(ptr.Pointer(), C.int(int32(frame)))
	}
}

func (ptr *QTimeLine) SetFrameRange(startFrame int, endFrame int) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetFrameRange(ptr.Pointer(), C.int(int32(startFrame)), C.int(int32(endFrame)))
	}
}

func (ptr *QTimeLine) SetLoopCount(count int) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetLoopCount(ptr.Pointer(), C.int(int32(count)))
	}
}

//export callbackQTimeLine_SetPaused
func callbackQTimeLine_SetPaused(ptr unsafe.Pointer, paused C.char) {
	if signal := qt.GetSignal(ptr, "setPaused"); signal != nil {
		(*(*func(bool))(signal))(int8(paused) != 0)
	} else {
		NewQTimeLineFromPointer(ptr).SetPausedDefault(int8(paused) != 0)
	}
}

func (ptr *QTimeLine) ConnectSetPaused(f func(paused bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setPaused"); signal != nil {
			f := func(paused bool) {
				(*(*func(bool))(signal))(paused)
				f(paused)
			}
			qt.ConnectSignal(ptr.Pointer(), "setPaused", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setPaused", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectSetPaused() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setPaused")
	}
}

func (ptr *QTimeLine) SetPaused(paused bool) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetPaused(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(paused))))
	}
}

func (ptr *QTimeLine) SetPausedDefault(paused bool) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetPausedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(paused))))
	}
}

func (ptr *QTimeLine) SetStartFrame(frame int) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetStartFrame(ptr.Pointer(), C.int(int32(frame)))
	}
}

func (ptr *QTimeLine) SetUpdateInterval(interval int) {
	if ptr.Pointer() != nil {
		C.QTimeLine_SetUpdateInterval(ptr.Pointer(), C.int(int32(interval)))
	}
}

//export callbackQTimeLine_Start
func callbackQTimeLine_Start(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "start"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTimeLineFromPointer(ptr).StartDefault()
	}
}

func (ptr *QTimeLine) ConnectStart(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectStart() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "start")
	}
}

func (ptr *QTimeLine) Start() {
	if ptr.Pointer() != nil {
		C.QTimeLine_Start(ptr.Pointer())
	}
}

func (ptr *QTimeLine) StartDefault() {
	if ptr.Pointer() != nil {
		C.QTimeLine_StartDefault(ptr.Pointer())
	}
}

func (ptr *QTimeLine) StartFrame() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeLine_StartFrame(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTimeLine) State() QTimeLine__State {
	if ptr.Pointer() != nil {
		return QTimeLine__State(C.QTimeLine_State(ptr.Pointer()))
	}
	return 0
}

//export callbackQTimeLine_StateChanged
func callbackQTimeLine_StateChanged(ptr unsafe.Pointer, newState C.longlong) {
	if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
		(*(*func(QTimeLine__State))(signal))(QTimeLine__State(newState))
	}

}

func (ptr *QTimeLine) ConnectStateChanged(f func(newState QTimeLine__State)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
			C.QTimeLine_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
			f := func(newState QTimeLine__State) {
				(*(*func(QTimeLine__State))(signal))(newState)
				f(newState)
			}
			qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectStateChanged() {
	if ptr.Pointer() != nil {
		C.QTimeLine_DisconnectStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
	}
}

//export callbackQTimeLine_Stop
func callbackQTimeLine_Stop(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "stop"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTimeLineFromPointer(ptr).StopDefault()
	}
}

func (ptr *QTimeLine) ConnectStop(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectStop() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "stop")
	}
}

func (ptr *QTimeLine) Stop() {
	if ptr.Pointer() != nil {
		C.QTimeLine_Stop(ptr.Pointer())
	}
}

func (ptr *QTimeLine) StopDefault() {
	if ptr.Pointer() != nil {
		C.QTimeLine_StopDefault(ptr.Pointer())
	}
}

//export callbackQTimeLine_ToggleDirection
func callbackQTimeLine_ToggleDirection(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "toggleDirection"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTimeLineFromPointer(ptr).ToggleDirectionDefault()
	}
}

func (ptr *QTimeLine) ConnectToggleDirection(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "toggleDirection"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "toggleDirection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "toggleDirection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectToggleDirection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "toggleDirection")
	}
}

func (ptr *QTimeLine) ToggleDirection() {
	if ptr.Pointer() != nil {
		C.QTimeLine_ToggleDirection(ptr.Pointer())
	}
}

func (ptr *QTimeLine) ToggleDirectionDefault() {
	if ptr.Pointer() != nil {
		C.QTimeLine_ToggleDirectionDefault(ptr.Pointer())
	}
}

func (ptr *QTimeLine) UpdateInterval() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeLine_UpdateInterval(ptr.Pointer())))
	}
	return 0
}

//export callbackQTimeLine_ValueChanged
func callbackQTimeLine_ValueChanged(ptr unsafe.Pointer, value C.double) {
	if signal := qt.GetSignal(ptr, "valueChanged"); signal != nil {
		(*(*func(float64))(signal))(float64(value))
	}

}

func (ptr *QTimeLine) ConnectValueChanged(f func(value float64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "valueChanged") {
			C.QTimeLine_ConnectValueChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "valueChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "valueChanged"); signal != nil {
			f := func(value float64) {
				(*(*func(float64))(signal))(value)
				f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectValueChanged() {
	if ptr.Pointer() != nil {
		C.QTimeLine_DisconnectValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "valueChanged")
	}
}

//export callbackQTimeLine_ValueForTime
func callbackQTimeLine_ValueForTime(ptr unsafe.Pointer, msec C.int) C.double {
	if signal := qt.GetSignal(ptr, "valueForTime"); signal != nil {
		return C.double((*(*func(int) float64)(signal))(int(int32(msec))))
	}

	return C.double(NewQTimeLineFromPointer(ptr).ValueForTimeDefault(int(int32(msec))))
}

func (ptr *QTimeLine) ConnectValueForTime(f func(msec int) float64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "valueForTime"); signal != nil {
			f := func(msec int) float64 {
				(*(*func(int) float64)(signal))(msec)
				return f(msec)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueForTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueForTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectValueForTime() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "valueForTime")
	}
}

func (ptr *QTimeLine) ValueForTime(msec int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QTimeLine_ValueForTime(ptr.Pointer(), C.int(int32(msec))))
	}
	return 0
}

func (ptr *QTimeLine) ValueForTimeDefault(msec int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QTimeLine_ValueForTimeDefault(ptr.Pointer(), C.int(int32(msec))))
	}
	return 0
}

//export callbackQTimeLine_DestroyQTimeLine
func callbackQTimeLine_DestroyQTimeLine(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTimeLine"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTimeLineFromPointer(ptr).DestroyQTimeLineDefault()
	}
}

func (ptr *QTimeLine) ConnectDestroyQTimeLine(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTimeLine"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTimeLine", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTimeLine", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeLine) DisconnectDestroyQTimeLine() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTimeLine")
	}
}

func (ptr *QTimeLine) DestroyQTimeLine() {
	if ptr.Pointer() != nil {
		C.QTimeLine_DestroyQTimeLine(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTimeLine) DestroyQTimeLineDefault() {
	if ptr.Pointer() != nil {
		C.QTimeLine_DestroyQTimeLineDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTimeZone struct {
	ptr unsafe.Pointer
}

type QTimeZone_ITF interface {
	QTimeZone_PTR() *QTimeZone
}

func (ptr *QTimeZone) QTimeZone_PTR() *QTimeZone {
	return ptr
}

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

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

func PointerFromQTimeZone(ptr QTimeZone_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTimeZone_PTR().Pointer()
	}
	return nil
}

func NewQTimeZoneFromPointer(ptr unsafe.Pointer) (n *QTimeZone) {
	n = new(QTimeZone)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTimeZone__TimeType
//QTimeZone::TimeType
type QTimeZone__TimeType int64

const (
	QTimeZone__StandardTime QTimeZone__TimeType = QTimeZone__TimeType(0)
	QTimeZone__DaylightTime QTimeZone__TimeType = QTimeZone__TimeType(1)
	QTimeZone__GenericTime  QTimeZone__TimeType = QTimeZone__TimeType(2)
)

//go:generate stringer -type=QTimeZone__NameType
//QTimeZone::NameType
type QTimeZone__NameType int64

const (
	QTimeZone__DefaultName QTimeZone__NameType = QTimeZone__NameType(0)
	QTimeZone__LongName    QTimeZone__NameType = QTimeZone__NameType(1)
	QTimeZone__ShortName   QTimeZone__NameType = QTimeZone__NameType(2)
	QTimeZone__OffsetName  QTimeZone__NameType = QTimeZone__NameType(3)
)

func NewQTimeZone() *QTimeZone {
	tmpValue := NewQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone())
	runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
	return tmpValue
}

func NewQTimeZone2(ianaId QByteArray_ITF) *QTimeZone {
	tmpValue := NewQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone2(PointerFromQByteArray(ianaId)))
	runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
	return tmpValue
}

func NewQTimeZone3(offsetSeconds int) *QTimeZone {
	tmpValue := NewQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone3(C.int(int32(offsetSeconds))))
	runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
	return tmpValue
}

func NewQTimeZone4(ianaId QByteArray_ITF, offsetSeconds int, name string, abbreviation string, country QLocale__Country, comment string) *QTimeZone {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	var abbreviationC *C.char
	if abbreviation != "" {
		abbreviationC = C.CString(abbreviation)
		defer C.free(unsafe.Pointer(abbreviationC))
	}
	var commentC *C.char
	if comment != "" {
		commentC = C.CString(comment)
		defer C.free(unsafe.Pointer(commentC))
	}
	tmpValue := NewQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone4(PointerFromQByteArray(ianaId), C.int(int32(offsetSeconds)), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.struct_QtCore_PackedString{data: abbreviationC, len: C.longlong(len(abbreviation))}, C.longlong(country), C.struct_QtCore_PackedString{data: commentC, len: C.longlong(len(comment))}))
	runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
	return tmpValue
}

func NewQTimeZone5(other QTimeZone_ITF) *QTimeZone {
	tmpValue := NewQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone5(PointerFromQTimeZone(other)))
	runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
	return tmpValue
}

func (ptr *QTimeZone) Abbreviation(atDateTime QDateTime_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTimeZone_Abbreviation(ptr.Pointer(), PointerFromQDateTime(atDateTime)))
	}
	return ""
}

func QTimeZone_AvailableTimeZoneIds() []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableTimeZoneIds_atList(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_AvailableTimeZoneIds())
}

func (ptr *QTimeZone) AvailableTimeZoneIds() []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableTimeZoneIds_atList(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_AvailableTimeZoneIds())
}

func QTimeZone_AvailableTimeZoneIds2(country QLocale__Country) []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableTimeZoneIds_atList2(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_AvailableTimeZoneIds2(C.longlong(country)))
}

func (ptr *QTimeZone) AvailableTimeZoneIds2(country QLocale__Country) []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableTimeZoneIds_atList2(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_AvailableTimeZoneIds2(C.longlong(country)))
}

func QTimeZone_AvailableTimeZoneIds3(offsetSeconds int) []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableTimeZoneIds_atList3(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_AvailableTimeZoneIds3(C.int(int32(offsetSeconds))))
}

func (ptr *QTimeZone) AvailableTimeZoneIds3(offsetSeconds int) []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__availableTimeZoneIds_atList3(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_AvailableTimeZoneIds3(C.int(int32(offsetSeconds))))
}

func (ptr *QTimeZone) Comment() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTimeZone_Comment(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTimeZone) Country() QLocale__Country {
	if ptr.Pointer() != nil {
		return QLocale__Country(C.QTimeZone_Country(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeZone) DaylightTimeOffset(atDateTime QDateTime_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeZone_DaylightTimeOffset(ptr.Pointer(), PointerFromQDateTime(atDateTime))))
	}
	return 0
}

func (ptr *QTimeZone) DisplayName(atDateTime QDateTime_ITF, nameType QTimeZone__NameType, locale QLocale_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTimeZone_DisplayName(ptr.Pointer(), PointerFromQDateTime(atDateTime), C.longlong(nameType), PointerFromQLocale(locale)))
	}
	return ""
}

func (ptr *QTimeZone) DisplayName2(timeType QTimeZone__TimeType, nameType QTimeZone__NameType, locale QLocale_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTimeZone_DisplayName2(ptr.Pointer(), C.longlong(timeType), C.longlong(nameType), PointerFromQLocale(locale)))
	}
	return ""
}

func (ptr *QTimeZone) HasDaylightTime() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTimeZone_HasDaylightTime(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTimeZone) HasTransitions() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTimeZone_HasTransitions(ptr.Pointer())) != 0
	}
	return false
}

func QTimeZone_IanaIdToWindowsId(ianaId QByteArray_ITF) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QTimeZone_QTimeZone_IanaIdToWindowsId(PointerFromQByteArray(ianaId)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QTimeZone) IanaIdToWindowsId(ianaId QByteArray_ITF) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QTimeZone_QTimeZone_IanaIdToWindowsId(PointerFromQByteArray(ianaId)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QTimeZone) Id() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTimeZone_Id(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTimeZone) IsDaylightTime(atDateTime QDateTime_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTimeZone_IsDaylightTime(ptr.Pointer(), PointerFromQDateTime(atDateTime))) != 0
	}
	return false
}

func QTimeZone_IsTimeZoneIdAvailable(ianaId QByteArray_ITF) bool {
	return int8(C.QTimeZone_QTimeZone_IsTimeZoneIdAvailable(PointerFromQByteArray(ianaId))) != 0
}

func (ptr *QTimeZone) IsTimeZoneIdAvailable(ianaId QByteArray_ITF) bool {
	return int8(C.QTimeZone_QTimeZone_IsTimeZoneIdAvailable(PointerFromQByteArray(ianaId))) != 0
}

func (ptr *QTimeZone) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTimeZone_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTimeZone) OffsetFromUtc(atDateTime QDateTime_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeZone_OffsetFromUtc(ptr.Pointer(), PointerFromQDateTime(atDateTime))))
	}
	return 0
}

func (ptr *QTimeZone) StandardTimeOffset(atDateTime QDateTime_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimeZone_StandardTimeOffset(ptr.Pointer(), PointerFromQDateTime(atDateTime))))
	}
	return 0
}

func (ptr *QTimeZone) Swap(other QTimeZone_ITF) {
	if ptr.Pointer() != nil {
		C.QTimeZone_Swap(ptr.Pointer(), PointerFromQTimeZone(other))
	}
}

func QTimeZone_SystemTimeZone() *QTimeZone {
	tmpValue := NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_SystemTimeZone())
	runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
	return tmpValue
}

func (ptr *QTimeZone) SystemTimeZone() *QTimeZone {
	tmpValue := NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_SystemTimeZone())
	runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
	return tmpValue
}

func QTimeZone_SystemTimeZoneId() *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QTimeZone_QTimeZone_SystemTimeZoneId())
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QTimeZone) SystemTimeZoneId() *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QTimeZone_QTimeZone_SystemTimeZoneId())
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QTimeZone_Utc() *QTimeZone {
	tmpValue := NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_Utc())
	runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
	return tmpValue
}

func (ptr *QTimeZone) Utc() *QTimeZone {
	tmpValue := NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_Utc())
	runtime.SetFinalizer(tmpValue, (*QTimeZone).DestroyQTimeZone)
	return tmpValue
}

func QTimeZone_WindowsIdToDefaultIanaId(windowsId QByteArray_ITF) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId(PointerFromQByteArray(windowsId)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QTimeZone) WindowsIdToDefaultIanaId(windowsId QByteArray_ITF) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId(PointerFromQByteArray(windowsId)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QTimeZone_WindowsIdToDefaultIanaId2(windowsId QByteArray_ITF, country QLocale__Country) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId2(PointerFromQByteArray(windowsId), C.longlong(country)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QTimeZone) WindowsIdToDefaultIanaId2(windowsId QByteArray_ITF, country QLocale__Country) *QByteArray {
	tmpValue := NewQByteArrayFromPointer(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId2(PointerFromQByteArray(windowsId), C.longlong(country)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QTimeZone_WindowsIdToIanaIds(windowsId QByteArray_ITF) []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__windowsIdToIanaIds_atList(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_WindowsIdToIanaIds(PointerFromQByteArray(windowsId)))
}

func (ptr *QTimeZone) WindowsIdToIanaIds(windowsId QByteArray_ITF) []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__windowsIdToIanaIds_atList(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_WindowsIdToIanaIds(PointerFromQByteArray(windowsId)))
}

func QTimeZone_WindowsIdToIanaIds2(windowsId QByteArray_ITF, country QLocale__Country) []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__windowsIdToIanaIds_atList2(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_WindowsIdToIanaIds2(PointerFromQByteArray(windowsId), C.longlong(country)))
}

func (ptr *QTimeZone) WindowsIdToIanaIds2(windowsId QByteArray_ITF, country QLocale__Country) []*QByteArray {
	return func(l C.struct_QtCore_PackedList) []*QByteArray {
		out := make([]*QByteArray, int(l.len))
		tmpList := NewQTimeZoneFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__windowsIdToIanaIds_atList2(i)
		}
		return out
	}(C.QTimeZone_QTimeZone_WindowsIdToIanaIds2(PointerFromQByteArray(windowsId), C.longlong(country)))
}

func (ptr *QTimeZone) DestroyQTimeZone() {
	if ptr.Pointer() != nil {
		C.QTimeZone_DestroyQTimeZone(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTimeZone) __availableTimeZoneIds_atList(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTimeZone___availableTimeZoneIds_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTimeZone) __availableTimeZoneIds_setList(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QTimeZone___availableTimeZoneIds_setList(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QTimeZone) __availableTimeZoneIds_newList() unsafe.Pointer {
	return C.QTimeZone___availableTimeZoneIds_newList(ptr.Pointer())
}

func (ptr *QTimeZone) __availableTimeZoneIds_atList2(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTimeZone___availableTimeZoneIds_atList2(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTimeZone) __availableTimeZoneIds_setList2(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QTimeZone___availableTimeZoneIds_setList2(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QTimeZone) __availableTimeZoneIds_newList2() unsafe.Pointer {
	return C.QTimeZone___availableTimeZoneIds_newList2(ptr.Pointer())
}

func (ptr *QTimeZone) __availableTimeZoneIds_atList3(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTimeZone___availableTimeZoneIds_atList3(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTimeZone) __availableTimeZoneIds_setList3(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QTimeZone___availableTimeZoneIds_setList3(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QTimeZone) __availableTimeZoneIds_newList3() unsafe.Pointer {
	return C.QTimeZone___availableTimeZoneIds_newList3(ptr.Pointer())
}

func (ptr *QTimeZone) __windowsIdToIanaIds_atList(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTimeZone___windowsIdToIanaIds_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTimeZone) __windowsIdToIanaIds_setList(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QTimeZone___windowsIdToIanaIds_setList(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QTimeZone) __windowsIdToIanaIds_newList() unsafe.Pointer {
	return C.QTimeZone___windowsIdToIanaIds_newList(ptr.Pointer())
}

func (ptr *QTimeZone) __windowsIdToIanaIds_atList2(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QTimeZone___windowsIdToIanaIds_atList2(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QTimeZone) __windowsIdToIanaIds_setList2(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QTimeZone___windowsIdToIanaIds_setList2(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QTimeZone) __windowsIdToIanaIds_newList2() unsafe.Pointer {
	return C.QTimeZone___windowsIdToIanaIds_newList2(ptr.Pointer())
}

type QTimer struct {
	QObject
}

type QTimer_ITF interface {
	QObject_ITF
	QTimer_PTR() *QTimer
}

func (ptr *QTimer) QTimer_PTR() *QTimer {
	return ptr
}

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

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

func PointerFromQTimer(ptr QTimer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTimer_PTR().Pointer()
	}
	return nil
}

func NewQTimerFromPointer(ptr unsafe.Pointer) (n *QTimer) {
	n = new(QTimer)
	n.SetPointer(ptr)
	return
}
func NewQTimer(parent QObject_ITF) *QTimer {
	tmpValue := NewQTimerFromPointer(C.QTimer_NewQTimer(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTimer) Interval() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimer_Interval(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTimer) IsActive() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTimer_IsActive(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTimer) IsSingleShot() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTimer_IsSingleShot(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTimer) RemainingTime() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimer_RemainingTime(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTimer) SetInterval(msec int) {
	if ptr.Pointer() != nil {
		C.QTimer_SetInterval(ptr.Pointer(), C.int(int32(msec)))
	}
}

func (ptr *QTimer) SetSingleShot(singleShot bool) {
	if ptr.Pointer() != nil {
		C.QTimer_SetSingleShot(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(singleShot))))
	}
}

func (ptr *QTimer) SetTimerType(atype Qt__TimerType) {
	if ptr.Pointer() != nil {
		C.QTimer_SetTimerType(ptr.Pointer(), C.longlong(atype))
	}
}

func QTimer_SingleShot(msec int, receiver QObject_ITF, member string) {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	C.QTimer_QTimer_SingleShot(C.int(int32(msec)), PointerFromQObject(receiver), memberC)
}

func (ptr *QTimer) SingleShot(msec int, receiver QObject_ITF, member string) {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	C.QTimer_QTimer_SingleShot(C.int(int32(msec)), PointerFromQObject(receiver), memberC)
}

func QTimer_SingleShot2(msec int, timerType Qt__TimerType, receiver QObject_ITF, member string) {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	C.QTimer_QTimer_SingleShot2(C.int(int32(msec)), C.longlong(timerType), PointerFromQObject(receiver), memberC)
}

func (ptr *QTimer) SingleShot2(msec int, timerType Qt__TimerType, receiver QObject_ITF, member string) {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	C.QTimer_QTimer_SingleShot2(C.int(int32(msec)), C.longlong(timerType), PointerFromQObject(receiver), memberC)
}

//export callbackQTimer_Start
func callbackQTimer_Start(ptr unsafe.Pointer, msec C.int) {
	if signal := qt.GetSignal(ptr, "start"); signal != nil {
		(*(*func(int))(signal))(int(int32(msec)))
	} else {
		NewQTimerFromPointer(ptr).StartDefault(int(int32(msec)))
	}
}

func (ptr *QTimer) ConnectStart(f func(msec int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
			f := func(msec int) {
				(*(*func(int))(signal))(msec)
				f(msec)
			}
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimer) DisconnectStart() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "start")
	}
}

func (ptr *QTimer) Start(msec int) {
	if ptr.Pointer() != nil {
		C.QTimer_Start(ptr.Pointer(), C.int(int32(msec)))
	}
}

func (ptr *QTimer) StartDefault(msec int) {
	if ptr.Pointer() != nil {
		C.QTimer_StartDefault(ptr.Pointer(), C.int(int32(msec)))
	}
}

//export callbackQTimer_Start2
func callbackQTimer_Start2(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "start2"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTimerFromPointer(ptr).Start2Default()
	}
}

func (ptr *QTimer) ConnectStart2(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "start2"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "start2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "start2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimer) DisconnectStart2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "start2")
	}
}

func (ptr *QTimer) Start2() {
	if ptr.Pointer() != nil {
		C.QTimer_Start2(ptr.Pointer())
	}
}

func (ptr *QTimer) Start2Default() {
	if ptr.Pointer() != nil {
		C.QTimer_Start2Default(ptr.Pointer())
	}
}

//export callbackQTimer_Stop
func callbackQTimer_Stop(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "stop"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTimerFromPointer(ptr).StopDefault()
	}
}

func (ptr *QTimer) ConnectStop(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimer) DisconnectStop() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "stop")
	}
}

func (ptr *QTimer) Stop() {
	if ptr.Pointer() != nil {
		C.QTimer_Stop(ptr.Pointer())
	}
}

func (ptr *QTimer) StopDefault() {
	if ptr.Pointer() != nil {
		C.QTimer_StopDefault(ptr.Pointer())
	}
}

//export callbackQTimer_Timeout
func callbackQTimer_Timeout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timeout"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QTimer) ConnectTimeout(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "timeout") {
			C.QTimer_ConnectTimeout(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "timeout")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "timeout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "timeout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "timeout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimer) DisconnectTimeout() {
	if ptr.Pointer() != nil {
		C.QTimer_DisconnectTimeout(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "timeout")
	}
}

func (ptr *QTimer) TimerId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimer_TimerId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTimer) TimerType() Qt__TimerType {
	if ptr.Pointer() != nil {
		return Qt__TimerType(C.QTimer_TimerType(ptr.Pointer()))
	}
	return 0
}

//export callbackQTimer_DestroyQTimer
func callbackQTimer_DestroyQTimer(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTimer"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTimerFromPointer(ptr).DestroyQTimerDefault()
	}
}

func (ptr *QTimer) ConnectDestroyQTimer(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTimer"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTimer", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTimer", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimer) DisconnectDestroyQTimer() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTimer")
	}
}

func (ptr *QTimer) DestroyQTimer() {
	if ptr.Pointer() != nil {
		C.QTimer_DestroyQTimer(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTimer) DestroyQTimerDefault() {
	if ptr.Pointer() != nil {
		C.QTimer_DestroyQTimerDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTimerEvent struct {
	QEvent
}

type QTimerEvent_ITF interface {
	QEvent_ITF
	QTimerEvent_PTR() *QTimerEvent
}

func (ptr *QTimerEvent) QTimerEvent_PTR() *QTimerEvent {
	return ptr
}

func (ptr *QTimerEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QEvent_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQTimerEvent(ptr QTimerEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTimerEvent_PTR().Pointer()
	}
	return nil
}

func NewQTimerEventFromPointer(ptr unsafe.Pointer) (n *QTimerEvent) {
	n = new(QTimerEvent)
	n.SetPointer(ptr)
	return
}

func (ptr *QTimerEvent) DestroyQTimerEvent() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(ptr.Pointer(), "")
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQTimerEvent(timerId int) *QTimerEvent {
	tmpValue := NewQTimerEventFromPointer(C.QTimerEvent_NewQTimerEvent(C.int(int32(timerId))))
	runtime.SetFinalizer(tmpValue, (*QTimerEvent).DestroyQTimerEvent)
	return tmpValue
}

func (ptr *QTimerEvent) TimerId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTimerEvent_TimerId(ptr.Pointer())))
	}
	return 0
}

type QTranslator struct {
	QObject
}

type QTranslator_ITF interface {
	QObject_ITF
	QTranslator_PTR() *QTranslator
}

func (ptr *QTranslator) QTranslator_PTR() *QTranslator {
	return ptr
}

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

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

func PointerFromQTranslator(ptr QTranslator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTranslator_PTR().Pointer()
	}
	return nil
}

func NewQTranslatorFromPointer(ptr unsafe.Pointer) (n *QTranslator) {
	n = new(QTranslator)
	n.SetPointer(ptr)
	return
}
func NewQTranslator(parent QObject_ITF) *QTranslator {
	tmpValue := NewQTranslatorFromPointer(C.QTranslator_NewQTranslator(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

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

	return C.char(int8(qt.GoBoolToInt(NewQTranslatorFromPointer(ptr).IsEmptyDefault())))
}

func (ptr *QTranslator) ConnectIsEmpty(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isEmpty"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTranslator) DisconnectIsEmpty() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isEmpty")
	}
}

func (ptr *QTranslator) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTranslator_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTranslator) IsEmptyDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTranslator_IsEmptyDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTranslator) Load(filename string, directory string, search_delimiters string, suffix string) bool {
	if ptr.Pointer() != nil {
		var filenameC *C.char
		if filename != "" {
			filenameC = C.CString(filename)
			defer C.free(unsafe.Pointer(filenameC))
		}
		var directoryC *C.char
		if directory != "" {
			directoryC = C.CString(directory)
			defer C.free(unsafe.Pointer(directoryC))
		}
		var search_delimitersC *C.char
		if search_delimiters != "" {
			search_delimitersC = C.CString(search_delimiters)
			defer C.free(unsafe.Pointer(search_delimitersC))
		}
		var suffixC *C.char
		if suffix != "" {
			suffixC = C.CString(suffix)
			defer C.free(unsafe.Pointer(suffixC))
		}
		return int8(C.QTranslator_Load(ptr.Pointer(), C.struct_QtCore_PackedString{data: filenameC, len: C.longlong(len(filename))}, C.struct_QtCore_PackedString{data: directoryC, len: C.longlong(len(directory))}, C.struct_QtCore_PackedString{data: search_delimitersC, len: C.longlong(len(search_delimiters))}, C.struct_QtCore_PackedString{data: suffixC, len: C.longlong(len(suffix))})) != 0
	}
	return false
}

func (ptr *QTranslator) Load2(locale QLocale_ITF, filename string, prefix string, directory string, suffix string) bool {
	if ptr.Pointer() != nil {
		var filenameC *C.char
		if filename != "" {
			filenameC = C.CString(filename)
			defer C.free(unsafe.Pointer(filenameC))
		}
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		var directoryC *C.char
		if directory != "" {
			directoryC = C.CString(directory)
			defer C.free(unsafe.Pointer(directoryC))
		}
		var suffixC *C.char
		if suffix != "" {
			suffixC = C.CString(suffix)
			defer C.free(unsafe.Pointer(suffixC))
		}
		return int8(C.QTranslator_Load2(ptr.Pointer(), PointerFromQLocale(locale), C.struct_QtCore_PackedString{data: filenameC, len: C.longlong(len(filename))}, C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))}, C.struct_QtCore_PackedString{data: directoryC, len: C.longlong(len(directory))}, C.struct_QtCore_PackedString{data: suffixC, len: C.longlong(len(suffix))})) != 0
	}
	return false
}

func (ptr *QTranslator) Load3(data string, l int, directory string) bool {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if data != "" {
			dataC = C.CString(data)
			defer C.free(unsafe.Pointer(dataC))
		}
		var directoryC *C.char
		if directory != "" {
			directoryC = C.CString(directory)
			defer C.free(unsafe.Pointer(directoryC))
		}
		return int8(C.QTranslator_Load3(ptr.Pointer(), dataC, C.int(int32(l)), C.struct_QtCore_PackedString{data: directoryC, len: C.longlong(len(directory))})) != 0
	}
	return false
}

//export callbackQTranslator_Translate
func callbackQTranslator_Translate(ptr unsafe.Pointer, context C.struct_QtCore_PackedString, sourceText C.struct_QtCore_PackedString, disambiguation C.struct_QtCore_PackedString, n C.int) C.struct_QtCore_PackedString {
	if signal := qt.GetSignal(ptr, "translate"); signal != nil {
		tempVal := (*(*func(string, string, string, int) string)(signal))(cGoUnpackString(context), cGoUnpackString(sourceText), cGoUnpackString(disambiguation), int(int32(n)))
		return C.struct_QtCore_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQTranslatorFromPointer(ptr).TranslateDefault(cGoUnpackString(context), cGoUnpackString(sourceText), cGoUnpackString(disambiguation), int(int32(n)))
	return C.struct_QtCore_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QTranslator) ConnectTranslate(f func(context string, sourceText string, disambiguation string, n int) string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "translate"); signal != nil {
			f := func(context string, sourceText string, disambiguation string, n int) string {
				(*(*func(string, string, string, int) string)(signal))(context, sourceText, disambiguation, n)
				return f(context, sourceText, disambiguation, n)
			}
			qt.ConnectSignal(ptr.Pointer(), "translate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "translate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTranslator) DisconnectTranslate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "translate")
	}
}

func (ptr *QTranslator) Translate(context string, sourceText string, disambiguation string, n int) string {
	if ptr.Pointer() != nil {
		var contextC *C.char
		if context != "" {
			contextC = C.CString(context)
			defer C.free(unsafe.Pointer(contextC))
		}
		var sourceTextC *C.char
		if sourceText != "" {
			sourceTextC = C.CString(sourceText)
			defer C.free(unsafe.Pointer(sourceTextC))
		}
		var disambiguationC *C.char
		if disambiguation != "" {
			disambiguationC = C.CString(disambiguation)
			defer C.free(unsafe.Pointer(disambiguationC))
		}
		return cGoUnpackString(C.QTranslator_Translate(ptr.Pointer(), contextC, sourceTextC, disambiguationC, C.int(int32(n))))
	}
	return ""
}

func (ptr *QTranslator) TranslateDefault(context string, sourceText string, disambiguation string, n int) string {
	if ptr.Pointer() != nil {
		var contextC *C.char
		if context != "" {
			contextC = C.CString(context)
			defer C.free(unsafe.Pointer(contextC))
		}
		var sourceTextC *C.char
		if sourceText != "" {
			sourceTextC = C.CString(sourceText)
			defer C.free(unsafe.Pointer(sourceTextC))
		}
		var disambiguationC *C.char
		if disambiguation != "" {
			disambiguationC = C.CString(disambiguation)
			defer C.free(unsafe.Pointer(disambiguationC))
		}
		return cGoUnpackString(C.QTranslator_TranslateDefault(ptr.Pointer(), contextC, sourceTextC, disambiguationC, C.int(int32(n))))
	}
	return ""
}

//export callbackQTranslator_DestroyQTranslator
func callbackQTranslator_DestroyQTranslator(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTranslator"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTranslatorFromPointer(ptr).DestroyQTranslatorDefault()
	}
}

func (ptr *QTranslator) ConnectDestroyQTranslator(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTranslator"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTranslator", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTranslator", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTranslator) DisconnectDestroyQTranslator() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTranslator")
	}
}

func (ptr *QTranslator) DestroyQTranslator() {
	if ptr.Pointer() != nil {
		C.QTranslator_DestroyQTranslator(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTranslator) DestroyQTranslatorDefault() {
	if ptr.Pointer() != nil {
		C.QTranslator_DestroyQTranslatorDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTransposeProxyModel struct {
	QAbstractProxyModel
}

type QTransposeProxyModel_ITF interface {
	QAbstractProxyModel_ITF
	QTransposeProxyModel_PTR() *QTransposeProxyModel
}

func (ptr *QTransposeProxyModel) QTransposeProxyModel_PTR() *QTransposeProxyModel {
	return ptr
}

func (ptr *QTransposeProxyModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractProxyModel_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQTransposeProxyModel(ptr QTransposeProxyModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTransposeProxyModel_PTR().Pointer()
	}
	return nil
}

func NewQTransposeProxyModelFromPointer(ptr unsafe.Pointer) (n *QTransposeProxyModel) {
	n = new(QTransposeProxyModel)
	n.SetPointer(ptr)
	return
}
func NewQTransposeProxyModel2(parent QObject_ITF) *QTransposeProxyModel {
	tmpValue := NewQTransposeProxyModelFromPointer(C.QTransposeProxyModel_NewQTransposeProxyModel2(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQTransposeProxyModel_ColumnCount
func callbackQTransposeProxyModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQTransposeProxyModelFromPointer(ptr).ColumnCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QTransposeProxyModel) ConnectColumnCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTransposeProxyModel) DisconnectColumnCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnCount")
	}
}

func (ptr *QTransposeProxyModel) ColumnCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTransposeProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QTransposeProxyModel) ColumnCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTransposeProxyModel_ColumnCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQTransposeProxyModel_Index
func callbackQTransposeProxyModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return PointerFromQModelIndex((*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
	}

	return PointerFromQModelIndex(NewQTransposeProxyModelFromPointer(ptr).IndexDefault(int(int32(row)), int(int32(column)), NewQModelIndexFromPointer(parent)))
}

func (ptr *QTransposeProxyModel) ConnectIndex(f func(row int, column int, parent *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "index"); signal != nil {
			f := func(row int, column int, parent *QModelIndex) *QModelIndex {
				(*(*func(int, int, *QModelIndex) *QModelIndex)(signal))(row, column, parent)
				return f(row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTransposeProxyModel) DisconnectIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "index")
	}
}

func (ptr *QTransposeProxyModel) Index(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QTransposeProxyModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTransposeProxyModel) IndexDefault(row int, column int, parent QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QTransposeProxyModel_IndexDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQTransposeProxyModel_MapFromSource
func callbackQTransposeProxyModel_MapFromSource(ptr unsafe.Pointer, sourceIndex unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapFromSource"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(sourceIndex)))
	}

	return PointerFromQModelIndex(NewQTransposeProxyModelFromPointer(ptr).MapFromSourceDefault(NewQModelIndexFromPointer(sourceIndex)))
}

func (ptr *QTransposeProxyModel) ConnectMapFromSource(f func(sourceIndex *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapFromSource"); signal != nil {
			f := func(sourceIndex *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(sourceIndex)
				return f(sourceIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapFromSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapFromSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTransposeProxyModel) DisconnectMapFromSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapFromSource")
	}
}

func (ptr *QTransposeProxyModel) MapFromSource(sourceIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QTransposeProxyModel_MapFromSource(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTransposeProxyModel) MapFromSourceDefault(sourceIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QTransposeProxyModel_MapFromSourceDefault(ptr.Pointer(), PointerFromQModelIndex(sourceIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQTransposeProxyModel_MapToSource
func callbackQTransposeProxyModel_MapToSource(ptr unsafe.Pointer, proxyIndex unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mapToSource"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(proxyIndex)))
	}

	return PointerFromQModelIndex(NewQTransposeProxyModelFromPointer(ptr).MapToSourceDefault(NewQModelIndexFromPointer(proxyIndex)))
}

func (ptr *QTransposeProxyModel) ConnectMapToSource(f func(proxyIndex *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mapToSource"); signal != nil {
			f := func(proxyIndex *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(proxyIndex)
				return f(proxyIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "mapToSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mapToSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTransposeProxyModel) DisconnectMapToSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mapToSource")
	}
}

func (ptr *QTransposeProxyModel) MapToSource(proxyIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QTransposeProxyModel_MapToSource(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTransposeProxyModel) MapToSourceDefault(proxyIndex QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QTransposeProxyModel_MapToSourceDefault(ptr.Pointer(), PointerFromQModelIndex(proxyIndex)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQTransposeProxyModel_Parent
func callbackQTransposeProxyModel_Parent(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return PointerFromQModelIndex((*(*func(*QModelIndex) *QModelIndex)(signal))(NewQModelIndexFromPointer(index)))
	}

	return PointerFromQModelIndex(NewQTransposeProxyModelFromPointer(ptr).ParentDefault(NewQModelIndexFromPointer(index)))
}

func (ptr *QTransposeProxyModel) ConnectParent(f func(index *QModelIndex) *QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "parent"); signal != nil {
			f := func(index *QModelIndex) *QModelIndex {
				(*(*func(*QModelIndex) *QModelIndex)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTransposeProxyModel) DisconnectParent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "parent")
	}
}

func (ptr *QTransposeProxyModel) Parent(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QTransposeProxyModel_Parent(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTransposeProxyModel) ParentDefault(index QModelIndex_ITF) *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QTransposeProxyModel_ParentDefault(ptr.Pointer(), PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQTransposeProxyModel_RowCount
func callbackQTransposeProxyModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*QModelIndex) int)(signal))(NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQTransposeProxyModelFromPointer(ptr).RowCountDefault(NewQModelIndexFromPointer(parent))))
}

func (ptr *QTransposeProxyModel) ConnectRowCount(f func(parent *QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowCount"); signal != nil {
			f := func(parent *QModelIndex) int {
				(*(*func(*QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTransposeProxyModel) DisconnectRowCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowCount")
	}
}

func (ptr *QTransposeProxyModel) RowCount(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTransposeProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QTransposeProxyModel) RowCountDefault(parent QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTransposeProxyModel_RowCountDefault(ptr.Pointer(), PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQTransposeProxyModel_DestroyQTransposeProxyModel
func callbackQTransposeProxyModel_DestroyQTransposeProxyModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTransposeProxyModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTransposeProxyModelFromPointer(ptr).DestroyQTransposeProxyModelDefault()
	}
}

func (ptr *QTransposeProxyModel) ConnectDestroyQTransposeProxyModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTransposeProxyModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTransposeProxyModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTransposeProxyModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTransposeProxyModel) DisconnectDestroyQTransposeProxyModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTransposeProxyModel")
	}
}

func (ptr *QTransposeProxyModel) DestroyQTransposeProxyModel() {
	if ptr.Pointer() != nil {
		C.QTransposeProxyModel_DestroyQTransposeProxyModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTransposeProxyModel) DestroyQTransposeProxyModelDefault() {
	if ptr.Pointer() != nil {
		C.QTransposeProxyModel_DestroyQTransposeProxyModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QTypedArrayData struct {
	QArrayData
}

type QTypedArrayData_ITF interface {
	QArrayData_ITF
	QTypedArrayData_PTR() *QTypedArrayData
}

func (ptr *QTypedArrayData) QTypedArrayData_PTR() *QTypedArrayData {
	return ptr
}

func (ptr *QTypedArrayData) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QArrayData_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQTypedArrayData(ptr QTypedArrayData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTypedArrayData_PTR().Pointer()
	}
	return nil
}

func NewQTypedArrayDataFromPointer(ptr unsafe.Pointer) (n *QTypedArrayData) {
	n = new(QTypedArrayData)
	n.SetPointer(ptr)
	return
}

func (ptr *QTypedArrayData) DestroyQTypedArrayData() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QUnhandledException struct {
	QException
}

type QUnhandledException_ITF interface {
	QException_ITF
	QUnhandledException_PTR() *QUnhandledException
}

func (ptr *QUnhandledException) QUnhandledException_PTR() *QUnhandledException {
	return ptr
}

func (ptr *QUnhandledException) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QException_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQUnhandledException(ptr QUnhandledException_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUnhandledException_PTR().Pointer()
	}
	return nil
}

func NewQUnhandledExceptionFromPointer(ptr unsafe.Pointer) (n *QUnhandledException) {
	n = new(QUnhandledException)
	n.SetPointer(ptr)
	return
}

func (ptr *QUnhandledException) DestroyQUnhandledException() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(ptr.Pointer(), "")
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QUrl struct {
	ptr unsafe.Pointer
}

type QUrl_ITF interface {
	QUrl_PTR() *QUrl
}

func (ptr *QUrl) QUrl_PTR() *QUrl {
	return ptr
}

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

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

func PointerFromQUrl(ptr QUrl_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUrl_PTR().Pointer()
	}
	return nil
}

func NewQUrlFromPointer(ptr unsafe.Pointer) (n *QUrl) {
	n = new(QUrl)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QUrl__ParsingMode
//QUrl::ParsingMode
type QUrl__ParsingMode int64

const (
	QUrl__TolerantMode QUrl__ParsingMode = QUrl__ParsingMode(0)
	QUrl__StrictMode   QUrl__ParsingMode = QUrl__ParsingMode(1)
	QUrl__DecodedMode  QUrl__ParsingMode = QUrl__ParsingMode(2)
)

//go:generate stringer -type=QUrl__UrlFormattingOption
//QUrl::UrlFormattingOption
type QUrl__UrlFormattingOption int64

const (
	QUrl__None                  QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x0)
	QUrl__RemoveScheme          QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x1)
	QUrl__RemovePassword        QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x2)
	QUrl__RemoveUserInfo        QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(QUrl__RemovePassword | 0x4)
	QUrl__RemovePort            QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x8)
	QUrl__RemoveAuthority       QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(QUrl__RemoveUserInfo | QUrl__RemovePort | 0x10)
	QUrl__RemovePath            QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x20)
	QUrl__RemoveQuery           QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x40)
	QUrl__RemoveFragment        QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x80)
	QUrl__PreferLocalFile       QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x200)
	QUrl__StripTrailingSlash    QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x400)
	QUrl__RemoveFilename        QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x800)
	QUrl__NormalizePathSegments QUrl__UrlFormattingOption = QUrl__UrlFormattingOption(0x1000)
)

//go:generate stringer -type=QUrl__ComponentFormattingOption
//QUrl::ComponentFormattingOption
type QUrl__ComponentFormattingOption int64

const (
	QUrl__PrettyDecoded    QUrl__ComponentFormattingOption = QUrl__ComponentFormattingOption(0x000000)
	QUrl__EncodeSpaces     QUrl__ComponentFormattingOption = QUrl__ComponentFormattingOption(0x100000)
	QUrl__EncodeUnicode    QUrl__ComponentFormattingOption = QUrl__ComponentFormattingOption(0x200000)
	QUrl__EncodeDelimiters QUrl__ComponentFormattingOption = QUrl__ComponentFormattingOption(0x400000 | 0x800000)
	QUrl__EncodeReserved   QUrl__ComponentFormattingOption = QUrl__ComponentFormattingOption(0x1000000)
	QUrl__DecodeReserved   QUrl__ComponentFormattingOption = QUrl__ComponentFormattingOption(0x2000000)
	QUrl__FullyEncoded     QUrl__ComponentFormattingOption = QUrl__ComponentFormattingOption(QUrl__EncodeSpaces | QUrl__EncodeUnicode | QUrl__EncodeDelimiters | QUrl__EncodeReserved)
	QUrl__FullyDecoded     QUrl__ComponentFormattingOption = QUrl__ComponentFormattingOption(QUrl__FullyEncoded | QUrl__DecodeReserved | 0x4000000)
)

//go:generate stringer -type=QUrl__UserInputResolutionOption
//QUrl::UserInputResolutionOption
type QUrl__UserInputResolutionOption int64

const (
	QUrl__DefaultResolution QUrl__UserInputResolutionOption = QUrl__UserInputResolutionOption(0)
	QUrl__AssumeLocalFile   QUrl__UserInputResolutionOption = QUrl__UserInputResolutionOption(1)
)

func NewQUrl() *QUrl {
	tmpValue := NewQUrlFromPointer(C.QUrl_NewQUrl())
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func NewQUrl2(other QUrl_ITF) *QUrl {
	tmpValue := NewQUrlFromPointer(C.QUrl_NewQUrl2(PointerFromQUrl(other)))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func NewQUrl3(url string, parsingMode QUrl__ParsingMode) *QUrl {
	var urlC *C.char
	if url != "" {
		urlC = C.CString(url)
		defer C.free(unsafe.Pointer(urlC))
	}
	tmpValue := NewQUrlFromPointer(C.QUrl_NewQUrl3(C.struct_QtCore_PackedString{data: urlC, len: C.longlong(len(url))}, C.longlong(parsingMode)))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func NewQUrl4(other QUrl_ITF) *QUrl {
	tmpValue := NewQUrlFromPointer(C.QUrl_NewQUrl4(PointerFromQUrl(other)))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QUrl) Adjusted(options QUrl__UrlFormattingOption) *QUrl {
	if ptr.Pointer() != nil {
		tmpValue := NewQUrlFromPointer(C.QUrl_Adjusted(ptr.Pointer(), C.longlong(options)))
		runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QUrl) Authority(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_Authority(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) Clear() {
	if ptr.Pointer() != nil {
		C.QUrl_Clear(ptr.Pointer())
	}
}

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

func (ptr *QUrl) FileName(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_FileName(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) Fragment(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_Fragment(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func QUrl_FromAce(domain QByteArray_ITF) string {
	return cGoUnpackString(C.QUrl_QUrl_FromAce(PointerFromQByteArray(domain)))
}

func (ptr *QUrl) FromAce(domain QByteArray_ITF) string {
	return cGoUnpackString(C.QUrl_QUrl_FromAce(PointerFromQByteArray(domain)))
}

func QUrl_FromEncoded(input QByteArray_ITF, parsingMode QUrl__ParsingMode) *QUrl {
	tmpValue := NewQUrlFromPointer(C.QUrl_QUrl_FromEncoded(PointerFromQByteArray(input), C.longlong(parsingMode)))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QUrl) FromEncoded(input QByteArray_ITF, parsingMode QUrl__ParsingMode) *QUrl {
	tmpValue := NewQUrlFromPointer(C.QUrl_QUrl_FromEncoded(PointerFromQByteArray(input), C.longlong(parsingMode)))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func QUrl_FromLocalFile(localFile string) *QUrl {
	var localFileC *C.char
	if localFile != "" {
		localFileC = C.CString(localFile)
		defer C.free(unsafe.Pointer(localFileC))
	}
	tmpValue := NewQUrlFromPointer(C.QUrl_QUrl_FromLocalFile(C.struct_QtCore_PackedString{data: localFileC, len: C.longlong(len(localFile))}))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QUrl) FromLocalFile(localFile string) *QUrl {
	var localFileC *C.char
	if localFile != "" {
		localFileC = C.CString(localFile)
		defer C.free(unsafe.Pointer(localFileC))
	}
	tmpValue := NewQUrlFromPointer(C.QUrl_QUrl_FromLocalFile(C.struct_QtCore_PackedString{data: localFileC, len: C.longlong(len(localFile))}))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func QUrl_FromPercentEncoding(input QByteArray_ITF) string {
	return cGoUnpackString(C.QUrl_QUrl_FromPercentEncoding(PointerFromQByteArray(input)))
}

func (ptr *QUrl) FromPercentEncoding(input QByteArray_ITF) string {
	return cGoUnpackString(C.QUrl_QUrl_FromPercentEncoding(PointerFromQByteArray(input)))
}

func QUrl_FromStringList(urls []string, mode QUrl__ParsingMode) []*QUrl {
	urlsC := C.CString(strings.Join(urls, "¡¦!"))
	defer C.free(unsafe.Pointer(urlsC))
	return func(l C.struct_QtCore_PackedList) []*QUrl {
		out := make([]*QUrl, int(l.len))
		tmpList := NewQUrlFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__fromStringList_atList(i)
		}
		return out
	}(C.QUrl_QUrl_FromStringList(C.struct_QtCore_PackedString{data: urlsC, len: C.longlong(len(strings.Join(urls, "¡¦!")))}, C.longlong(mode)))
}

func (ptr *QUrl) FromStringList(urls []string, mode QUrl__ParsingMode) []*QUrl {
	urlsC := C.CString(strings.Join(urls, "¡¦!"))
	defer C.free(unsafe.Pointer(urlsC))
	return func(l C.struct_QtCore_PackedList) []*QUrl {
		out := make([]*QUrl, int(l.len))
		tmpList := NewQUrlFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__fromStringList_atList(i)
		}
		return out
	}(C.QUrl_QUrl_FromStringList(C.struct_QtCore_PackedString{data: urlsC, len: C.longlong(len(strings.Join(urls, "¡¦!")))}, C.longlong(mode)))
}

func QUrl_FromUserInput(userInput string) *QUrl {
	var userInputC *C.char
	if userInput != "" {
		userInputC = C.CString(userInput)
		defer C.free(unsafe.Pointer(userInputC))
	}
	tmpValue := NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput(C.struct_QtCore_PackedString{data: userInputC, len: C.longlong(len(userInput))}))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QUrl) FromUserInput(userInput string) *QUrl {
	var userInputC *C.char
	if userInput != "" {
		userInputC = C.CString(userInput)
		defer C.free(unsafe.Pointer(userInputC))
	}
	tmpValue := NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput(C.struct_QtCore_PackedString{data: userInputC, len: C.longlong(len(userInput))}))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func QUrl_FromUserInput2(userInput string, workingDirectory string, options QUrl__UserInputResolutionOption) *QUrl {
	var userInputC *C.char
	if userInput != "" {
		userInputC = C.CString(userInput)
		defer C.free(unsafe.Pointer(userInputC))
	}
	var workingDirectoryC *C.char
	if workingDirectory != "" {
		workingDirectoryC = C.CString(workingDirectory)
		defer C.free(unsafe.Pointer(workingDirectoryC))
	}
	tmpValue := NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput2(C.struct_QtCore_PackedString{data: userInputC, len: C.longlong(len(userInput))}, C.struct_QtCore_PackedString{data: workingDirectoryC, len: C.longlong(len(workingDirectory))}, C.longlong(options)))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QUrl) FromUserInput2(userInput string, workingDirectory string, options QUrl__UserInputResolutionOption) *QUrl {
	var userInputC *C.char
	if userInput != "" {
		userInputC = C.CString(userInput)
		defer C.free(unsafe.Pointer(userInputC))
	}
	var workingDirectoryC *C.char
	if workingDirectory != "" {
		workingDirectoryC = C.CString(workingDirectory)
		defer C.free(unsafe.Pointer(workingDirectoryC))
	}
	tmpValue := NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput2(C.struct_QtCore_PackedString{data: userInputC, len: C.longlong(len(userInput))}, C.struct_QtCore_PackedString{data: workingDirectoryC, len: C.longlong(len(workingDirectory))}, C.longlong(options)))
	runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QUrl) HasFragment() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUrl_HasFragment(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUrl) HasQuery() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUrl_HasQuery(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUrl) Host(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_Host(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func QUrl_IdnWhitelist() []string {
	return unpackStringList(cGoUnpackString(C.QUrl_QUrl_IdnWhitelist()))
}

func (ptr *QUrl) IdnWhitelist() []string {
	return unpackStringList(cGoUnpackString(C.QUrl_QUrl_IdnWhitelist()))
}

func (ptr *QUrl) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUrl_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUrl) IsLocalFile() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUrl_IsLocalFile(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUrl) IsParentOf(childUrl QUrl_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QUrl_IsParentOf(ptr.Pointer(), PointerFromQUrl(childUrl))) != 0
	}
	return false
}

func (ptr *QUrl) IsRelative() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUrl_IsRelative(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUrl) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUrl_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUrl) Matches(url QUrl_ITF, options QUrl__UrlFormattingOption) bool {
	if ptr.Pointer() != nil {
		return int8(C.QUrl_Matches(ptr.Pointer(), PointerFromQUrl(url), C.longlong(options))) != 0
	}
	return false
}

func (ptr *QUrl) Password(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_Password(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) Path(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_Path(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) Port(defaultPort int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QUrl_Port(ptr.Pointer(), C.int(int32(defaultPort)))))
	}
	return 0
}

func (ptr *QUrl) Query(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_Query(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) Resolved(relative QUrl_ITF) *QUrl {
	if ptr.Pointer() != nil {
		tmpValue := NewQUrlFromPointer(C.QUrl_Resolved(ptr.Pointer(), PointerFromQUrl(relative)))
		runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QUrl) Scheme() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_Scheme(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUrl) SetAuthority(authority string, mode QUrl__ParsingMode) {
	if ptr.Pointer() != nil {
		var authorityC *C.char
		if authority != "" {
			authorityC = C.CString(authority)
			defer C.free(unsafe.Pointer(authorityC))
		}
		C.QUrl_SetAuthority(ptr.Pointer(), C.struct_QtCore_PackedString{data: authorityC, len: C.longlong(len(authority))}, C.longlong(mode))
	}
}

func (ptr *QUrl) SetFragment(fragment string, mode QUrl__ParsingMode) {
	if ptr.Pointer() != nil {
		var fragmentC *C.char
		if fragment != "" {
			fragmentC = C.CString(fragment)
			defer C.free(unsafe.Pointer(fragmentC))
		}
		C.QUrl_SetFragment(ptr.Pointer(), C.struct_QtCore_PackedString{data: fragmentC, len: C.longlong(len(fragment))}, C.longlong(mode))
	}
}

func (ptr *QUrl) SetHost(host string, mode QUrl__ParsingMode) {
	if ptr.Pointer() != nil {
		var hostC *C.char
		if host != "" {
			hostC = C.CString(host)
			defer C.free(unsafe.Pointer(hostC))
		}
		C.QUrl_SetHost(ptr.Pointer(), C.struct_QtCore_PackedString{data: hostC, len: C.longlong(len(host))}, C.longlong(mode))
	}
}

func QUrl_SetIdnWhitelist(list []string) {
	listC := C.CString(strings.Join(list, "¡¦!"))
	defer C.free(unsafe.Pointer(listC))
	C.QUrl_QUrl_SetIdnWhitelist(C.struct_QtCore_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "¡¦!")))})
}

func (ptr *QUrl) SetIdnWhitelist(list []string) {
	listC := C.CString(strings.Join(list, "¡¦!"))
	defer C.free(unsafe.Pointer(listC))
	C.QUrl_QUrl_SetIdnWhitelist(C.struct_QtCore_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "¡¦!")))})
}

func (ptr *QUrl) SetPassword(password string, mode QUrl__ParsingMode) {
	if ptr.Pointer() != nil {
		var passwordC *C.char
		if password != "" {
			passwordC = C.CString(password)
			defer C.free(unsafe.Pointer(passwordC))
		}
		C.QUrl_SetPassword(ptr.Pointer(), C.struct_QtCore_PackedString{data: passwordC, len: C.longlong(len(password))}, C.longlong(mode))
	}
}

func (ptr *QUrl) SetPath(path string, mode QUrl__ParsingMode) {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		C.QUrl_SetPath(ptr.Pointer(), C.struct_QtCore_PackedString{data: pathC, len: C.longlong(len(path))}, C.longlong(mode))
	}
}

func (ptr *QUrl) SetPort(port int) {
	if ptr.Pointer() != nil {
		C.QUrl_SetPort(ptr.Pointer(), C.int(int32(port)))
	}
}

func (ptr *QUrl) SetQuery(query string, mode QUrl__ParsingMode) {
	if ptr.Pointer() != nil {
		var queryC *C.char
		if query != "" {
			queryC = C.CString(query)
			defer C.free(unsafe.Pointer(queryC))
		}
		C.QUrl_SetQuery(ptr.Pointer(), C.struct_QtCore_PackedString{data: queryC, len: C.longlong(len(query))}, C.longlong(mode))
	}
}

func (ptr *QUrl) SetQuery2(query QUrlQuery_ITF) {
	if ptr.Pointer() != nil {
		C.QUrl_SetQuery2(ptr.Pointer(), PointerFromQUrlQuery(query))
	}
}

func (ptr *QUrl) SetScheme(scheme string) {
	if ptr.Pointer() != nil {
		var schemeC *C.char
		if scheme != "" {
			schemeC = C.CString(scheme)
			defer C.free(unsafe.Pointer(schemeC))
		}
		C.QUrl_SetScheme(ptr.Pointer(), C.struct_QtCore_PackedString{data: schemeC, len: C.longlong(len(scheme))})
	}
}

func (ptr *QUrl) SetUrl(url string, parsingMode QUrl__ParsingMode) {
	if ptr.Pointer() != nil {
		var urlC *C.char
		if url != "" {
			urlC = C.CString(url)
			defer C.free(unsafe.Pointer(urlC))
		}
		C.QUrl_SetUrl(ptr.Pointer(), C.struct_QtCore_PackedString{data: urlC, len: C.longlong(len(url))}, C.longlong(parsingMode))
	}
}

func (ptr *QUrl) SetUserInfo(userInfo string, mode QUrl__ParsingMode) {
	if ptr.Pointer() != nil {
		var userInfoC *C.char
		if userInfo != "" {
			userInfoC = C.CString(userInfo)
			defer C.free(unsafe.Pointer(userInfoC))
		}
		C.QUrl_SetUserInfo(ptr.Pointer(), C.struct_QtCore_PackedString{data: userInfoC, len: C.longlong(len(userInfo))}, C.longlong(mode))
	}
}

func (ptr *QUrl) SetUserName(userName string, mode QUrl__ParsingMode) {
	if ptr.Pointer() != nil {
		var userNameC *C.char
		if userName != "" {
			userNameC = C.CString(userName)
			defer C.free(unsafe.Pointer(userNameC))
		}
		C.QUrl_SetUserName(ptr.Pointer(), C.struct_QtCore_PackedString{data: userNameC, len: C.longlong(len(userName))}, C.longlong(mode))
	}
}

func (ptr *QUrl) Swap(other QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QUrl_Swap(ptr.Pointer(), PointerFromQUrl(other))
	}
}

func QUrl_ToAce(domain string) *QByteArray {
	var domainC *C.char
	if domain != "" {
		domainC = C.CString(domain)
		defer C.free(unsafe.Pointer(domainC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QUrl_QUrl_ToAce(C.struct_QtCore_PackedString{data: domainC, len: C.longlong(len(domain))}))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QUrl) ToAce(domain string) *QByteArray {
	var domainC *C.char
	if domain != "" {
		domainC = C.CString(domain)
		defer C.free(unsafe.Pointer(domainC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QUrl_QUrl_ToAce(C.struct_QtCore_PackedString{data: domainC, len: C.longlong(len(domain))}))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QUrl) ToDisplayString(options QUrl__UrlFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_ToDisplayString(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) ToEncoded(options QUrl__UrlFormattingOption) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QUrl_ToEncoded(ptr.Pointer(), C.longlong(options)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QUrl) ToLocalFile() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_ToLocalFile(ptr.Pointer()))
	}
	return ""
}

func QUrl_ToPercentEncoding(input string, exclude QByteArray_ITF, include QByteArray_ITF) *QByteArray {
	var inputC *C.char
	if input != "" {
		inputC = C.CString(input)
		defer C.free(unsafe.Pointer(inputC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QUrl_QUrl_ToPercentEncoding(C.struct_QtCore_PackedString{data: inputC, len: C.longlong(len(input))}, PointerFromQByteArray(exclude), PointerFromQByteArray(include)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QUrl) ToPercentEncoding(input string, exclude QByteArray_ITF, include QByteArray_ITF) *QByteArray {
	var inputC *C.char
	if input != "" {
		inputC = C.CString(input)
		defer C.free(unsafe.Pointer(inputC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QUrl_QUrl_ToPercentEncoding(C.struct_QtCore_PackedString{data: inputC, len: C.longlong(len(input))}, PointerFromQByteArray(exclude), PointerFromQByteArray(include)))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QUrl) ToString(options QUrl__UrlFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_ToString(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func QUrl_ToStringList(urls []*QUrl, options QUrl__UrlFormattingOption) []string {
	return unpackStringList(cGoUnpackString(C.QUrl_QUrl_ToStringList(func() unsafe.Pointer {
		tmpList := NewQUrlFromPointer(NewQUrlFromPointer(nil).__toStringList_urls_newList())
		for _, v := range urls {
			tmpList.__toStringList_urls_setList(v)
		}
		return tmpList.Pointer()
	}(), C.longlong(options))))
}

func (ptr *QUrl) ToStringList(urls []*QUrl, options QUrl__UrlFormattingOption) []string {
	return unpackStringList(cGoUnpackString(C.QUrl_QUrl_ToStringList(func() unsafe.Pointer {
		tmpList := NewQUrlFromPointer(NewQUrlFromPointer(nil).__toStringList_urls_newList())
		for _, v := range urls {
			tmpList.__toStringList_urls_setList(v)
		}
		return tmpList.Pointer()
	}(), C.longlong(options))))
}

func (ptr *QUrl) TopLevelDomain(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_TopLevelDomain(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) Url(options QUrl__UrlFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_Url(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) UserInfo(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_UserInfo(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) UserName(options QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrl_UserName(ptr.Pointer(), C.longlong(options)))
	}
	return ""
}

func (ptr *QUrl) DestroyQUrl() {
	if ptr.Pointer() != nil {
		C.QUrl_DestroyQUrl(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QUrl) __allEncodedQueryItemValues_atList(i int) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QUrl___allEncodedQueryItemValues_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QUrl) __allEncodedQueryItemValues_setList(i QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QUrl___allEncodedQueryItemValues_setList(ptr.Pointer(), PointerFromQByteArray(i))
	}
}

func (ptr *QUrl) __allEncodedQueryItemValues_newList() unsafe.Pointer {
	return C.QUrl___allEncodedQueryItemValues_newList(ptr.Pointer())
}

func (ptr *QUrl) __fromStringList_atList(i int) *QUrl {
	if ptr.Pointer() != nil {
		tmpValue := NewQUrlFromPointer(C.QUrl___fromStringList_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QUrl) __fromStringList_setList(i QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QUrl___fromStringList_setList(ptr.Pointer(), PointerFromQUrl(i))
	}
}

func (ptr *QUrl) __fromStringList_newList() unsafe.Pointer {
	return C.QUrl___fromStringList_newList(ptr.Pointer())
}

func (ptr *QUrl) __toStringList_urls_atList(i int) *QUrl {
	if ptr.Pointer() != nil {
		tmpValue := NewQUrlFromPointer(C.QUrl___toStringList_urls_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QUrl) __toStringList_urls_setList(i QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QUrl___toStringList_urls_setList(ptr.Pointer(), PointerFromQUrl(i))
	}
}

func (ptr *QUrl) __toStringList_urls_newList() unsafe.Pointer {
	return C.QUrl___toStringList_urls_newList(ptr.Pointer())
}

type QUrlQuery struct {
	ptr unsafe.Pointer
}

type QUrlQuery_ITF interface {
	QUrlQuery_PTR() *QUrlQuery
}

func (ptr *QUrlQuery) QUrlQuery_PTR() *QUrlQuery {
	return ptr
}

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

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

func PointerFromQUrlQuery(ptr QUrlQuery_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUrlQuery_PTR().Pointer()
	}
	return nil
}

func NewQUrlQueryFromPointer(ptr unsafe.Pointer) (n *QUrlQuery) {
	n = new(QUrlQuery)
	n.SetPointer(ptr)
	return
}
func NewQUrlQuery() *QUrlQuery {
	tmpValue := NewQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery())
	runtime.SetFinalizer(tmpValue, (*QUrlQuery).DestroyQUrlQuery)
	return tmpValue
}

func NewQUrlQuery2(url QUrl_ITF) *QUrlQuery {
	tmpValue := NewQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery2(PointerFromQUrl(url)))
	runtime.SetFinalizer(tmpValue, (*QUrlQuery).DestroyQUrlQuery)
	return tmpValue
}

func NewQUrlQuery3(queryString string) *QUrlQuery {
	var queryStringC *C.char
	if queryString != "" {
		queryStringC = C.CString(queryString)
		defer C.free(unsafe.Pointer(queryStringC))
	}
	tmpValue := NewQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery3(C.struct_QtCore_PackedString{data: queryStringC, len: C.longlong(len(queryString))}))
	runtime.SetFinalizer(tmpValue, (*QUrlQuery).DestroyQUrlQuery)
	return tmpValue
}

func NewQUrlQuery5(other QUrlQuery_ITF) *QUrlQuery {
	tmpValue := NewQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery5(PointerFromQUrlQuery(other)))
	runtime.SetFinalizer(tmpValue, (*QUrlQuery).DestroyQUrlQuery)
	return tmpValue
}

func (ptr *QUrlQuery) AddQueryItem(key string, value string) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		var valueC *C.char
		if value != "" {
			valueC = C.CString(value)
			defer C.free(unsafe.Pointer(valueC))
		}
		C.QUrlQuery_AddQueryItem(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, C.struct_QtCore_PackedString{data: valueC, len: C.longlong(len(value))})
	}
}

func (ptr *QUrlQuery) AllQueryItemValues(key string, encoding QUrl__ComponentFormattingOption) []string {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		return unpackStringList(cGoUnpackString(C.QUrlQuery_AllQueryItemValues(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, C.longlong(encoding))))
	}
	return make([]string, 0)
}

func (ptr *QUrlQuery) Clear() {
	if ptr.Pointer() != nil {
		C.QUrlQuery_Clear(ptr.Pointer())
	}
}

func QUrlQuery_DefaultQueryPairDelimiter() *QChar {
	tmpValue := NewQCharFromPointer(C.QUrlQuery_QUrlQuery_DefaultQueryPairDelimiter())
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func (ptr *QUrlQuery) DefaultQueryPairDelimiter() *QChar {
	tmpValue := NewQCharFromPointer(C.QUrlQuery_QUrlQuery_DefaultQueryPairDelimiter())
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func QUrlQuery_DefaultQueryValueDelimiter() *QChar {
	tmpValue := NewQCharFromPointer(C.QUrlQuery_QUrlQuery_DefaultQueryValueDelimiter())
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func (ptr *QUrlQuery) DefaultQueryValueDelimiter() *QChar {
	tmpValue := NewQCharFromPointer(C.QUrlQuery_QUrlQuery_DefaultQueryValueDelimiter())
	runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
	return tmpValue
}

func (ptr *QUrlQuery) HasQueryItem(key string) bool {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		return int8(C.QUrlQuery_HasQueryItem(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})) != 0
	}
	return false
}

func (ptr *QUrlQuery) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUrlQuery_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUrlQuery) Query(encoding QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrlQuery_Query(ptr.Pointer(), C.longlong(encoding)))
	}
	return ""
}

func (ptr *QUrlQuery) QueryItemValue(key string, encoding QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		return cGoUnpackString(C.QUrlQuery_QueryItemValue(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, C.longlong(encoding)))
	}
	return ""
}

func (ptr *QUrlQuery) QueryPairDelimiter() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QUrlQuery_QueryPairDelimiter(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QUrlQuery) QueryValueDelimiter() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QUrlQuery_QueryValueDelimiter(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QUrlQuery) RemoveAllQueryItems(key string) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QUrlQuery_RemoveAllQueryItems(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})
	}
}

func (ptr *QUrlQuery) RemoveQueryItem(key string) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QUrlQuery_RemoveQueryItem(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))})
	}
}

func (ptr *QUrlQuery) SetQuery(queryString string) {
	if ptr.Pointer() != nil {
		var queryStringC *C.char
		if queryString != "" {
			queryStringC = C.CString(queryString)
			defer C.free(unsafe.Pointer(queryStringC))
		}
		C.QUrlQuery_SetQuery(ptr.Pointer(), C.struct_QtCore_PackedString{data: queryStringC, len: C.longlong(len(queryString))})
	}
}

func (ptr *QUrlQuery) SetQueryDelimiters(valueDelimiter QChar_ITF, pairDelimiter QChar_ITF) {
	if ptr.Pointer() != nil {
		C.QUrlQuery_SetQueryDelimiters(ptr.Pointer(), PointerFromQChar(valueDelimiter), PointerFromQChar(pairDelimiter))
	}
}

func (ptr *QUrlQuery) Swap(other QUrlQuery_ITF) {
	if ptr.Pointer() != nil {
		C.QUrlQuery_Swap(ptr.Pointer(), PointerFromQUrlQuery(other))
	}
}

func (ptr *QUrlQuery) ToString(encoding QUrl__ComponentFormattingOption) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUrlQuery_ToString(ptr.Pointer(), C.longlong(encoding)))
	}
	return ""
}

func (ptr *QUrlQuery) DestroyQUrlQuery() {
	if ptr.Pointer() != nil {
		C.QUrlQuery_DestroyQUrlQuery(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QUrlTwoFlags struct {
	ptr unsafe.Pointer
}

type QUrlTwoFlags_ITF interface {
	QUrlTwoFlags_PTR() *QUrlTwoFlags
}

func (ptr *QUrlTwoFlags) QUrlTwoFlags_PTR() *QUrlTwoFlags {
	return ptr
}

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

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

func PointerFromQUrlTwoFlags(ptr QUrlTwoFlags_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUrlTwoFlags_PTR().Pointer()
	}
	return nil
}

func NewQUrlTwoFlagsFromPointer(ptr unsafe.Pointer) (n *QUrlTwoFlags) {
	n = new(QUrlTwoFlags)
	n.SetPointer(ptr)
	return
}

func (ptr *QUrlTwoFlags) DestroyQUrlTwoFlags() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QUuid struct {
	ptr unsafe.Pointer
}

type QUuid_ITF interface {
	QUuid_PTR() *QUuid
}

func (ptr *QUuid) QUuid_PTR() *QUuid {
	return ptr
}

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

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

func PointerFromQUuid(ptr QUuid_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUuid_PTR().Pointer()
	}
	return nil
}

func NewQUuidFromPointer(ptr unsafe.Pointer) (n *QUuid) {
	n = new(QUuid)
	n.SetPointer(ptr)
	return
}

func (ptr *QUuid) DestroyQUuid() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QUuid__Variant
//QUuid::Variant
type QUuid__Variant int64

const (
	QUuid__VarUnknown QUuid__Variant = QUuid__Variant(-1)
	QUuid__NCS        QUuid__Variant = QUuid__Variant(0)
	QUuid__DCE        QUuid__Variant = QUuid__Variant(2)
	QUuid__Microsoft  QUuid__Variant = QUuid__Variant(6)
	QUuid__Reserved   QUuid__Variant = QUuid__Variant(7)
)

//go:generate stringer -type=QUuid__Version
//QUuid::Version
type QUuid__Version int64

const (
	QUuid__VerUnknown    QUuid__Version = QUuid__Version(-1)
	QUuid__Time          QUuid__Version = QUuid__Version(1)
	QUuid__EmbeddedPOSIX QUuid__Version = QUuid__Version(2)
	QUuid__Md5           QUuid__Version = QUuid__Version(3)
	QUuid__Name          QUuid__Version = QUuid__Version(QUuid__Md5)
	QUuid__Random        QUuid__Version = QUuid__Version(4)
	QUuid__Sha1          QUuid__Version = QUuid__Version(5)
)

//go:generate stringer -type=QUuid__StringFormat
//QUuid::StringFormat
type QUuid__StringFormat int64

const (
	QUuid__WithBraces    QUuid__StringFormat = QUuid__StringFormat(0)
	QUuid__WithoutBraces QUuid__StringFormat = QUuid__StringFormat(1)
	QUuid__Id128         QUuid__StringFormat = QUuid__StringFormat(3)
)

func NewQUuid2() *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_NewQUuid2())
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func NewQUuid3(l uint, w1 uint16, w2 uint16, b1 string, b2 string, b3 string, b4 string, b5 string, b6 string, b7 string, b8 string) *QUuid {
	var b1C *C.char
	if b1 != "" {
		b1C = C.CString(b1)
		defer C.free(unsafe.Pointer(b1C))
	}
	var b2C *C.char
	if b2 != "" {
		b2C = C.CString(b2)
		defer C.free(unsafe.Pointer(b2C))
	}
	var b3C *C.char
	if b3 != "" {
		b3C = C.CString(b3)
		defer C.free(unsafe.Pointer(b3C))
	}
	var b4C *C.char
	if b4 != "" {
		b4C = C.CString(b4)
		defer C.free(unsafe.Pointer(b4C))
	}
	var b5C *C.char
	if b5 != "" {
		b5C = C.CString(b5)
		defer C.free(unsafe.Pointer(b5C))
	}
	var b6C *C.char
	if b6 != "" {
		b6C = C.CString(b6)
		defer C.free(unsafe.Pointer(b6C))
	}
	var b7C *C.char
	if b7 != "" {
		b7C = C.CString(b7)
		defer C.free(unsafe.Pointer(b7C))
	}
	var b8C *C.char
	if b8 != "" {
		b8C = C.CString(b8)
		defer C.free(unsafe.Pointer(b8C))
	}
	tmpValue := NewQUuidFromPointer(C.QUuid_NewQUuid3(C.uint(uint32(l)), C.ushort(w1), C.ushort(w2), b1C, b2C, b3C, b4C, b5C, b6C, b7C, b8C))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func NewQUuid4(text string) *QUuid {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQUuidFromPointer(C.QUuid_NewQUuid4(C.struct_QtCore_PackedString{data: textC, len: C.longlong(len(text))}))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func NewQUuid(text QByteArray_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_NewQUuid(PointerFromQByteArray(text)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func QUuid_CreateUuid() *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuid())
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func (ptr *QUuid) CreateUuid() *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuid())
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func QUuid_CreateUuidV3(ns QUuid_ITF, baseData QByteArray_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuidV3(PointerFromQUuid(ns), PointerFromQByteArray(baseData)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func (ptr *QUuid) CreateUuidV3(ns QUuid_ITF, baseData QByteArray_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuidV3(PointerFromQUuid(ns), PointerFromQByteArray(baseData)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func QUuid_CreateUuidV32(ns QUuid_ITF, baseData string) *QUuid {
	var baseDataC *C.char
	if baseData != "" {
		baseDataC = C.CString(baseData)
		defer C.free(unsafe.Pointer(baseDataC))
	}
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuidV32(PointerFromQUuid(ns), C.struct_QtCore_PackedString{data: baseDataC, len: C.longlong(len(baseData))}))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func (ptr *QUuid) CreateUuidV32(ns QUuid_ITF, baseData string) *QUuid {
	var baseDataC *C.char
	if baseData != "" {
		baseDataC = C.CString(baseData)
		defer C.free(unsafe.Pointer(baseDataC))
	}
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuidV32(PointerFromQUuid(ns), C.struct_QtCore_PackedString{data: baseDataC, len: C.longlong(len(baseData))}))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func QUuid_CreateUuidV5(ns QUuid_ITF, baseData QByteArray_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuidV5(PointerFromQUuid(ns), PointerFromQByteArray(baseData)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func (ptr *QUuid) CreateUuidV5(ns QUuid_ITF, baseData QByteArray_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuidV5(PointerFromQUuid(ns), PointerFromQByteArray(baseData)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func QUuid_CreateUuidV52(ns QUuid_ITF, baseData string) *QUuid {
	var baseDataC *C.char
	if baseData != "" {
		baseDataC = C.CString(baseData)
		defer C.free(unsafe.Pointer(baseDataC))
	}
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuidV52(PointerFromQUuid(ns), C.struct_QtCore_PackedString{data: baseDataC, len: C.longlong(len(baseData))}))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func (ptr *QUuid) CreateUuidV52(ns QUuid_ITF, baseData string) *QUuid {
	var baseDataC *C.char
	if baseData != "" {
		baseDataC = C.CString(baseData)
		defer C.free(unsafe.Pointer(baseDataC))
	}
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_CreateUuidV52(PointerFromQUuid(ns), C.struct_QtCore_PackedString{data: baseDataC, len: C.longlong(len(baseData))}))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func QUuid_FromRfc4122(bytes QByteArray_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_FromRfc4122(PointerFromQByteArray(bytes)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func (ptr *QUuid) FromRfc4122(bytes QByteArray_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_FromRfc4122(PointerFromQByteArray(bytes)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func QUuid_FromString(text QStringView_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_FromString(PointerFromQStringView(text)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func (ptr *QUuid) FromString(text QStringView_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_FromString(PointerFromQStringView(text)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func QUuid_FromString2(text QLatin1String_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_FromString2(PointerFromQLatin1String(text)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func (ptr *QUuid) FromString2(text QLatin1String_ITF) *QUuid {
	tmpValue := NewQUuidFromPointer(C.QUuid_QUuid_FromString2(PointerFromQLatin1String(text)))
	runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
	return tmpValue
}

func (ptr *QUuid) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUuid_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUuid) ToByteArray() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QUuid_ToByteArray(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QUuid) ToByteArray2(mode QUuid__StringFormat) *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QUuid_ToByteArray2(ptr.Pointer(), C.longlong(mode)))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QUuid) ToRfc4122() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QUuid_ToRfc4122(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QUuid) ToString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUuid_ToString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUuid) ToString2(mode QUuid__StringFormat) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUuid_ToString2(ptr.Pointer(), C.longlong(mode)))
	}
	return ""
}

func (ptr *QUuid) Variant() QUuid__Variant {
	if ptr.Pointer() != nil {
		return QUuid__Variant(C.QUuid_Variant(ptr.Pointer()))
	}
	return 0
}

func (ptr *QUuid) Version() QUuid__Version {
	if ptr.Pointer() != nil {
		return QUuid__Version(C.QUuid_Version(ptr.Pointer()))
	}
	return 0
}

type QVarLengthArray struct {
	ptr unsafe.Pointer
}

type QVarLengthArray_ITF interface {
	QVarLengthArray_PTR() *QVarLengthArray
}

func (ptr *QVarLengthArray) QVarLengthArray_PTR() *QVarLengthArray {
	return ptr
}

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

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

func PointerFromQVarLengthArray(ptr QVarLengthArray_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVarLengthArray_PTR().Pointer()
	}
	return nil
}

func NewQVarLengthArrayFromPointer(ptr unsafe.Pointer) (n *QVarLengthArray) {
	n = new(QVarLengthArray)
	n.SetPointer(ptr)
	return
}

type QVariant struct {
	ptr unsafe.Pointer
}

type QVariant_ITF interface {
	QVariant_PTR() *QVariant
}

func (ptr *QVariant) QVariant_PTR() *QVariant {
	return ptr
}

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

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

func PointerFromQVariant(ptr QVariant_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVariant_PTR().Pointer()
	}
	return nil
}

func NewQVariantFromPointer(ptr unsafe.Pointer) (n *QVariant) {
	n = new(QVariant)
	n.SetPointer(ptr)
	return
}

type qVariant_ITF interface{ ToVariant() *QVariant }

func NewQVariant1(i interface{}) *QVariant {
	switch d := i.(type) {
	case *QVariant:
		return d
	case QVariant__Type:
		return NewQVariant2(d)
	case *QDataStream:
		return NewQVariant4(d)
	case int:
		return NewQVariant5(d)
	case uint:
		return NewQVariant6(d)
	case int64:
		return NewQVariant7(d)
	case uint64:
		return NewQVariant8(d)
	case bool:
		return NewQVariant9(d)
	case float64:
		return NewQVariant10(d)
	case float32:
		return NewQVariant11(d)
	case string:
		return NewQVariant12(d)
	case *QByteArray:
		return NewQVariant13(d)
	case *QBitArray:
		return NewQVariant14(d)
	case *QLatin1String:
		return NewQVariant16(d)
	case []string:
		return NewQVariant17(d)
	case *QChar:
		return NewQVariant18(d)
	case *QDate:
		return NewQVariant19(d)
	case *QTime:
		return NewQVariant20(d)
	case *QDateTime:
		return NewQVariant21(d)
	case []*QVariant:
		return NewQVariant22(d)
	case map[string]*QVariant:
		return NewQVariant23(d)
	case *QSize:
		return NewQVariant25(d)
	case *QSizeF:
		return NewQVariant26(d)
	case *QPoint:
		return NewQVariant27(d)
	case *QPointF:
		return NewQVariant28(d)
	case *QLine:
		return NewQVariant29(d)
	case *QLineF:
		return NewQVariant30(d)
	case *QRect:
		return NewQVariant31(d)
	case *QRectF:
		return NewQVariant32(d)
	case *QLocale:
		return NewQVariant33(d)
	case *QRegExp:
		return NewQVariant34(d)
	case *QRegularExpression:
		return NewQVariant35(d)
	case *QUrl:
		return NewQVariant36(d)
	case *QEasingCurve:
		return NewQVariant37(d)
	case *QUuid:
		return NewQVariant38(d)
	case *QJsonValue:
		return NewQVariant39(d)
	case *QJsonObject:
		return NewQVariant40(d)
	case *QJsonArray:
		return NewQVariant41(d)
	case *QJsonDocument:
		return NewQVariant42(d)
	case *QModelIndex:
		return NewQVariant43(d)
	case *QPersistentModelIndex:
		return NewQVariant44(d)
	case qVariant_ITF:
		return d.ToVariant()
	default:
		return NewQVariant()

	}
}
func (v *QVariant) ToInterface() interface{} {
	switch v.Type() {
	case QVariant__Bool:
		return v.ToBool()
	case QVariant__Int:
		return v.ToInt(nil)
	case QVariant__UInt:
		return v.ToUInt(nil)
	case QVariant__LongLong:
		return v.ToLongLong(nil)
	case QVariant__ULongLong:
		return v.ToULongLong(nil)
	case QVariant__Double:
		return v.ToDouble(nil)
	case QVariant__Char:
		return v.ToChar()
	case QVariant__Map:
		return v.ToMap()
	case QVariant__List:
		return v.ToList()
	case QVariant__String:
		return v.ToString()
	case QVariant__StringList:
		return v.ToStringList()
	case QVariant__ByteArray:
		return v.ToByteArray()
	case QVariant__BitArray:
		return v.ToBitArray()
	case QVariant__Date:
		return v.ToDate()
	case QVariant__Time:
		return v.ToTime()
	case QVariant__DateTime:
		return v.ToDateTime()
	case QVariant__Url:
		return v.ToUrl()
	case QVariant__Locale:
		return v.ToLocale()
	case QVariant__Rect:
		return v.ToRect()
	case QVariant__RectF:
		return v.ToRectF()
	case QVariant__Size:
		return v.ToSize()
	case QVariant__SizeF:
		return v.ToSizeF()
	case QVariant__Line:
		return v.ToLine()
	case QVariant__LineF:
		return v.ToLineF()
	case QVariant__Point:
		return v.ToPoint()
	case QVariant__PointF:
		return v.ToPointF()
	case QVariant__RegExp:
		return v.ToRegExp()
	case QVariant__RegularExpression:
		return v.ToRegularExpression()
	case QVariant__Hash:
		return v.ToHash()
	case QVariant__EasingCurve:
		return v.ToEasingCurve()
	case QVariant__Uuid:
		return v.ToUuid()
	case QVariant__ModelIndex:
		return v.ToModelIndex()
	case QVariant__PersistentModelIndex:
		return v.ToPersistentModelIndex()
	case QVariant__Font:
		return v.ToFont()
	case QVariant__Brush:
		return v.ToBrush()
	case QVariant__Color:
		return v.ToColor()
	case QVariant__Image:
		return v.ToImage()
	case QVariant__Icon:
		return v.ToIcon()

	}
	return v
}

//go:generate stringer -type=QVariant__Type
//QVariant::Type
type QVariant__Type int64

const (
	QVariant__Invalid              QVariant__Type = QVariant__Type(QMetaType__UnknownType)
	QVariant__Bool                 QVariant__Type = QVariant__Type(QMetaType__Bool)
	QVariant__Int                  QVariant__Type = QVariant__Type(QMetaType__Int)
	QVariant__UInt                 QVariant__Type = QVariant__Type(QMetaType__UInt)
	QVariant__LongLong             QVariant__Type = QVariant__Type(QMetaType__LongLong)
	QVariant__ULongLong            QVariant__Type = QVariant__Type(QMetaType__ULongLong)
	QVariant__Double               QVariant__Type = QVariant__Type(QMetaType__Double)
	QVariant__Char                 QVariant__Type = QVariant__Type(QMetaType__QChar)
	QVariant__Map                  QVariant__Type = QVariant__Type(QMetaType__QVariantMap)
	QVariant__List                 QVariant__Type = QVariant__Type(QMetaType__QVariantList)
	QVariant__String               QVariant__Type = QVariant__Type(QMetaType__QString)
	QVariant__StringList           QVariant__Type = QVariant__Type(QMetaType__QStringList)
	QVariant__ByteArray            QVariant__Type = QVariant__Type(QMetaType__QByteArray)
	QVariant__BitArray             QVariant__Type = QVariant__Type(QMetaType__QBitArray)
	QVariant__Date                 QVariant__Type = QVariant__Type(QMetaType__QDate)
	QVariant__Time                 QVariant__Type = QVariant__Type(QMetaType__QTime)
	QVariant__DateTime             QVariant__Type = QVariant__Type(QMetaType__QDateTime)
	QVariant__Url                  QVariant__Type = QVariant__Type(QMetaType__QUrl)
	QVariant__Locale               QVariant__Type = QVariant__Type(QMetaType__QLocale)
	QVariant__Rect                 QVariant__Type = QVariant__Type(QMetaType__QRect)
	QVariant__RectF                QVariant__Type = QVariant__Type(QMetaType__QRectF)
	QVariant__Size                 QVariant__Type = QVariant__Type(QMetaType__QSize)
	QVariant__SizeF                QVariant__Type = QVariant__Type(QMetaType__QSizeF)
	QVariant__Line                 QVariant__Type = QVariant__Type(QMetaType__QLine)
	QVariant__LineF                QVariant__Type = QVariant__Type(QMetaType__QLineF)
	QVariant__Point                QVariant__Type = QVariant__Type(QMetaType__QPoint)
	QVariant__PointF               QVariant__Type = QVariant__Type(QMetaType__QPointF)
	QVariant__RegExp               QVariant__Type = QVariant__Type(QMetaType__QRegExp)
	QVariant__RegularExpression    QVariant__Type = QVariant__Type(QMetaType__QRegularExpression)
	QVariant__Hash                 QVariant__Type = QVariant__Type(QMetaType__QVariantHash)
	QVariant__EasingCurve          QVariant__Type = QVariant__Type(QMetaType__QEasingCurve)
	QVariant__Uuid                 QVariant__Type = QVariant__Type(QMetaType__QUuid)
	QVariant__ModelIndex           QVariant__Type = QVariant__Type(QMetaType__QModelIndex)
	QVariant__PersistentModelIndex QVariant__Type = QVariant__Type(QMetaType__QPersistentModelIndex)
	QVariant__Font                 QVariant__Type = QVariant__Type(QMetaType__QFont)
	QVariant__Pixmap               QVariant__Type = QVariant__Type(QMetaType__QPixmap)
	QVariant__Brush                QVariant__Type = QVariant__Type(QMetaType__QBrush)
	QVariant__Color                QVariant__Type = QVariant__Type(QMetaType__QColor)
	QVariant__Palette              QVariant__Type = QVariant__Type(QMetaType__QPalette)
	QVariant__Image                QVariant__Type = QVariant__Type(QMetaType__QImage)
	QVariant__Polygon              QVariant__Type = QVariant__Type(QMetaType__QPolygon)
	QVariant__Region               QVariant__Type = QVariant__Type(QMetaType__QRegion)
	QVariant__Bitmap               QVariant__Type = QVariant__Type(QMetaType__QBitmap)
	QVariant__Cursor               QVariant__Type = QVariant__Type(QMetaType__QCursor)
	QVariant__KeySequence          QVariant__Type = QVariant__Type(QMetaType__QKeySequence)
	QVariant__Pen                  QVariant__Type = QVariant__Type(QMetaType__QPen)
	QVariant__TextLength           QVariant__Type = QVariant__Type(QMetaType__QTextLength)
	QVariant__TextFormat           QVariant__Type = QVariant__Type(QMetaType__QTextFormat)
	QVariant__Matrix               QVariant__Type = QVariant__Type(QMetaType__QMatrix)
	QVariant__Transform            QVariant__Type = QVariant__Type(QMetaType__QTransform)
	QVariant__Matrix4x4            QVariant__Type = QVariant__Type(QMetaType__QMatrix4x4)
	QVariant__Vector2D             QVariant__Type = QVariant__Type(QMetaType__QVector2D)
	QVariant__Vector3D             QVariant__Type = QVariant__Type(QMetaType__QVector3D)
	QVariant__Vector4D             QVariant__Type = QVariant__Type(QMetaType__QVector4D)
	QVariant__Quaternion           QVariant__Type = QVariant__Type(QMetaType__QQuaternion)
	QVariant__PolygonF             QVariant__Type = QVariant__Type(QMetaType__QPolygonF)
	QVariant__Icon                 QVariant__Type = QVariant__Type(QMetaType__QIcon)
	QVariant__SizePolicy           QVariant__Type = QVariant__Type(QMetaType__QSizePolicy)
	QVariant__UserType             QVariant__Type = QVariant__Type(QMetaType__User)
	QVariant__LastType             QVariant__Type = QVariant__Type(0xffffffff)
)

func NewQVariant() *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant())
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant2(ty QVariant__Type) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant2(C.longlong(ty)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant3(typeId int, copy unsafe.Pointer) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant3(C.int(int32(typeId)), copy))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant4(s QDataStream_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant4(PointerFromQDataStream(s)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant5(val int) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant5(C.int(int32(val))))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant6(val uint) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant6(C.uint(uint32(val))))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant7(val int64) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant7(C.longlong(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant8(val uint64) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant8(C.ulonglong(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant9(val bool) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant9(C.char(int8(qt.GoBoolToInt(val)))))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant10(val float64) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant10(C.double(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant11(val float32) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant11(C.float(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant12(val string) *QVariant {
	var valC *C.char
	if val != "" {
		valC = C.CString(val)
		defer C.free(unsafe.Pointer(valC))
	}
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant12(valC))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant13(val QByteArray_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant13(PointerFromQByteArray(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant14(val QBitArray_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant14(PointerFromQBitArray(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant15(val string) *QVariant {
	var valC *C.char
	if val != "" {
		valC = C.CString(val)
		defer C.free(unsafe.Pointer(valC))
	}
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant15(C.struct_QtCore_PackedString{data: valC, len: C.longlong(len(val))}))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant16(val QLatin1String_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant16(PointerFromQLatin1String(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant17(val []string) *QVariant {
	valC := C.CString(strings.Join(val, "¡¦!"))
	defer C.free(unsafe.Pointer(valC))
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant17(C.struct_QtCore_PackedString{data: valC, len: C.longlong(len(strings.Join(val, "¡¦!")))}))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant18(c QChar_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant18(PointerFromQChar(c)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant19(val QDate_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant19(PointerFromQDate(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant20(val QTime_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant20(PointerFromQTime(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant21(val QDateTime_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant21(PointerFromQDateTime(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant22(val []*QVariant) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant22(func() unsafe.Pointer {
		tmpList := NewQVariantFromPointer(NewQVariantFromPointer(nil).__QVariant_val_newList22())
		for _, v := range val {
			tmpList.__QVariant_val_setList22(v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant23(val map[string]*QVariant) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant23(func() unsafe.Pointer {
		tmpList := NewQVariantFromPointer(NewQVariantFromPointer(nil).__QVariant_val_newList23())
		for k, v := range val {
			tmpList.__QVariant_val_setList23(k, v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant24(val map[string]*QVariant) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant24(func() unsafe.Pointer {
		tmpList := NewQVariantFromPointer(NewQVariantFromPointer(nil).__QVariant_val_newList24())
		for k, v := range val {
			tmpList.__QVariant_val_setList24(k, v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant25(val QSize_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant25(PointerFromQSize(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant26(val QSizeF_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant26(PointerFromQSizeF(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant27(val QPoint_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant27(PointerFromQPoint(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant28(val QPointF_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant28(PointerFromQPointF(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant29(val QLine_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant29(PointerFromQLine(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant30(val QLineF_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant30(PointerFromQLineF(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant31(val QRect_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant31(PointerFromQRect(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant32(val QRectF_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant32(PointerFromQRectF(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant33(l QLocale_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant33(PointerFromQLocale(l)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant34(regExp QRegExp_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant34(PointerFromQRegExp(regExp)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant35(re QRegularExpression_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant35(PointerFromQRegularExpression(re)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant36(val QUrl_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant36(PointerFromQUrl(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant37(val QEasingCurve_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant37(PointerFromQEasingCurve(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant38(val QUuid_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant38(PointerFromQUuid(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant39(val QJsonValue_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant39(PointerFromQJsonValue(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant40(val QJsonObject_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant40(PointerFromQJsonObject(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant41(val QJsonArray_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant41(PointerFromQJsonArray(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant42(val QJsonDocument_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant42(PointerFromQJsonDocument(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant43(val QModelIndex_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant43(PointerFromQModelIndex(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant44(val QPersistentModelIndex_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant44(PointerFromQPersistentModelIndex(val)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func NewQVariant45(other QVariant_ITF) *QVariant {
	tmpValue := NewQVariantFromPointer(C.QVariant_NewQVariant45(PointerFromQVariant(other)))
	runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
	return tmpValue
}

func (ptr *QVariant) Clear() {
	if ptr.Pointer() != nil {
		C.QVariant_Clear(ptr.Pointer())
	}
}

func (ptr *QVariant) Convert(targetTypeId int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QVariant_Convert(ptr.Pointer(), C.int(int32(targetTypeId)))) != 0
	}
	return false
}

func (ptr *QVariant) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QVariant_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QVariant) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QVariant_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func QVariant_NameToType(name string) QVariant__Type {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	return QVariant__Type(C.QVariant_QVariant_NameToType(nameC))
}

func (ptr *QVariant) NameToType(name string) QVariant__Type {
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	return QVariant__Type(C.QVariant_QVariant_NameToType(nameC))
}

func (ptr *QVariant) Swap(other QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QVariant_Swap(ptr.Pointer(), PointerFromQVariant(other))
	}
}

func (ptr *QVariant) ToBitArray() *QBitArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQBitArrayFromPointer(C.QVariant_ToBitArray(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QBitArray).DestroyQBitArray)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToBool() bool {
	if ptr.Pointer() != nil {
		return int8(C.QVariant_ToBool(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QVariant) ToByteArray() *QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQByteArrayFromPointer(C.QVariant_ToByteArray(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToChar() *QChar {
	if ptr.Pointer() != nil {
		tmpValue := NewQCharFromPointer(C.QVariant_ToChar(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QChar).DestroyQChar)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToDate() *QDate {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateFromPointer(C.QVariant_ToDate(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToDateTime() *QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQDateTimeFromPointer(C.QVariant_ToDateTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToDouble(ok *bool) float64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float64(C.QVariant_ToDouble(ptr.Pointer(), &okC))
	}
	return 0
}

func (ptr *QVariant) ToEasingCurve() *QEasingCurve {
	if ptr.Pointer() != nil {
		tmpValue := NewQEasingCurveFromPointer(C.QVariant_ToEasingCurve(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QEasingCurve).DestroyQEasingCurve)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToFloat(ok *bool) float32 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float32(C.QVariant_ToFloat(ptr.Pointer(), &okC))
	}
	return 0
}

func (ptr *QVariant) ToHash() map[string]*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[string]*QVariant {
			out := make(map[string]*QVariant, int(l.len))
			tmpList := NewQVariantFromPointer(l.data)
			for i, v := range tmpList.__toHash_keyList() {
				out[v] = tmpList.__toHash_atList(v, i)
			}
			return out
		}(C.QVariant_ToHash(ptr.Pointer()))
	}
	return make(map[string]*QVariant, 0)
}

func (ptr *QVariant) ToInt(ok *bool) int {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int(int32(C.QVariant_ToInt(ptr.Pointer(), &okC)))
	}
	return 0
}

func (ptr *QVariant) ToJsonArray() *QJsonArray {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonArrayFromPointer(C.QVariant_ToJsonArray(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonArray).DestroyQJsonArray)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToJsonDocument() *QJsonDocument {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonDocumentFromPointer(C.QVariant_ToJsonDocument(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonDocument).DestroyQJsonDocument)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToJsonObject() *QJsonObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonObjectFromPointer(C.QVariant_ToJsonObject(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonObject).DestroyQJsonObject)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToJsonValue() *QJsonValue {
	if ptr.Pointer() != nil {
		tmpValue := NewQJsonValueFromPointer(C.QVariant_ToJsonValue(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QJsonValue).DestroyQJsonValue)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToLine() *QLine {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineFromPointer(C.QVariant_ToLine(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLine).DestroyQLine)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToLineF() *QLineF {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineFFromPointer(C.QVariant_ToLineF(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLineF).DestroyQLineF)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToList() []*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []*QVariant {
			out := make([]*QVariant, int(l.len))
			tmpList := NewQVariantFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__toList_atList(i)
			}
			return out
		}(C.QVariant_ToList(ptr.Pointer()))
	}
	return make([]*QVariant, 0)
}

func (ptr *QVariant) ToLocale() *QLocale {
	if ptr.Pointer() != nil {
		tmpValue := NewQLocaleFromPointer(C.QVariant_ToLocale(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QLocale).DestroyQLocale)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToLongLong(ok *bool) int64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return int64(C.QVariant_ToLongLong(ptr.Pointer(), &okC))
	}
	return 0
}

func (ptr *QVariant) ToMap() map[string]*QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) map[string]*QVariant {
			out := make(map[string]*QVariant, int(l.len))
			tmpList := NewQVariantFromPointer(l.data)
			for i, v := range tmpList.__toMap_keyList() {
				out[v] = tmpList.__toMap_atList(v, i)
			}
			return out
		}(C.QVariant_ToMap(ptr.Pointer()))
	}
	return make(map[string]*QVariant, 0)
}

func (ptr *QVariant) ToModelIndex() *QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQModelIndexFromPointer(C.QVariant_ToModelIndex(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToPersistentModelIndex() *QPersistentModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := NewQPersistentModelIndexFromPointer(C.QVariant_ToPersistentModelIndex(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPersistentModelIndex).DestroyQPersistentModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToPoint() *QPoint {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFromPointer(C.QVariant_ToPoint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToPointF() *QPointF {
	if ptr.Pointer() != nil {
		tmpValue := NewQPointFFromPointer(C.QVariant_ToPointF(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToReal(ok *bool) float64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return float64(C.QVariant_ToReal(ptr.Pointer(), &okC))
	}
	return 0
}

func (ptr *QVariant) ToRect() *QRect {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFromPointer(C.QVariant_ToRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToRectF() *QRectF {
	if ptr.Pointer() != nil {
		tmpValue := NewQRectFFromPointer(C.QVariant_ToRectF(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToRegExp() *QRegExp {
	if ptr.Pointer() != nil {
		tmpValue := NewQRegExpFromPointer(C.QVariant_ToRegExp(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRegExp).DestroyQRegExp)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToRegularExpression() *QRegularExpression {
	if ptr.Pointer() != nil {
		tmpValue := NewQRegularExpressionFromPointer(C.QVariant_ToRegularExpression(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QRegularExpression).DestroyQRegularExpression)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToSize() *QSize {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFromPointer(C.QVariant_ToSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToSizeF() *QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizeFFromPointer(C.QVariant_ToSizeF(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QVariant_ToString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QVariant) ToStringList() []string {
	if ptr.Pointer() != nil {
		return unpackStringList(cGoUnpackString(C.QVariant_ToStringList(ptr.Pointer())))
	}
	return make([]string, 0)
}

func (ptr *QVariant) ToTime() *QTime {
	if ptr.Pointer() != nil {
		tmpValue := NewQTimeFromPointer(C.QVariant_ToTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QTime).DestroyQTime)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToUInt(ok *bool) uint {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint(uint32(C.QVariant_ToUInt(ptr.Pointer(), &okC)))
	}
	return 0
}

func (ptr *QVariant) ToULongLong(ok *bool) uint64 {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		return uint64(C.QVariant_ToULongLong(ptr.Pointer(), &okC))
	}
	return 0
}

func (ptr *QVariant) ToUrl() *QUrl {
	if ptr.Pointer() != nil {
		tmpValue := NewQUrlFromPointer(C.QVariant_ToUrl(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToUuid() *QUuid {
	if ptr.Pointer() != nil {
		tmpValue := NewQUuidFromPointer(C.QVariant_ToUuid(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QUuid).DestroyQUuid)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) Type() QVariant__Type {
	if ptr.Pointer() != nil {
		return QVariant__Type(C.QVariant_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QVariant) TypeName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QVariant_TypeName(ptr.Pointer()))
	}
	return ""
}

func QVariant_TypeToName(typeId int) string {
	return cGoUnpackString(C.QVariant_QVariant_TypeToName(C.int(int32(typeId))))
}

func (ptr *QVariant) TypeToName(typeId int) string {
	return cGoUnpackString(C.QVariant_QVariant_TypeToName(C.int(int32(typeId))))
}

func (ptr *QVariant) UserType() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVariant_UserType(ptr.Pointer())))
	}
	return 0
}

func (ptr *QVariant) DestroyQVariant() {
	if ptr.Pointer() != nil {
		C.QVariant_DestroyQVariant(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QVariant) ToColor() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QVariant_ToColor(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToFont() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QVariant_ToFont(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToImage() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QVariant_ToImage(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToObject() *QObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQObjectFromPointer(C.QVariant_ToObject(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) ToIcon() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QVariant_ToIcon(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToBrush() unsafe.Pointer {
	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QVariant_ToBrush(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) __QVariant_val_atList22(i int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QVariant___QVariant_val_atList22(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) __QVariant_val_setList22(i QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QVariant___QVariant_val_setList22(ptr.Pointer(), PointerFromQVariant(i))
	}
}

func (ptr *QVariant) __QVariant_val_newList22() unsafe.Pointer {
	return C.QVariant___QVariant_val_newList22(ptr.Pointer())
}

func (ptr *QVariant) __QVariant_val_atList23(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QVariant___QVariant_val_atList23(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) __QVariant_val_setList23(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QVariant___QVariant_val_setList23(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QVariant) __QVariant_val_newList23() unsafe.Pointer {
	return C.QVariant___QVariant_val_newList23(ptr.Pointer())
}

func (ptr *QVariant) __QVariant_val_keyList23() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQVariantFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____QVariant_val_keyList_atList23(i)
			}
			return out
		}(C.QVariant___QVariant_val_keyList23(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QVariant) __QVariant_val_atList24(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QVariant___QVariant_val_atList24(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) __QVariant_val_setList24(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QVariant___QVariant_val_setList24(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QVariant) __QVariant_val_newList24() unsafe.Pointer {
	return C.QVariant___QVariant_val_newList24(ptr.Pointer())
}

func (ptr *QVariant) __QVariant_val_keyList24() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQVariantFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____QVariant_val_keyList_atList24(i)
			}
			return out
		}(C.QVariant___QVariant_val_keyList24(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QVariant) __toHash_atList(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QVariant___toHash_atList(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) __toHash_setList(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QVariant___toHash_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QVariant) __toHash_newList() unsafe.Pointer {
	return C.QVariant___toHash_newList(ptr.Pointer())
}

func (ptr *QVariant) __toHash_keyList() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQVariantFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____toHash_keyList_atList(i)
			}
			return out
		}(C.QVariant___toHash_keyList(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QVariant) __toList_atList(i int) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QVariant___toList_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) __toList_setList(i QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QVariant___toList_setList(ptr.Pointer(), PointerFromQVariant(i))
	}
}

func (ptr *QVariant) __toList_newList() unsafe.Pointer {
	return C.QVariant___toList_newList(ptr.Pointer())
}

func (ptr *QVariant) __toMap_atList(v string, i int) *QVariant {
	if ptr.Pointer() != nil {
		var vC *C.char
		if v != "" {
			vC = C.CString(v)
			defer C.free(unsafe.Pointer(vC))
		}
		tmpValue := NewQVariantFromPointer(C.QVariant___toMap_atList(ptr.Pointer(), C.struct_QtCore_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QVariant) __toMap_setList(key string, i QVariant_ITF) {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		C.QVariant___toMap_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: keyC, len: C.longlong(len(key))}, PointerFromQVariant(i))
	}
}

func (ptr *QVariant) __toMap_newList() unsafe.Pointer {
	return C.QVariant___toMap_newList(ptr.Pointer())
}

func (ptr *QVariant) __toMap_keyList() []string {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []string {
			out := make([]string, int(l.len))
			tmpList := NewQVariantFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____toMap_keyList_atList(i)
			}
			return out
		}(C.QVariant___toMap_keyList(ptr.Pointer()))
	}
	return make([]string, 0)
}

func (ptr *QVariant) ____QVariant_val_keyList_atList23(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QVariant_____QVariant_val_keyList_atList23(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QVariant) ____QVariant_val_keyList_setList23(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QVariant_____QVariant_val_keyList_setList23(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QVariant) ____QVariant_val_keyList_newList23() unsafe.Pointer {
	return C.QVariant_____QVariant_val_keyList_newList23(ptr.Pointer())
}

func (ptr *QVariant) ____QVariant_val_keyList_atList24(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QVariant_____QVariant_val_keyList_atList24(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QVariant) ____QVariant_val_keyList_setList24(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QVariant_____QVariant_val_keyList_setList24(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QVariant) ____QVariant_val_keyList_newList24() unsafe.Pointer {
	return C.QVariant_____QVariant_val_keyList_newList24(ptr.Pointer())
}

func (ptr *QVariant) ____toHash_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QVariant_____toHash_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QVariant) ____toHash_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QVariant_____toHash_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QVariant) ____toHash_keyList_newList() unsafe.Pointer {
	return C.QVariant_____toHash_keyList_newList(ptr.Pointer())
}

func (ptr *QVariant) ____toMap_keyList_atList(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QVariant_____toMap_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QVariant) ____toMap_keyList_setList(i string) {
	if ptr.Pointer() != nil {
		var iC *C.char
		if i != "" {
			iC = C.CString(i)
			defer C.free(unsafe.Pointer(iC))
		}
		C.QVariant_____toMap_keyList_setList(ptr.Pointer(), C.struct_QtCore_PackedString{data: iC, len: C.longlong(len(i))})
	}
}

func (ptr *QVariant) ____toMap_keyList_newList() unsafe.Pointer {
	return C.QVariant_____toMap_keyList_newList(ptr.Pointer())
}

type QVariantAnimation struct {
	QAbstractAnimation
}

type QVariantAnimation_ITF interface {
	QAbstractAnimation_ITF
	QVariantAnimation_PTR() *QVariantAnimation
}

func (ptr *QVariantAnimation) QVariantAnimation_PTR() *QVariantAnimation {
	return ptr
}

func (ptr *QVariantAnimation) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractAnimation_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQVariantAnimation(ptr QVariantAnimation_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVariantAnimation_PTR().Pointer()
	}
	return nil
}

func NewQVariantAnimationFromPointer(ptr unsafe.Pointer) (n *QVariantAnimation) {
	n = new(QVariantAnimation)
	n.SetPointer(ptr)
	return
}
func NewQVariantAnimation(parent QObject_ITF) *QVariantAnimation {
	tmpValue := NewQVariantAnimationFromPointer(C.QVariantAnimation_NewQVariantAnimation(PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QVariantAnimation) CurrentValue() *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QVariantAnimation_CurrentValue(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQVariantAnimation_Duration
func callbackQVariantAnimation_Duration(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "duration"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQVariantAnimationFromPointer(ptr).DurationDefault()))
}

func (ptr *QVariantAnimation) ConnectDuration(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "duration"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QVariantAnimation) DisconnectDuration() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "duration")
	}
}

func (ptr *QVariantAnimation) Duration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVariantAnimation_Duration(ptr.Pointer())))
	}
	return 0
}

func (ptr *QVariantAnimation) DurationDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVariantAnimation_DurationDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QVariantAnimation) EasingCurve() *QEasingCurve {
	if ptr.Pointer() != nil {
		tmpValue := NewQEasingCurveFromPointer(C.QVariantAnimation_EasingCurve(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QEasingCurve).DestroyQEasingCurve)
		return tmpValue
	}
	return nil
}

func (ptr *QVariantAnimation) EndValue() *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QVariantAnimation_EndValue(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQVariantAnimation_Interpolated
func callbackQVariantAnimation_Interpolated(ptr unsafe.Pointer, from unsafe.Pointer, to unsafe.Pointer, progress C.double) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "interpolated"); signal != nil {
		return PointerFromQVariant((*(*func(*QVariant, *QVariant, float64) *QVariant)(signal))(NewQVariantFromPointer(from), NewQVariantFromPointer(to), float64(progress)))
	}

	return PointerFromQVariant(NewQVariantAnimationFromPointer(ptr).InterpolatedDefault(NewQVariantFromPointer(from), NewQVariantFromPointer(to), float64(progress)))
}

func (ptr *QVariantAnimation) ConnectInterpolated(f func(from *QVariant, to *QVariant, progress float64) *QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "interpolated"); signal != nil {
			f := func(from *QVariant, to *QVariant, progress float64) *QVariant {
				(*(*func(*QVariant, *QVariant, float64) *QVariant)(signal))(from, to, progress)
				return f(from, to, progress)
			}
			qt.ConnectSignal(ptr.Pointer(), "interpolated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "interpolated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QVariantAnimation) DisconnectInterpolated() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "interpolated")
	}
}

func (ptr *QVariantAnimation) Interpolated(from QVariant_ITF, to QVariant_ITF, progress float64) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QVariantAnimation_Interpolated(ptr.Pointer(), PointerFromQVariant(from), PointerFromQVariant(to), C.double(progress)))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QVariantAnimation) InterpolatedDefault(from QVariant_ITF, to QVariant_ITF, progress float64) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QVariantAnimation_InterpolatedDefault(ptr.Pointer(), PointerFromQVariant(from), PointerFromQVariant(to), C.double(progress)))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QVariantAnimation) KeyValueAt(step float64) *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QVariantAnimation_KeyValueAt(ptr.Pointer(), C.double(step)))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QVariantAnimation) SetDuration(msecs int) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetDuration(ptr.Pointer(), C.int(int32(msecs)))
	}
}

func (ptr *QVariantAnimation) SetEasingCurve(easing QEasingCurve_ITF) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetEasingCurve(ptr.Pointer(), PointerFromQEasingCurve(easing))
	}
}

func (ptr *QVariantAnimation) SetEndValue(value QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetEndValue(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) SetKeyValueAt(step float64, value QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetKeyValueAt(ptr.Pointer(), C.double(step), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) SetStartValue(value QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetStartValue(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) StartValue() *QVariant {
	if ptr.Pointer() != nil {
		tmpValue := NewQVariantFromPointer(C.QVariantAnimation_StartValue(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQVariantAnimation_UpdateCurrentTime
func callbackQVariantAnimation_UpdateCurrentTime(ptr unsafe.Pointer, vin C.int) {
	if signal := qt.GetSignal(ptr, "updateCurrentTime"); signal != nil {
		(*(*func(int))(signal))(int(int32(vin)))
	} else {
		NewQVariantAnimationFromPointer(ptr).UpdateCurrentTimeDefault(int(int32(vin)))
	}
}

func (ptr *QVariantAnimation) ConnectUpdateCurrentTime(f func(vin int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateCurrentTime"); signal != nil {
			f := func(vin int) {
				(*(*func(int))(signal))(vin)
				f(vin)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QVariantAnimation) DisconnectUpdateCurrentTime() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateCurrentTime")
	}
}

func (ptr *QVariantAnimation) UpdateCurrentTime(vin int) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QVariantAnimation) UpdateCurrentTimeDefault(vin int) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(int32(vin)))
	}
}

//export callbackQVariantAnimation_UpdateCurrentValue
func callbackQVariantAnimation_UpdateCurrentValue(ptr unsafe.Pointer, value unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateCurrentValue"); signal != nil {
		(*(*func(*QVariant))(signal))(NewQVariantFromPointer(value))
	} else {
		NewQVariantAnimationFromPointer(ptr).UpdateCurrentValueDefault(NewQVariantFromPointer(value))
	}
}

func (ptr *QVariantAnimation) ConnectUpdateCurrentValue(f func(value *QVariant)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateCurrentValue"); signal != nil {
			f := func(value *QVariant) {
				(*(*func(*QVariant))(signal))(value)
				f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentValue", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateCurrentValue", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QVariantAnimation) DisconnectUpdateCurrentValue() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateCurrentValue")
	}
}

func (ptr *QVariantAnimation) UpdateCurrentValue(value QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateCurrentValue(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) UpdateCurrentValueDefault(value QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateCurrentValueDefault(ptr.Pointer(), PointerFromQVariant(value))
	}
}

//export callbackQVariantAnimation_ValueChanged
func callbackQVariantAnimation_ValueChanged(ptr unsafe.Pointer, value unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "valueChanged"); signal != nil {
		(*(*func(*QVariant))(signal))(NewQVariantFromPointer(value))
	}

}

func (ptr *QVariantAnimation) ConnectValueChanged(f func(value *QVariant)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "valueChanged") {
			C.QVariantAnimation_ConnectValueChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "valueChanged")))
		}

		if signal := qt.LendSignal(ptr.Pointer(), "valueChanged"); signal != nil {
			f := func(value *QVariant) {
				(*(*func(*QVariant))(signal))(value)
				f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QVariantAnimation) DisconnectValueChanged() {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_DisconnectValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "valueChanged")
	}
}

func (ptr *QVariantAnimation) ValueChanged(value QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_ValueChanged(ptr.Pointer(), PointerFromQVariant(value))
	}
}

//export callbackQVariantAnimation_DestroyQVariantAnimation
func callbackQVariantAnimation_DestroyQVariantAnimation(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QVariantAnimation"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQVariantAnimationFromPointer(ptr).DestroyQVariantAnimationDefault()
	}
}

func (ptr *QVariantAnimation) ConnectDestroyQVariantAnimation(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QVariantAnimation"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QVariantAnimation", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QVariantAnimation", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QVariantAnimation) DisconnectDestroyQVariantAnimation() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QVariantAnimation")
	}
}

func (ptr *QVariantAnimation) DestroyQVariantAnimation() {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_DestroyQVariantAnimation(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QVariantAnimation) DestroyQVariantAnimationDefault() {
	if ptr.Pointer() != nil {
		C.QVariantAnimation_DestroyQVariantAnimationDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QVector struct {
	ptr unsafe.Pointer
}

type QVector_ITF interface {
	QVector_PTR() *QVector
}

func (ptr *QVector) QVector_PTR() *QVector {
	return ptr
}

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

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

func PointerFromQVector(ptr QVector_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVector_PTR().Pointer()
	}
	return nil
}

func NewQVectorFromPointer(ptr unsafe.Pointer) (n *QVector) {
	n = new(QVector)
	n.SetPointer(ptr)
	return
}

type QVectorIterator struct {
	ptr unsafe.Pointer
}

type QVectorIterator_ITF interface {
	QVectorIterator_PTR() *QVectorIterator
}

func (ptr *QVectorIterator) QVectorIterator_PTR() *QVectorIterator {
	return ptr
}

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

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

func PointerFromQVectorIterator(ptr QVectorIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVectorIterator_PTR().Pointer()
	}
	return nil
}

func NewQVectorIteratorFromPointer(ptr unsafe.Pointer) (n *QVectorIterator) {
	n = new(QVectorIterator)
	n.SetPointer(ptr)
	return
}

func (ptr *QVectorIterator) DestroyQVectorIterator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QVersionNumber struct {
	ptr unsafe.Pointer
}

type QVersionNumber_ITF interface {
	QVersionNumber_PTR() *QVersionNumber
}

func (ptr *QVersionNumber) QVersionNumber_PTR() *QVersionNumber {
	return ptr
}

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

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

func PointerFromQVersionNumber(ptr QVersionNumber_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVersionNumber_PTR().Pointer()
	}
	return nil
}

func NewQVersionNumberFromPointer(ptr unsafe.Pointer) (n *QVersionNumber) {
	n = new(QVersionNumber)
	n.SetPointer(ptr)
	return
}

func (ptr *QVersionNumber) DestroyQVersionNumber() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQVersionNumber() *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber())
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func NewQVersionNumber2(seg []int) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber2(func() unsafe.Pointer {
		tmpList := NewQVersionNumberFromPointer(NewQVersionNumberFromPointer(nil).__QVersionNumber_seg_newList2())
		for _, v := range seg {
			tmpList.__QVersionNumber_seg_setList2(v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func NewQVersionNumber3(seg []int) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber3(func() unsafe.Pointer {
		tmpList := NewQVersionNumberFromPointer(NewQVersionNumberFromPointer(nil).__QVersionNumber_seg_newList3())
		for _, v := range seg {
			tmpList.__QVersionNumber_seg_setList3(v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func NewQVersionNumber5(maj int) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber5(C.int(int32(maj))))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func NewQVersionNumber6(maj int, min int) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber6(C.int(int32(maj)), C.int(int32(min))))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func NewQVersionNumber7(maj int, min int, mic int) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_NewQVersionNumber7(C.int(int32(maj)), C.int(int32(min)), C.int(int32(mic))))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func QVersionNumber_CommonPrefix(v1 QVersionNumber_ITF, v2 QVersionNumber_ITF) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_QVersionNumber_CommonPrefix(PointerFromQVersionNumber(v1), PointerFromQVersionNumber(v2)))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func (ptr *QVersionNumber) CommonPrefix(v1 QVersionNumber_ITF, v2 QVersionNumber_ITF) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_QVersionNumber_CommonPrefix(PointerFromQVersionNumber(v1), PointerFromQVersionNumber(v2)))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func QVersionNumber_Compare(v1 QVersionNumber_ITF, v2 QVersionNumber_ITF) int {
	return int(int32(C.QVersionNumber_QVersionNumber_Compare(PointerFromQVersionNumber(v1), PointerFromQVersionNumber(v2))))
}

func (ptr *QVersionNumber) Compare(v1 QVersionNumber_ITF, v2 QVersionNumber_ITF) int {
	return int(int32(C.QVersionNumber_QVersionNumber_Compare(PointerFromQVersionNumber(v1), PointerFromQVersionNumber(v2))))
}

func QVersionNumber_FromString(stri string, suffixIndex int) *QVersionNumber {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_QVersionNumber_FromString(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.int(int32(suffixIndex))))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func (ptr *QVersionNumber) FromString(stri string, suffixIndex int) *QVersionNumber {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_QVersionNumber_FromString(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}, C.int(int32(suffixIndex))))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func QVersionNumber_FromString2(stri QLatin1String_ITF, suffixIndex int) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_QVersionNumber_FromString2(PointerFromQLatin1String(stri), C.int(int32(suffixIndex))))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func (ptr *QVersionNumber) FromString2(stri QLatin1String_ITF, suffixIndex int) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_QVersionNumber_FromString2(PointerFromQLatin1String(stri), C.int(int32(suffixIndex))))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func QVersionNumber_FromString3(stri QStringView_ITF, suffixIndex int) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_QVersionNumber_FromString3(PointerFromQStringView(stri), C.int(int32(suffixIndex))))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func (ptr *QVersionNumber) FromString3(stri QStringView_ITF, suffixIndex int) *QVersionNumber {
	tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_QVersionNumber_FromString3(PointerFromQStringView(stri), C.int(int32(suffixIndex))))
	runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
	return tmpValue
}

func (ptr *QVersionNumber) IsNormalized() bool {
	if ptr.Pointer() != nil {
		return int8(C.QVersionNumber_IsNormalized(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QVersionNumber) IsNull() bool {
	if ptr.Pointer() != nil {
		return int8(C.QVersionNumber_IsNull(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QVersionNumber) IsPrefixOf(other QVersionNumber_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QVersionNumber_IsPrefixOf(ptr.Pointer(), PointerFromQVersionNumber(other))) != 0
	}
	return false
}

func (ptr *QVersionNumber) MajorVersion() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVersionNumber_MajorVersion(ptr.Pointer())))
	}
	return 0
}

func (ptr *QVersionNumber) MicroVersion() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVersionNumber_MicroVersion(ptr.Pointer())))
	}
	return 0
}

func (ptr *QVersionNumber) MinorVersion() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVersionNumber_MinorVersion(ptr.Pointer())))
	}
	return 0
}

func (ptr *QVersionNumber) Normalized() *QVersionNumber {
	if ptr.Pointer() != nil {
		tmpValue := NewQVersionNumberFromPointer(C.QVersionNumber_Normalized(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QVersionNumber).DestroyQVersionNumber)
		return tmpValue
	}
	return nil
}

func (ptr *QVersionNumber) SegmentAt(index int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVersionNumber_SegmentAt(ptr.Pointer(), C.int(int32(index)))))
	}
	return 0
}

func (ptr *QVersionNumber) SegmentCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVersionNumber_SegmentCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QVersionNumber) Segments() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtCore_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQVersionNumberFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__segments_atList(i)
			}
			return out
		}(C.QVersionNumber_Segments(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QVersionNumber) ToString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QVersionNumber_ToString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QVersionNumber) __QVersionNumber_seg_atList2(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVersionNumber___QVersionNumber_seg_atList2(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QVersionNumber) __QVersionNumber_seg_setList2(i int) {
	if ptr.Pointer() != nil {
		C.QVersionNumber___QVersionNumber_seg_setList2(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QVersionNumber) __QVersionNumber_seg_newList2() unsafe.Pointer {
	return C.QVersionNumber___QVersionNumber_seg_newList2(ptr.Pointer())
}

func (ptr *QVersionNumber) __QVersionNumber_seg_atList3(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVersionNumber___QVersionNumber_seg_atList3(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QVersionNumber) __QVersionNumber_seg_setList3(i int) {
	if ptr.Pointer() != nil {
		C.QVersionNumber___QVersionNumber_seg_setList3(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QVersionNumber) __QVersionNumber_seg_newList3() unsafe.Pointer {
	return C.QVersionNumber___QVersionNumber_seg_newList3(ptr.Pointer())
}

func (ptr *QVersionNumber) __segments_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QVersionNumber___segments_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QVersionNumber) __segments_setList(i int) {
	if ptr.Pointer() != nil {
		C.QVersionNumber___segments_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QVersionNumber) __segments_newList() unsafe.Pointer {
	return C.QVersionNumber___segments_newList(ptr.Pointer())
}

type QWaitCondition struct {
	ptr unsafe.Pointer
}

type QWaitCondition_ITF interface {
	QWaitCondition_PTR() *QWaitCondition
}

func (ptr *QWaitCondition) QWaitCondition_PTR() *QWaitCondition {
	return ptr
}

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

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

func PointerFromQWaitCondition(ptr QWaitCondition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWaitCondition_PTR().Pointer()
	}
	return nil
}

func NewQWaitConditionFromPointer(ptr unsafe.Pointer) (n *QWaitCondition) {
	n = new(QWaitCondition)
	n.SetPointer(ptr)
	return
}
func NewQWaitCondition() *QWaitCondition {
	tmpValue := NewQWaitConditionFromPointer(C.QWaitCondition_NewQWaitCondition())
	runtime.SetFinalizer(tmpValue, (*QWaitCondition).DestroyQWaitCondition)
	return tmpValue
}

func (ptr *QWaitCondition) Notify_all() {
	if ptr.Pointer() != nil {
		C.QWaitCondition_Notify_all(ptr.Pointer())
	}
}

func (ptr *QWaitCondition) Notify_one() {
	if ptr.Pointer() != nil {
		C.QWaitCondition_Notify_one(ptr.Pointer())
	}
}

func (ptr *QWaitCondition) Wait(lockedMutex QMutex_ITF, ti uint) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWaitCondition_Wait(ptr.Pointer(), PointerFromQMutex(lockedMutex), C.ulong(uint32(ti)))) != 0
	}
	return false
}

func (ptr *QWaitCondition) Wait3(lockedReadWriteLock QReadWriteLock_ITF, ti uint) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWaitCondition_Wait3(ptr.Pointer(), PointerFromQReadWriteLock(lockedReadWriteLock), C.ulong(uint32(ti)))) != 0
	}
	return false
}

func (ptr *QWaitCondition) WakeAll() {
	if ptr.Pointer() != nil {
		C.QWaitCondition_WakeAll(ptr.Pointer())
	}
}

func (ptr *QWaitCondition) WakeOne() {
	if ptr.Pointer() != nil {
		C.QWaitCondition_WakeOne(ptr.Pointer())
	}
}

func (ptr *QWaitCondition) DestroyQWaitCondition() {
	if ptr.Pointer() != nil {
		C.QWaitCondition_DestroyQWaitCondition(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QWeakPointer struct {
	ptr unsafe.Pointer
}

type QWeakPointer_ITF interface {
	QWeakPointer_PTR() *QWeakPointer
}

func (ptr *QWeakPointer) QWeakPointer_PTR() *QWeakPointer {
	return ptr
}

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

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

func PointerFromQWeakPointer(ptr QWeakPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWeakPointer_PTR().Pointer()
	}
	return nil
}

func NewQWeakPointerFromPointer(ptr unsafe.Pointer) (n *QWeakPointer) {
	n = new(QWeakPointer)
	n.SetPointer(ptr)
	return
}

type QWinEventNotifier struct {
	QObject
}

type QWinEventNotifier_ITF interface {
	QObject_ITF
	QWinEventNotifier_PTR() *QWinEventNotifier
}

func (ptr *QWinEventNotifier) QWinEventNotifier_PTR() *QWinEventNotifier {
	return ptr
}

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

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

func PointerFromQWinEventNotifier(ptr QWinEventNotifier_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWinEventNotifier_PTR().Pointer()
	}
	return nil
}

func NewQWinEventNotifierFromPointer(ptr unsafe.Pointer) (n *QWinEventNotifier) {
	n = new(QWinEventNotifier)
	n.SetPointer(ptr)
	return
}

type QWriteLocker struct {
	ptr unsafe.Pointer
}

type QWriteLocker_ITF interface {
	QWriteLocker_PTR() *QWriteLocker
}

func (ptr *QWriteLocker) QWriteLocker_PTR() *QWriteLocker {
	return ptr
}

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

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

func PointerFromQWriteLocker(ptr QWriteLocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWriteLocker_PTR().Pointer()
	}
	return nil
}

func NewQWriteLockerFromPointer(ptr unsafe.Pointer) (n *QWriteLocker) {
	n = new(QWriteLocker)
	n.SetPointer(ptr)
	return
}
func NewQWriteLocker(lock QReadWriteLock_ITF) *QWriteLocker {
	tmpValue := NewQWriteLockerFromPointer(C.QWriteLocker_NewQWriteLocker(PointerFromQReadWriteLock(lock)))
	runtime.SetFinalizer(tmpValue, (*QWriteLocker).DestroyQWriteLocker)
	return tmpValue
}

func (ptr *QWriteLocker) ReadWriteLock() *QReadWriteLock {
	if ptr.Pointer() != nil {
		return NewQReadWriteLockFromPointer(C.QWriteLocker_ReadWriteLock(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWriteLocker) Relock() {
	if ptr.Pointer() != nil {
		C.QWriteLocker_Relock(ptr.Pointer())
	}
}

func (ptr *QWriteLocker) Unlock() {
	if ptr.Pointer() != nil {
		C.QWriteLocker_Unlock(ptr.Pointer())
	}
}

func (ptr *QWriteLocker) DestroyQWriteLocker() {
	if ptr.Pointer() != nil {
		C.QWriteLocker_DestroyQWriteLocker(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QXmlStreamAttribute struct {
	ptr unsafe.Pointer
}

type QXmlStreamAttribute_ITF interface {
	QXmlStreamAttribute_PTR() *QXmlStreamAttribute
}

func (ptr *QXmlStreamAttribute) QXmlStreamAttribute_PTR() *QXmlStreamAttribute {
	return ptr
}

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

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

func PointerFromQXmlStreamAttribute(ptr QXmlStreamAttribute_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamAttribute_PTR().Pointer()
	}
	return nil
}

func NewQXmlStreamAttributeFromPointer(ptr unsafe.Pointer) (n *QXmlStreamAttribute) {
	n = new(QXmlStreamAttribute)
	n.SetPointer(ptr)
	return
}
func NewQXmlStreamAttribute() *QXmlStreamAttribute {
	tmpValue := NewQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute())
	runtime.SetFinalizer(tmpValue, (*QXmlStreamAttribute).DestroyQXmlStreamAttribute)
	return tmpValue
}

func NewQXmlStreamAttribute2(qualifiedName string, value string) *QXmlStreamAttribute {
	var qualifiedNameC *C.char
	if qualifiedName != "" {
		qualifiedNameC = C.CString(qualifiedName)
		defer C.free(unsafe.Pointer(qualifiedNameC))
	}
	var valueC *C.char
	if value != "" {
		valueC = C.CString(value)
		defer C.free(unsafe.Pointer(valueC))
	}
	tmpValue := NewQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute2(C.struct_QtCore_PackedString{data: qualifiedNameC, len: C.longlong(len(qualifiedName))}, C.struct_QtCore_PackedString{data: valueC, len: C.longlong(len(value))}))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamAttribute).DestroyQXmlStreamAttribute)
	return tmpValue
}

func NewQXmlStreamAttribute3(namespaceUri string, name string, value string) *QXmlStreamAttribute {
	var namespaceUriC *C.char
	if namespaceUri != "" {
		namespaceUriC = C.CString(namespaceUri)
		defer C.free(unsafe.Pointer(namespaceUriC))
	}
	var nameC *C.char
	if name != "" {
		nameC = C.CString(name)
		defer C.free(unsafe.Pointer(nameC))
	}
	var valueC *C.char
	if value != "" {
		valueC = C.CString(value)
		defer C.free(unsafe.Pointer(valueC))
	}
	tmpValue := NewQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute3(C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.struct_QtCore_PackedString{data: valueC, len: C.longlong(len(value))}))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamAttribute).DestroyQXmlStreamAttribute)
	return tmpValue
}

func NewQXmlStreamAttribute4(other QXmlStreamAttribute_ITF) *QXmlStreamAttribute {
	tmpValue := NewQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute4(PointerFromQXmlStreamAttribute(other)))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamAttribute).DestroyQXmlStreamAttribute)
	return tmpValue
}

func (ptr *QXmlStreamAttribute) IsDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamAttribute_IsDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamAttribute) Name() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttribute_Name(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamAttribute) NamespaceUri() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttribute_NamespaceUri(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamAttribute) Prefix() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttribute_Prefix(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamAttribute) QualifiedName() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttribute_QualifiedName(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamAttribute) Value() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttribute_Value(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamAttribute) DestroyQXmlStreamAttribute() {
	if ptr.Pointer() != nil {
		C.QXmlStreamAttribute_DestroyQXmlStreamAttribute(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QXmlStreamAttributes struct {
	QVector
}

type QXmlStreamAttributes_ITF interface {
	QVector_ITF
	QXmlStreamAttributes_PTR() *QXmlStreamAttributes
}

func (ptr *QXmlStreamAttributes) QXmlStreamAttributes_PTR() *QXmlStreamAttributes {
	return ptr
}

func (ptr *QXmlStreamAttributes) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QVector_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQXmlStreamAttributes(ptr QXmlStreamAttributes_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamAttributes_PTR().Pointer()
	}
	return nil
}

func NewQXmlStreamAttributesFromPointer(ptr unsafe.Pointer) (n *QXmlStreamAttributes) {
	n = new(QXmlStreamAttributes)
	n.SetPointer(ptr)
	return
}

func (ptr *QXmlStreamAttributes) DestroyQXmlStreamAttributes() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQXmlStreamAttributes() *QXmlStreamAttributes {
	tmpValue := NewQXmlStreamAttributesFromPointer(C.QXmlStreamAttributes_NewQXmlStreamAttributes())
	runtime.SetFinalizer(tmpValue, (*QXmlStreamAttributes).DestroyQXmlStreamAttributes)
	return tmpValue
}

func (ptr *QXmlStreamAttributes) Append(namespaceUri string, name string, value string) {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		var valueC *C.char
		if value != "" {
			valueC = C.CString(value)
			defer C.free(unsafe.Pointer(valueC))
		}
		C.QXmlStreamAttributes_Append(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.struct_QtCore_PackedString{data: valueC, len: C.longlong(len(value))})
	}
}

func (ptr *QXmlStreamAttributes) Append2(qualifiedName string, value string) {
	if ptr.Pointer() != nil {
		var qualifiedNameC *C.char
		if qualifiedName != "" {
			qualifiedNameC = C.CString(qualifiedName)
			defer C.free(unsafe.Pointer(qualifiedNameC))
		}
		var valueC *C.char
		if value != "" {
			valueC = C.CString(value)
			defer C.free(unsafe.Pointer(valueC))
		}
		C.QXmlStreamAttributes_Append2(ptr.Pointer(), C.struct_QtCore_PackedString{data: qualifiedNameC, len: C.longlong(len(qualifiedName))}, C.struct_QtCore_PackedString{data: valueC, len: C.longlong(len(value))})
	}
}

func (ptr *QXmlStreamAttributes) HasAttribute(qualifiedName string) bool {
	if ptr.Pointer() != nil {
		var qualifiedNameC *C.char
		if qualifiedName != "" {
			qualifiedNameC = C.CString(qualifiedName)
			defer C.free(unsafe.Pointer(qualifiedNameC))
		}
		return int8(C.QXmlStreamAttributes_HasAttribute(ptr.Pointer(), C.struct_QtCore_PackedString{data: qualifiedNameC, len: C.longlong(len(qualifiedName))})) != 0
	}
	return false
}

func (ptr *QXmlStreamAttributes) HasAttribute2(qualifiedName QLatin1String_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamAttributes_HasAttribute2(ptr.Pointer(), PointerFromQLatin1String(qualifiedName))) != 0
	}
	return false
}

func (ptr *QXmlStreamAttributes) HasAttribute3(namespaceUri string, name string) bool {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return int8(C.QXmlStreamAttributes_HasAttribute3(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})) != 0
	}
	return false
}

func (ptr *QXmlStreamAttributes) Value(namespaceUri string, name string) *QStringRef {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttributes_Value(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamAttributes) Value2(namespaceUri string, name QLatin1String_ITF) *QStringRef {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttributes_Value2(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, PointerFromQLatin1String(name)))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamAttributes) Value3(namespaceUri QLatin1String_ITF, name QLatin1String_ITF) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttributes_Value3(ptr.Pointer(), PointerFromQLatin1String(namespaceUri), PointerFromQLatin1String(name)))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamAttributes) Value4(qualifiedName string) *QStringRef {
	if ptr.Pointer() != nil {
		var qualifiedNameC *C.char
		if qualifiedName != "" {
			qualifiedNameC = C.CString(qualifiedName)
			defer C.free(unsafe.Pointer(qualifiedNameC))
		}
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttributes_Value4(ptr.Pointer(), C.struct_QtCore_PackedString{data: qualifiedNameC, len: C.longlong(len(qualifiedName))}))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamAttributes) Value5(qualifiedName QLatin1String_ITF) *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamAttributes_Value5(ptr.Pointer(), PointerFromQLatin1String(qualifiedName)))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

type QXmlStreamEntityDeclaration struct {
	ptr unsafe.Pointer
}

type QXmlStreamEntityDeclaration_ITF interface {
	QXmlStreamEntityDeclaration_PTR() *QXmlStreamEntityDeclaration
}

func (ptr *QXmlStreamEntityDeclaration) QXmlStreamEntityDeclaration_PTR() *QXmlStreamEntityDeclaration {
	return ptr
}

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

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

func PointerFromQXmlStreamEntityDeclaration(ptr QXmlStreamEntityDeclaration_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamEntityDeclaration_PTR().Pointer()
	}
	return nil
}

func NewQXmlStreamEntityDeclarationFromPointer(ptr unsafe.Pointer) (n *QXmlStreamEntityDeclaration) {
	n = new(QXmlStreamEntityDeclaration)
	n.SetPointer(ptr)
	return
}
func NewQXmlStreamEntityDeclaration() *QXmlStreamEntityDeclaration {
	tmpValue := NewQXmlStreamEntityDeclarationFromPointer(C.QXmlStreamEntityDeclaration_NewQXmlStreamEntityDeclaration())
	runtime.SetFinalizer(tmpValue, (*QXmlStreamEntityDeclaration).DestroyQXmlStreamEntityDeclaration)
	return tmpValue
}

func NewQXmlStreamEntityDeclaration2(other QXmlStreamEntityDeclaration_ITF) *QXmlStreamEntityDeclaration {
	tmpValue := NewQXmlStreamEntityDeclarationFromPointer(C.QXmlStreamEntityDeclaration_NewQXmlStreamEntityDeclaration2(PointerFromQXmlStreamEntityDeclaration(other)))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamEntityDeclaration).DestroyQXmlStreamEntityDeclaration)
	return tmpValue
}

func (ptr *QXmlStreamEntityDeclaration) Name() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_Name(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) NotationName() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_NotationName(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) PublicId() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_PublicId(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) SystemId() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_SystemId(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) Value() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_Value(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) DestroyQXmlStreamEntityDeclaration() {
	if ptr.Pointer() != nil {
		C.QXmlStreamEntityDeclaration_DestroyQXmlStreamEntityDeclaration(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QXmlStreamEntityResolver struct {
	ptr unsafe.Pointer
}

type QXmlStreamEntityResolver_ITF interface {
	QXmlStreamEntityResolver_PTR() *QXmlStreamEntityResolver
}

func (ptr *QXmlStreamEntityResolver) QXmlStreamEntityResolver_PTR() *QXmlStreamEntityResolver {
	return ptr
}

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

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

func PointerFromQXmlStreamEntityResolver(ptr QXmlStreamEntityResolver_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamEntityResolver_PTR().Pointer()
	}
	return nil
}

func NewQXmlStreamEntityResolverFromPointer(ptr unsafe.Pointer) (n *QXmlStreamEntityResolver) {
	n = new(QXmlStreamEntityResolver)
	n.SetPointer(ptr)
	return
}

//export callbackQXmlStreamEntityResolver_ResolveUndeclaredEntity
func callbackQXmlStreamEntityResolver_ResolveUndeclaredEntity(ptr unsafe.Pointer, name C.struct_QtCore_PackedString) C.struct_QtCore_PackedString {
	if signal := qt.GetSignal(ptr, "resolveUndeclaredEntity"); signal != nil {
		tempVal := (*(*func(string) string)(signal))(cGoUnpackString(name))
		return C.struct_QtCore_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQXmlStreamEntityResolverFromPointer(ptr).ResolveUndeclaredEntityDefault(cGoUnpackString(name))
	return C.struct_QtCore_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QXmlStreamEntityResolver) ConnectResolveUndeclaredEntity(f func(name string) string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resolveUndeclaredEntity"); signal != nil {
			f := func(name string) string {
				(*(*func(string) string)(signal))(name)
				return f(name)
			}
			qt.ConnectSignal(ptr.Pointer(), "resolveUndeclaredEntity", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resolveUndeclaredEntity", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QXmlStreamEntityResolver) DisconnectResolveUndeclaredEntity() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resolveUndeclaredEntity")
	}
}

func (ptr *QXmlStreamEntityResolver) ResolveUndeclaredEntity(name string) string {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return cGoUnpackString(C.QXmlStreamEntityResolver_ResolveUndeclaredEntity(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}))
	}
	return ""
}

func (ptr *QXmlStreamEntityResolver) ResolveUndeclaredEntityDefault(name string) string {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		return cGoUnpackString(C.QXmlStreamEntityResolver_ResolveUndeclaredEntityDefault(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}))
	}
	return ""
}

//export callbackQXmlStreamEntityResolver_DestroyQXmlStreamEntityResolver
func callbackQXmlStreamEntityResolver_DestroyQXmlStreamEntityResolver(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QXmlStreamEntityResolver"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQXmlStreamEntityResolverFromPointer(ptr).DestroyQXmlStreamEntityResolverDefault()
	}
}

func (ptr *QXmlStreamEntityResolver) ConnectDestroyQXmlStreamEntityResolver(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QXmlStreamEntityResolver"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QXmlStreamEntityResolver", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QXmlStreamEntityResolver", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QXmlStreamEntityResolver) DisconnectDestroyQXmlStreamEntityResolver() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QXmlStreamEntityResolver")
	}
}

func (ptr *QXmlStreamEntityResolver) DestroyQXmlStreamEntityResolver() {
	if ptr.Pointer() != nil {
		C.QXmlStreamEntityResolver_DestroyQXmlStreamEntityResolver(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QXmlStreamEntityResolver) DestroyQXmlStreamEntityResolverDefault() {
	if ptr.Pointer() != nil {
		C.QXmlStreamEntityResolver_DestroyQXmlStreamEntityResolverDefault(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

type QXmlStreamNamespaceDeclaration struct {
	ptr unsafe.Pointer
}

type QXmlStreamNamespaceDeclaration_ITF interface {
	QXmlStreamNamespaceDeclaration_PTR() *QXmlStreamNamespaceDeclaration
}

func (ptr *QXmlStreamNamespaceDeclaration) QXmlStreamNamespaceDeclaration_PTR() *QXmlStreamNamespaceDeclaration {
	return ptr
}

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

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

func PointerFromQXmlStreamNamespaceDeclaration(ptr QXmlStreamNamespaceDeclaration_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamNamespaceDeclaration_PTR().Pointer()
	}
	return nil
}

func NewQXmlStreamNamespaceDeclarationFromPointer(ptr unsafe.Pointer) (n *QXmlStreamNamespaceDeclaration) {
	n = new(QXmlStreamNamespaceDeclaration)
	n.SetPointer(ptr)
	return
}
func NewQXmlStreamNamespaceDeclaration() *QXmlStreamNamespaceDeclaration {
	tmpValue := NewQXmlStreamNamespaceDeclarationFromPointer(C.QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration())
	runtime.SetFinalizer(tmpValue, (*QXmlStreamNamespaceDeclaration).DestroyQXmlStreamNamespaceDeclaration)
	return tmpValue
}

func NewQXmlStreamNamespaceDeclaration2(other QXmlStreamNamespaceDeclaration_ITF) *QXmlStreamNamespaceDeclaration {
	tmpValue := NewQXmlStreamNamespaceDeclarationFromPointer(C.QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration2(PointerFromQXmlStreamNamespaceDeclaration(other)))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamNamespaceDeclaration).DestroyQXmlStreamNamespaceDeclaration)
	return tmpValue
}

func NewQXmlStreamNamespaceDeclaration4(prefix string, namespaceUri string) *QXmlStreamNamespaceDeclaration {
	var prefixC *C.char
	if prefix != "" {
		prefixC = C.CString(prefix)
		defer C.free(unsafe.Pointer(prefixC))
	}
	var namespaceUriC *C.char
	if namespaceUri != "" {
		namespaceUriC = C.CString(namespaceUri)
		defer C.free(unsafe.Pointer(namespaceUriC))
	}
	tmpValue := NewQXmlStreamNamespaceDeclarationFromPointer(C.QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration4(C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))}, C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamNamespaceDeclaration).DestroyQXmlStreamNamespaceDeclaration)
	return tmpValue
}

func (ptr *QXmlStreamNamespaceDeclaration) NamespaceUri() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamNamespaceDeclaration_NamespaceUri(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamNamespaceDeclaration) Prefix() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamNamespaceDeclaration_Prefix(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamNamespaceDeclaration) DestroyQXmlStreamNamespaceDeclaration() {
	if ptr.Pointer() != nil {
		C.QXmlStreamNamespaceDeclaration_DestroyQXmlStreamNamespaceDeclaration(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QXmlStreamNotationDeclaration struct {
	ptr unsafe.Pointer
}

type QXmlStreamNotationDeclaration_ITF interface {
	QXmlStreamNotationDeclaration_PTR() *QXmlStreamNotationDeclaration
}

func (ptr *QXmlStreamNotationDeclaration) QXmlStreamNotationDeclaration_PTR() *QXmlStreamNotationDeclaration {
	return ptr
}

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

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

func PointerFromQXmlStreamNotationDeclaration(ptr QXmlStreamNotationDeclaration_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamNotationDeclaration_PTR().Pointer()
	}
	return nil
}

func NewQXmlStreamNotationDeclarationFromPointer(ptr unsafe.Pointer) (n *QXmlStreamNotationDeclaration) {
	n = new(QXmlStreamNotationDeclaration)
	n.SetPointer(ptr)
	return
}
func NewQXmlStreamNotationDeclaration() *QXmlStreamNotationDeclaration {
	tmpValue := NewQXmlStreamNotationDeclarationFromPointer(C.QXmlStreamNotationDeclaration_NewQXmlStreamNotationDeclaration())
	runtime.SetFinalizer(tmpValue, (*QXmlStreamNotationDeclaration).DestroyQXmlStreamNotationDeclaration)
	return tmpValue
}

func NewQXmlStreamNotationDeclaration2(other QXmlStreamNotationDeclaration_ITF) *QXmlStreamNotationDeclaration {
	tmpValue := NewQXmlStreamNotationDeclarationFromPointer(C.QXmlStreamNotationDeclaration_NewQXmlStreamNotationDeclaration2(PointerFromQXmlStreamNotationDeclaration(other)))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamNotationDeclaration).DestroyQXmlStreamNotationDeclaration)
	return tmpValue
}

func (ptr *QXmlStreamNotationDeclaration) Name() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamNotationDeclaration_Name(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamNotationDeclaration) PublicId() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamNotationDeclaration_PublicId(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamNotationDeclaration) SystemId() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamNotationDeclaration_SystemId(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamNotationDeclaration) DestroyQXmlStreamNotationDeclaration() {
	if ptr.Pointer() != nil {
		C.QXmlStreamNotationDeclaration_DestroyQXmlStreamNotationDeclaration(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QXmlStreamReader struct {
	ptr unsafe.Pointer
}

type QXmlStreamReader_ITF interface {
	QXmlStreamReader_PTR() *QXmlStreamReader
}

func (ptr *QXmlStreamReader) QXmlStreamReader_PTR() *QXmlStreamReader {
	return ptr
}

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

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

func PointerFromQXmlStreamReader(ptr QXmlStreamReader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamReader_PTR().Pointer()
	}
	return nil
}

func NewQXmlStreamReaderFromPointer(ptr unsafe.Pointer) (n *QXmlStreamReader) {
	n = new(QXmlStreamReader)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QXmlStreamReader__TokenType
//QXmlStreamReader::TokenType
type QXmlStreamReader__TokenType int64

const (
	QXmlStreamReader__NoToken               QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(0)
	QXmlStreamReader__Invalid               QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(1)
	QXmlStreamReader__StartDocument         QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(2)
	QXmlStreamReader__EndDocument           QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(3)
	QXmlStreamReader__StartElement          QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(4)
	QXmlStreamReader__EndElement            QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(5)
	QXmlStreamReader__Characters            QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(6)
	QXmlStreamReader__Comment               QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(7)
	QXmlStreamReader__DTD                   QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(8)
	QXmlStreamReader__EntityReference       QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(9)
	QXmlStreamReader__ProcessingInstruction QXmlStreamReader__TokenType = QXmlStreamReader__TokenType(10)
)

//go:generate stringer -type=QXmlStreamReader__ReadElementTextBehaviour
//QXmlStreamReader::ReadElementTextBehaviour
type QXmlStreamReader__ReadElementTextBehaviour int64

const (
	QXmlStreamReader__ErrorOnUnexpectedElement QXmlStreamReader__ReadElementTextBehaviour = QXmlStreamReader__ReadElementTextBehaviour(0)
	QXmlStreamReader__IncludeChildElements     QXmlStreamReader__ReadElementTextBehaviour = QXmlStreamReader__ReadElementTextBehaviour(1)
	QXmlStreamReader__SkipChildElements        QXmlStreamReader__ReadElementTextBehaviour = QXmlStreamReader__ReadElementTextBehaviour(2)
)

//go:generate stringer -type=QXmlStreamReader__Error
//QXmlStreamReader::Error
type QXmlStreamReader__Error int64

const (
	QXmlStreamReader__NoError                     QXmlStreamReader__Error = QXmlStreamReader__Error(0)
	QXmlStreamReader__UnexpectedElementError      QXmlStreamReader__Error = QXmlStreamReader__Error(1)
	QXmlStreamReader__CustomError                 QXmlStreamReader__Error = QXmlStreamReader__Error(2)
	QXmlStreamReader__NotWellFormedError          QXmlStreamReader__Error = QXmlStreamReader__Error(3)
	QXmlStreamReader__PrematureEndOfDocumentError QXmlStreamReader__Error = QXmlStreamReader__Error(4)
)

func NewQXmlStreamReader() *QXmlStreamReader {
	tmpValue := NewQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader())
	runtime.SetFinalizer(tmpValue, (*QXmlStreamReader).DestroyQXmlStreamReader)
	return tmpValue
}

func NewQXmlStreamReader2(device QIODevice_ITF) *QXmlStreamReader {
	tmpValue := NewQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader2(PointerFromQIODevice(device)))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamReader).DestroyQXmlStreamReader)
	return tmpValue
}

func NewQXmlStreamReader3(data QByteArray_ITF) *QXmlStreamReader {
	tmpValue := NewQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader3(PointerFromQByteArray(data)))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamReader).DestroyQXmlStreamReader)
	return tmpValue
}

func NewQXmlStreamReader4(data string) *QXmlStreamReader {
	var dataC *C.char
	if data != "" {
		dataC = C.CString(data)
		defer C.free(unsafe.Pointer(dataC))
	}
	tmpValue := NewQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader4(C.struct_QtCore_PackedString{data: dataC, len: C.longlong(len(data))}))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamReader).DestroyQXmlStreamReader)
	return tmpValue
}

func NewQXmlStreamReader5(data string) *QXmlStreamReader {
	var dataC *C.char
	if data != "" {
		dataC = C.CString(data)
		defer C.free(unsafe.Pointer(dataC))
	}
	tmpValue := NewQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader5(dataC))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamReader).DestroyQXmlStreamReader)
	return tmpValue
}

func (ptr *QXmlStreamReader) AddData(data QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QXmlStreamReader_AddData(ptr.Pointer(), PointerFromQByteArray(data))
	}
}

func (ptr *QXmlStreamReader) AddData2(data string) {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if data != "" {
			dataC = C.CString(data)
			defer C.free(unsafe.Pointer(dataC))
		}
		C.QXmlStreamReader_AddData2(ptr.Pointer(), C.struct_QtCore_PackedString{data: dataC, len: C.longlong(len(data))})
	}
}

func (ptr *QXmlStreamReader) AddData3(data string) {
	if ptr.Pointer() != nil {
		var dataC *C.char
		if data != "" {
			dataC = C.CString(data)
			defer C.free(unsafe.Pointer(dataC))
		}
		C.QXmlStreamReader_AddData3(ptr.Pointer(), dataC)
	}
}

func (ptr *QXmlStreamReader) AddExtraNamespaceDeclaration(extraNamespaceDeclaration QXmlStreamNamespaceDeclaration_ITF) {
	if ptr.Pointer() != nil {
		C.QXmlStreamReader_AddExtraNamespaceDeclaration(ptr.Pointer(), PointerFromQXmlStreamNamespaceDeclaration(extraNamespaceDeclaration))
	}
}

func (ptr *QXmlStreamReader) AtEnd() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_AtEnd(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) CharacterOffset() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QXmlStreamReader_CharacterOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) Clear() {
	if ptr.Pointer() != nil {
		C.QXmlStreamReader_Clear(ptr.Pointer())
	}
}

func (ptr *QXmlStreamReader) ColumnNumber() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QXmlStreamReader_ColumnNumber(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) Device() *QIODevice {
	if ptr.Pointer() != nil {
		tmpValue := NewQIODeviceFromPointer(C.QXmlStreamReader_Device(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) DocumentEncoding() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_DocumentEncoding(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) DocumentVersion() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_DocumentVersion(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) DtdName() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_DtdName(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) DtdPublicId() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_DtdPublicId(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) DtdSystemId() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_DtdSystemId(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) EntityResolver() *QXmlStreamEntityResolver {
	if ptr.Pointer() != nil {
		return NewQXmlStreamEntityResolverFromPointer(C.QXmlStreamReader_EntityResolver(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) Error() QXmlStreamReader__Error {
	if ptr.Pointer() != nil {
		return QXmlStreamReader__Error(C.QXmlStreamReader_Error(ptr.Pointer()))
	}
	return 0
}

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

func (ptr *QXmlStreamReader) HasError() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_HasError(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsCDATA() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsCDATA(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsCharacters() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsCharacters(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsComment() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsComment(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsDTD() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsDTD(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsEndDocument() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsEndDocument(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsEndElement() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsEndElement(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsEntityReference() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsEntityReference(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsProcessingInstruction() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsProcessingInstruction(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsStandaloneDocument() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsStandaloneDocument(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsStartDocument() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsStartDocument(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsStartElement() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsStartElement(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsWhitespace() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_IsWhitespace(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) LineNumber() int64 {
	if ptr.Pointer() != nil {
		return int64(C.QXmlStreamReader_LineNumber(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) Name() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_Name(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) NamespaceProcessing() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_NamespaceProcessing(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) NamespaceUri() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_NamespaceUri(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) Prefix() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_Prefix(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) ProcessingInstructionData() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_ProcessingInstructionData(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) ProcessingInstructionTarget() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_ProcessingInstructionTarget(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) QualifiedName() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_QualifiedName(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) RaiseError(message string) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QXmlStreamReader_RaiseError(ptr.Pointer(), C.struct_QtCore_PackedString{data: messageC, len: C.longlong(len(message))})
	}
}

func (ptr *QXmlStreamReader) ReadElementText(behaviour QXmlStreamReader__ReadElementTextBehaviour) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QXmlStreamReader_ReadElementText(ptr.Pointer(), C.longlong(behaviour)))
	}
	return ""
}

func (ptr *QXmlStreamReader) ReadNext() QXmlStreamReader__TokenType {
	if ptr.Pointer() != nil {
		return QXmlStreamReader__TokenType(C.QXmlStreamReader_ReadNext(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) ReadNextStartElement() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamReader_ReadNextStartElement(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) SetDevice(device QIODevice_ITF) {
	if ptr.Pointer() != nil {
		C.QXmlStreamReader_SetDevice(ptr.Pointer(), PointerFromQIODevice(device))
	}
}

func (ptr *QXmlStreamReader) SetEntityResolver(resolver QXmlStreamEntityResolver_ITF) {
	if ptr.Pointer() != nil {
		C.QXmlStreamReader_SetEntityResolver(ptr.Pointer(), PointerFromQXmlStreamEntityResolver(resolver))
	}
}

func (ptr *QXmlStreamReader) SetNamespaceProcessing(vbo bool) {
	if ptr.Pointer() != nil {
		C.QXmlStreamReader_SetNamespaceProcessing(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QXmlStreamReader) SkipCurrentElement() {
	if ptr.Pointer() != nil {
		C.QXmlStreamReader_SkipCurrentElement(ptr.Pointer())
	}
}

func (ptr *QXmlStreamReader) Text() *QStringRef {
	if ptr.Pointer() != nil {
		tmpValue := NewQStringRefFromPointer(C.QXmlStreamReader_Text(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStringRef).DestroyQStringRef)
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamReader) TokenString() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QXmlStreamReader_TokenString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QXmlStreamReader) TokenType() QXmlStreamReader__TokenType {
	if ptr.Pointer() != nil {
		return QXmlStreamReader__TokenType(C.QXmlStreamReader_TokenType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) DestroyQXmlStreamReader() {
	if ptr.Pointer() != nil {
		C.QXmlStreamReader_DestroyQXmlStreamReader(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QXmlStreamWriter struct {
	ptr unsafe.Pointer
}

type QXmlStreamWriter_ITF interface {
	QXmlStreamWriter_PTR() *QXmlStreamWriter
}

func (ptr *QXmlStreamWriter) QXmlStreamWriter_PTR() *QXmlStreamWriter {
	return ptr
}

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

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

func PointerFromQXmlStreamWriter(ptr QXmlStreamWriter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamWriter_PTR().Pointer()
	}
	return nil
}

func NewQXmlStreamWriterFromPointer(ptr unsafe.Pointer) (n *QXmlStreamWriter) {
	n = new(QXmlStreamWriter)
	n.SetPointer(ptr)
	return
}
func NewQXmlStreamWriter() *QXmlStreamWriter {
	tmpValue := NewQXmlStreamWriterFromPointer(C.QXmlStreamWriter_NewQXmlStreamWriter())
	runtime.SetFinalizer(tmpValue, (*QXmlStreamWriter).DestroyQXmlStreamWriter)
	return tmpValue
}

func NewQXmlStreamWriter2(device QIODevice_ITF) *QXmlStreamWriter {
	tmpValue := NewQXmlStreamWriterFromPointer(C.QXmlStreamWriter_NewQXmlStreamWriter2(PointerFromQIODevice(device)))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamWriter).DestroyQXmlStreamWriter)
	return tmpValue
}

func NewQXmlStreamWriter3(array QByteArray_ITF) *QXmlStreamWriter {
	tmpValue := NewQXmlStreamWriterFromPointer(C.QXmlStreamWriter_NewQXmlStreamWriter3(PointerFromQByteArray(array)))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamWriter).DestroyQXmlStreamWriter)
	return tmpValue
}

func NewQXmlStreamWriter4(stri string) *QXmlStreamWriter {
	var striC *C.char
	if stri != "" {
		striC = C.CString(stri)
		defer C.free(unsafe.Pointer(striC))
	}
	tmpValue := NewQXmlStreamWriterFromPointer(C.QXmlStreamWriter_NewQXmlStreamWriter4(C.struct_QtCore_PackedString{data: striC, len: C.longlong(len(stri))}))
	runtime.SetFinalizer(tmpValue, (*QXmlStreamWriter).DestroyQXmlStreamWriter)
	return tmpValue
}

func (ptr *QXmlStreamWriter) AutoFormatting() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamWriter_AutoFormatting(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamWriter) AutoFormattingIndent() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QXmlStreamWriter_AutoFormattingIndent(ptr.Pointer())))
	}
	return 0
}

func (ptr *QXmlStreamWriter) Codec() *QTextCodec {
	if ptr.Pointer() != nil {
		return NewQTextCodecFromPointer(C.QXmlStreamWriter_Codec(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamWriter) Device() *QIODevice {
	if ptr.Pointer() != nil {
		tmpValue := NewQIODeviceFromPointer(C.QXmlStreamWriter_Device(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QXmlStreamWriter) HasError() bool {
	if ptr.Pointer() != nil {
		return int8(C.QXmlStreamWriter_HasError(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QXmlStreamWriter) SetAutoFormatting(enable bool) {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_SetAutoFormatting(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QXmlStreamWriter) SetAutoFormattingIndent(spacesOrTabs int) {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_SetAutoFormattingIndent(ptr.Pointer(), C.int(int32(spacesOrTabs)))
	}
}

func (ptr *QXmlStreamWriter) SetCodec(codec QTextCodec_ITF) {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_SetCodec(ptr.Pointer(), PointerFromQTextCodec(codec))
	}
}

func (ptr *QXmlStreamWriter) SetCodec2(codecName string) {
	if ptr.Pointer() != nil {
		var codecNameC *C.char
		if codecName != "" {
			codecNameC = C.CString(codecName)
			defer C.free(unsafe.Pointer(codecNameC))
		}
		C.QXmlStreamWriter_SetCodec2(ptr.Pointer(), codecNameC)
	}
}

func (ptr *QXmlStreamWriter) SetDevice(device QIODevice_ITF) {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_SetDevice(ptr.Pointer(), PointerFromQIODevice(device))
	}
}

func (ptr *QXmlStreamWriter) WriteAttribute(namespaceUri string, name string, value string) {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		var valueC *C.char
		if value != "" {
			valueC = C.CString(value)
			defer C.free(unsafe.Pointer(valueC))
		}
		C.QXmlStreamWriter_WriteAttribute(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.struct_QtCore_PackedString{data: valueC, len: C.longlong(len(value))})
	}
}

func (ptr *QXmlStreamWriter) WriteAttribute2(qualifiedName string, value string) {
	if ptr.Pointer() != nil {
		var qualifiedNameC *C.char
		if qualifiedName != "" {
			qualifiedNameC = C.CString(qualifiedName)
			defer C.free(unsafe.Pointer(qualifiedNameC))
		}
		var valueC *C.char
		if value != "" {
			valueC = C.CString(value)
			defer C.free(unsafe.Pointer(valueC))
		}
		C.QXmlStreamWriter_WriteAttribute2(ptr.Pointer(), C.struct_QtCore_PackedString{data: qualifiedNameC, len: C.longlong(len(qualifiedName))}, C.struct_QtCore_PackedString{data: valueC, len: C.longlong(len(value))})
	}
}

func (ptr *QXmlStreamWriter) WriteAttribute3(attribute QXmlStreamAttribute_ITF) {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteAttribute3(ptr.Pointer(), PointerFromQXmlStreamAttribute(attribute))
	}
}

func (ptr *QXmlStreamWriter) WriteAttributes(attributes QXmlStreamAttributes_ITF) {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteAttributes(ptr.Pointer(), PointerFromQXmlStreamAttributes(attributes))
	}
}

func (ptr *QXmlStreamWriter) WriteCDATA(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QXmlStreamWriter_WriteCDATA(ptr.Pointer(), C.struct_QtCore_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QXmlStreamWriter) WriteCharacters(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QXmlStreamWriter_WriteCharacters(ptr.Pointer(), C.struct_QtCore_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QXmlStreamWriter) WriteComment(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QXmlStreamWriter_WriteComment(ptr.Pointer(), C.struct_QtCore_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QXmlStreamWriter) WriteCurrentToken(reader QXmlStreamReader_ITF) {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteCurrentToken(ptr.Pointer(), PointerFromQXmlStreamReader(reader))
	}
}

func (ptr *QXmlStreamWriter) WriteDTD(dtd string) {
	if ptr.Pointer() != nil {
		var dtdC *C.char
		if dtd != "" {
			dtdC = C.CString(dtd)
			defer C.free(unsafe.Pointer(dtdC))
		}
		C.QXmlStreamWriter_WriteDTD(ptr.Pointer(), C.struct_QtCore_PackedString{data: dtdC, len: C.longlong(len(dtd))})
	}
}

func (ptr *QXmlStreamWriter) WriteDefaultNamespace(namespaceUri string) {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		C.QXmlStreamWriter_WriteDefaultNamespace(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))})
	}
}

func (ptr *QXmlStreamWriter) WriteEmptyElement(namespaceUri string, name string) {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QXmlStreamWriter_WriteEmptyElement(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

func (ptr *QXmlStreamWriter) WriteEmptyElement2(qualifiedName string) {
	if ptr.Pointer() != nil {
		var qualifiedNameC *C.char
		if qualifiedName != "" {
			qualifiedNameC = C.CString(qualifiedName)
			defer C.free(unsafe.Pointer(qualifiedNameC))
		}
		C.QXmlStreamWriter_WriteEmptyElement2(ptr.Pointer(), C.struct_QtCore_PackedString{data: qualifiedNameC, len: C.longlong(len(qualifiedName))})
	}
}

func (ptr *QXmlStreamWriter) WriteEndDocument() {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteEndDocument(ptr.Pointer())
	}
}

func (ptr *QXmlStreamWriter) WriteEndElement() {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteEndElement(ptr.Pointer())
	}
}

func (ptr *QXmlStreamWriter) WriteEntityReference(name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QXmlStreamWriter_WriteEntityReference(ptr.Pointer(), C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

func (ptr *QXmlStreamWriter) WriteNamespace(namespaceUri string, prefix string) {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		C.QXmlStreamWriter_WriteNamespace(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, C.struct_QtCore_PackedString{data: prefixC, len: C.longlong(len(prefix))})
	}
}

func (ptr *QXmlStreamWriter) WriteProcessingInstruction(target string, data string) {
	if ptr.Pointer() != nil {
		var targetC *C.char
		if target != "" {
			targetC = C.CString(target)
			defer C.free(unsafe.Pointer(targetC))
		}
		var dataC *C.char
		if data != "" {
			dataC = C.CString(data)
			defer C.free(unsafe.Pointer(dataC))
		}
		C.QXmlStreamWriter_WriteProcessingInstruction(ptr.Pointer(), C.struct_QtCore_PackedString{data: targetC, len: C.longlong(len(target))}, C.struct_QtCore_PackedString{data: dataC, len: C.longlong(len(data))})
	}
}

func (ptr *QXmlStreamWriter) WriteStartDocument(version string) {
	if ptr.Pointer() != nil {
		var versionC *C.char
		if version != "" {
			versionC = C.CString(version)
			defer C.free(unsafe.Pointer(versionC))
		}
		C.QXmlStreamWriter_WriteStartDocument(ptr.Pointer(), C.struct_QtCore_PackedString{data: versionC, len: C.longlong(len(version))})
	}
}

func (ptr *QXmlStreamWriter) WriteStartDocument2() {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteStartDocument2(ptr.Pointer())
	}
}

func (ptr *QXmlStreamWriter) WriteStartDocument3(version string, standalone bool) {
	if ptr.Pointer() != nil {
		var versionC *C.char
		if version != "" {
			versionC = C.CString(version)
			defer C.free(unsafe.Pointer(versionC))
		}
		C.QXmlStreamWriter_WriteStartDocument3(ptr.Pointer(), C.struct_QtCore_PackedString{data: versionC, len: C.longlong(len(version))}, C.char(int8(qt.GoBoolToInt(standalone))))
	}
}

func (ptr *QXmlStreamWriter) WriteStartElement(namespaceUri string, name string) {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QXmlStreamWriter_WriteStartElement(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

func (ptr *QXmlStreamWriter) WriteStartElement2(qualifiedName string) {
	if ptr.Pointer() != nil {
		var qualifiedNameC *C.char
		if qualifiedName != "" {
			qualifiedNameC = C.CString(qualifiedName)
			defer C.free(unsafe.Pointer(qualifiedNameC))
		}
		C.QXmlStreamWriter_WriteStartElement2(ptr.Pointer(), C.struct_QtCore_PackedString{data: qualifiedNameC, len: C.longlong(len(qualifiedName))})
	}
}

func (ptr *QXmlStreamWriter) WriteTextElement(namespaceUri string, name string, text string) {
	if ptr.Pointer() != nil {
		var namespaceUriC *C.char
		if namespaceUri != "" {
			namespaceUriC = C.CString(namespaceUri)
			defer C.free(unsafe.Pointer(namespaceUriC))
		}
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QXmlStreamWriter_WriteTextElement(ptr.Pointer(), C.struct_QtCore_PackedString{data: namespaceUriC, len: C.longlong(len(namespaceUri))}, C.struct_QtCore_PackedString{data: nameC, len: C.longlong(len(name))}, C.struct_QtCore_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QXmlStreamWriter) WriteTextElement2(qualifiedName string, text string) {
	if ptr.Pointer() != nil {
		var qualifiedNameC *C.char
		if qualifiedName != "" {
			qualifiedNameC = C.CString(qualifiedName)
			defer C.free(unsafe.Pointer(qualifiedNameC))
		}
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QXmlStreamWriter_WriteTextElement2(ptr.Pointer(), C.struct_QtCore_PackedString{data: qualifiedNameC, len: C.longlong(len(qualifiedName))}, C.struct_QtCore_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QXmlStreamWriter) DestroyQXmlStreamWriter() {
	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_DestroyQXmlStreamWriter(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type Qt struct {
	ptr unsafe.Pointer
}

type Qt_ITF interface {
	Qt_PTR() *Qt
}

func (ptr *Qt) Qt_PTR() *Qt {
	return ptr
}

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

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

func PointerFromQt(ptr Qt_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.Qt_PTR().Pointer()
	}
	return nil
}

func NewQtFromPointer(ptr unsafe.Pointer) (n *Qt) {
	n = new(Qt)
	n.SetPointer(ptr)
	return
}

func (ptr *Qt) DestroyQt() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=Qt__GlobalColor
//Qt::GlobalColor
type Qt__GlobalColor int64

const (
	Qt__color0      Qt__GlobalColor = Qt__GlobalColor(0)
	Qt__color1      Qt__GlobalColor = Qt__GlobalColor(1)
	Qt__black       Qt__GlobalColor = Qt__GlobalColor(2)
	Qt__white       Qt__GlobalColor = Qt__GlobalColor(3)
	Qt__darkGray    Qt__GlobalColor = Qt__GlobalColor(4)
	Qt__gray        Qt__GlobalColor = Qt__GlobalColor(5)
	Qt__lightGray   Qt__GlobalColor = Qt__GlobalColor(6)
	Qt__red         Qt__GlobalColor = Qt__GlobalColor(7)
	Qt__green       Qt__GlobalColor = Qt__GlobalColor(8)
	Qt__blue        Qt__GlobalColor = Qt__GlobalColor(9)
	Qt__cyan        Qt__GlobalColor = Qt__GlobalColor(10)
	Qt__magenta     Qt__GlobalColor = Qt__GlobalColor(11)
	Qt__yellow      Qt__GlobalColor = Qt__GlobalColor(12)
	Qt__darkRed     Qt__GlobalColor = Qt__GlobalColor(13)
	Qt__darkGreen   Qt__GlobalColor = Qt__GlobalColor(14)
	Qt__darkBlue    Qt__GlobalColor = Qt__GlobalColor(15)
	Qt__darkCyan    Qt__GlobalColor = Qt__GlobalColor(16)
	Qt__darkMagenta Qt__GlobalColor = Qt__GlobalColor(17)
	Qt__darkYellow  Qt__GlobalColor = Qt__GlobalColor(18)
	Qt__transparent Qt__GlobalColor = Qt__GlobalColor(19)
)

//go:generate stringer -type=Qt__KeyboardModifier
//Qt::KeyboardModifier
type Qt__KeyboardModifier int64

const (
	Qt__NoModifier           Qt__KeyboardModifier = Qt__KeyboardModifier(0x00000000)
	Qt__ShiftModifier        Qt__KeyboardModifier = Qt__KeyboardModifier(0x02000000)
	Qt__ControlModifier      Qt__KeyboardModifier = Qt__KeyboardModifier(0x04000000)
	Qt__AltModifier          Qt__KeyboardModifier = Qt__KeyboardModifier(0x08000000)
	Qt__MetaModifier         Qt__KeyboardModifier = Qt__KeyboardModifier(0x10000000)
	Qt__KeypadModifier       Qt__KeyboardModifier = Qt__KeyboardModifier(0x20000000)
	Qt__GroupSwitchModifier  Qt__KeyboardModifier = Qt__KeyboardModifier(0x40000000)
	Qt__KeyboardModifierMask Qt__KeyboardModifier = Qt__KeyboardModifier(0xfe000000)
)

//go:generate stringer -type=Qt__Modifier
//Qt::Modifier
type Qt__Modifier int64

const (
	Qt__META          Qt__Modifier = Qt__Modifier(Qt__MetaModifier)
	Qt__SHIFT         Qt__Modifier = Qt__Modifier(Qt__ShiftModifier)
	Qt__CTRL          Qt__Modifier = Qt__Modifier(Qt__ControlModifier)
	Qt__ALT           Qt__Modifier = Qt__Modifier(Qt__AltModifier)
	Qt__MODIFIER_MASK Qt__Modifier = Qt__Modifier(Qt__KeyboardModifierMask)
	Qt__UNICODE_ACCEL Qt__Modifier = Qt__Modifier(0x00000000)
)

//go:generate stringer -type=Qt__MouseButton
//Qt::MouseButton
type Qt__MouseButton int64

const (
	Qt__NoButton        Qt__MouseButton = Qt__MouseButton(0x00000000)
	Qt__LeftButton      Qt__MouseButton = Qt__MouseButton(0x00000001)
	Qt__RightButton     Qt__MouseButton = Qt__MouseButton(0x00000002)
	Qt__MidButton       Qt__MouseButton = Qt__MouseButton(0x00000004)
	Qt__MiddleButton    Qt__MouseButton = Qt__MouseButton(Qt__MidButton)
	Qt__BackButton      Qt__MouseButton = Qt__MouseButton(0x00000008)
	Qt__XButton1        Qt__MouseButton = Qt__MouseButton(Qt__BackButton)
	Qt__ExtraButton1    Qt__MouseButton = Qt__MouseButton(Qt__XButton1)
	Qt__ForwardButton   Qt__MouseButton = Qt__MouseButton(0x00000010)
	Qt__XButton2        Qt__MouseButton = Qt__MouseButton(Qt__ForwardButton)
	Qt__ExtraButton2    Qt__MouseButton = Qt__MouseButton(Qt__ForwardButton)
	Qt__TaskButton      Qt__MouseButton = Qt__MouseButton(0x00000020)
	Qt__ExtraButton3    Qt__MouseButton = Qt__MouseButton(Qt__TaskButton)
	Qt__ExtraButton4    Qt__MouseButton = Qt__MouseButton(0x00000040)
	Qt__ExtraButton5    Qt__MouseButton = Qt__MouseButton(0x00000080)
	Qt__ExtraButton6    Qt__MouseButton = Qt__MouseButton(0x00000100)
	Qt__ExtraButton7    Qt__MouseButton = Qt__MouseButton(0x00000200)
	Qt__ExtraButton8    Qt__MouseButton = Qt__MouseButton(0x00000400)
	Qt__ExtraButton9    Qt__MouseButton = Qt__MouseButton(0x00000800)
	Qt__ExtraButton10   Qt__MouseButton = Qt__MouseButton(0x00001000)
	Qt__ExtraButton11   Qt__MouseButton = Qt__MouseButton(0x00002000)
	Qt__ExtraButton12   Qt__MouseButton = Qt__MouseButton(0x00004000)
	Qt__ExtraButton13   Qt__MouseButton = Qt__MouseButton(0x00008000)
	Qt__ExtraButton14   Qt__MouseButton = Qt__MouseButton(0x00010000)
	Qt__ExtraButton15   Qt__MouseButton = Qt__MouseButton(0x00020000)
	Qt__ExtraButton16   Qt__MouseButton = Qt__MouseButton(0x00040000)
	Qt__ExtraButton17   Qt__MouseButton = Qt__MouseButton(0x00080000)
	Qt__ExtraButton18   Qt__MouseButton = Qt__MouseButton(0x00100000)
	Qt__ExtraButton19   Qt__MouseButton = Qt__MouseButton(0x00200000)
	Qt__ExtraButton20   Qt__MouseButton = Qt__MouseButton(0x00400000)
	Qt__ExtraButton21   Qt__MouseButton = Qt__MouseButton(0x00800000)
	Qt__ExtraButton22   Qt__MouseButton = Qt__MouseButton(0x01000000)
	Qt__ExtraButton23   Qt__MouseButton = Qt__MouseButton(0x02000000)
	Qt__ExtraButton24   Qt__MouseButton = Qt__MouseButton(0x04000000)
	Qt__AllButtons      Qt__MouseButton = Qt__MouseButton(0x07ffffff)
	Qt__MaxMouseButton  Qt__MouseButton = Qt__MouseButton(Qt__ExtraButton24)
	Qt__MouseButtonMask Qt__MouseButton = Qt__MouseButton(0xffffffff)
)

//go:generate stringer -type=Qt__Orientation
//Qt::Orientation
type Qt__Orientation int64

const (
	Qt__Horizontal Qt__Orientation = Qt__Orientation(0x1)
	Qt__Vertical   Qt__Orientation = Qt__Orientation(0x2)
)

//go:generate stringer -type=Qt__FocusPolicy
//Qt::FocusPolicy
type Qt__FocusPolicy int64

const (
	Qt__NoFocus     Qt__FocusPolicy = Qt__FocusPolicy(0)
	Qt__TabFocus    Qt__FocusPolicy = Qt__FocusPolicy(0x1)
	Qt__ClickFocus  Qt__FocusPolicy = Qt__FocusPolicy(0x2)
	Qt__StrongFocus Qt__FocusPolicy = Qt__FocusPolicy(Qt__TabFocus | Qt__ClickFocus | 0x8)
	Qt__WheelFocus  Qt__FocusPolicy = Qt__FocusPolicy(Qt__StrongFocus | 0x4)
)

//go:generate stringer -type=Qt__TabFocusBehavior
//Qt::TabFocusBehavior
type Qt__TabFocusBehavior int64

const (
	Qt__NoTabFocus           Qt__TabFocusBehavior = Qt__TabFocusBehavior(0x00)
	Qt__TabFocusTextControls Qt__TabFocusBehavior = Qt__TabFocusBehavior(0x01)
	Qt__TabFocusListControls Qt__TabFocusBehavior = Qt__TabFocusBehavior(0x02)
	Qt__TabFocusAllControls  Qt__TabFocusBehavior = Qt__TabFocusBehavior(0xff)
)

//go:generate stringer -type=Qt__SortOrder
//Qt::SortOrder
type Qt__SortOrder int64

const (
	Qt__AscendingOrder  Qt__SortOrder = Qt__SortOrder(0)
	Qt__DescendingOrder Qt__SortOrder = Qt__SortOrder(1)
)

//go:generate stringer -type=Qt__TileRule
//Qt::TileRule
type Qt__TileRule int64

const (
	Qt__StretchTile Qt__TileRule = Qt__TileRule(0)
	Qt__RepeatTile  Qt__TileRule = Qt__TileRule(1)
	Qt__RoundTile   Qt__TileRule = Qt__TileRule(2)
)

//go:generate stringer -type=Qt__AlignmentFlag
//Qt::AlignmentFlag
type Qt__AlignmentFlag int64

const (
	Qt__AlignLeft            Qt__AlignmentFlag = Qt__AlignmentFlag(0x0001)
	Qt__AlignLeading         Qt__AlignmentFlag = Qt__AlignmentFlag(Qt__AlignLeft)
	Qt__AlignRight           Qt__AlignmentFlag = Qt__AlignmentFlag(0x0002)
	Qt__AlignTrailing        Qt__AlignmentFlag = Qt__AlignmentFlag(Qt__AlignRight)
	Qt__AlignHCenter         Qt__AlignmentFlag = Qt__AlignmentFlag(0x0004)
	Qt__AlignJustify         Qt__AlignmentFlag = Qt__AlignmentFlag(0x0008)
	Qt__AlignAbsolute        Qt__AlignmentFlag = Qt__AlignmentFlag(0x0010)
	Qt__AlignHorizontal_Mask Qt__AlignmentFlag = Qt__AlignmentFlag(Qt__AlignLeft | Qt__AlignRight | Qt__AlignHCenter | Qt__AlignJustify | Qt__AlignAbsolute)
	Qt__AlignTop             Qt__AlignmentFlag = Qt__AlignmentFlag(0x0020)
	Qt__AlignBottom          Qt__AlignmentFlag = Qt__AlignmentFlag(0x0040)
	Qt__AlignVCenter         Qt__AlignmentFlag = Qt__AlignmentFlag(0x0080)
	Qt__AlignBaseline        Qt__AlignmentFlag = Qt__AlignmentFlag(0x0100)
	Qt__AlignVertical_Mask   Qt__AlignmentFlag = Qt__AlignmentFlag(Qt__AlignTop | Qt__AlignBottom | Qt__AlignVCenter | Qt__AlignBaseline)
	Qt__AlignCenter          Qt__AlignmentFlag = Qt__AlignmentFlag(Qt__AlignVCenter | Qt__AlignHCenter)
)

//go:generate stringer -type=Qt__TextFlag
//Qt::TextFlag
type Qt__TextFlag int64

const (
	Qt__TextSingleLine            Qt__TextFlag = Qt__TextFlag(0x0100)
	Qt__TextDontClip              Qt__TextFlag = Qt__TextFlag(0x0200)
	Qt__TextExpandTabs            Qt__TextFlag = Qt__TextFlag(0x0400)
	Qt__TextShowMnemonic          Qt__TextFlag = Qt__TextFlag(0x0800)
	Qt__TextWordWrap              Qt__TextFlag = Qt__TextFlag(0x1000)
	Qt__TextWrapAnywhere          Qt__TextFlag = Qt__TextFlag(0x2000)
	Qt__TextDontPrint             Qt__TextFlag = Qt__TextFlag(0x4000)
	Qt__TextIncludeTrailingSpaces Qt__TextFlag = Qt__TextFlag(0x08000000)
	Qt__TextHideMnemonic          Qt__TextFlag = Qt__TextFlag(0x8000)
	Qt__TextJustificationForced   Qt__TextFlag = Qt__TextFlag(0x10000)
	Qt__TextForceLeftToRight      Qt__TextFlag = Qt__TextFlag(0x20000)
	Qt__TextForceRightToLeft      Qt__TextFlag = Qt__TextFlag(0x40000)
	Qt__TextLongestVariant        Qt__TextFlag = Qt__TextFlag(0x80000)
	Qt__TextBypassShaping         Qt__TextFlag = Qt__TextFlag(0x100000)
)

//go:generate stringer -type=Qt__TextElideMode
//Qt::TextElideMode
type Qt__TextElideMode int64

const (
	Qt__ElideLeft   Qt__TextElideMode = Qt__TextElideMode(0)
	Qt__ElideRight  Qt__TextElideMode = Qt__TextElideMode(1)
	Qt__ElideMiddle Qt__TextElideMode = Qt__TextElideMode(2)
	Qt__ElideNone   Qt__TextElideMode = Qt__TextElideMode(3)
)

//go:generate stringer -type=Qt__WhiteSpaceMode
//Qt::WhiteSpaceMode
type Qt__WhiteSpaceMode int64

const (
	Qt__WhiteSpaceNormal        Qt__WhiteSpaceMode = Qt__WhiteSpaceMode(0)
	Qt__WhiteSpacePre           Qt__WhiteSpaceMode = Qt__WhiteSpaceMode(1)
	Qt__WhiteSpaceNoWrap        Qt__WhiteSpaceMode = Qt__WhiteSpaceMode(2)
	Qt__WhiteSpaceModeUndefined Qt__WhiteSpaceMode = Qt__WhiteSpaceMode(-1)
)

//go:generate stringer -type=Qt__HitTestAccuracy
//Qt::HitTestAccuracy
type Qt__HitTestAccuracy int64

const (
	Qt__ExactHit Qt__HitTestAccuracy = Qt__HitTestAccuracy(0)
	Qt__FuzzyHit Qt__HitTestAccuracy = Qt__HitTestAccuracy(1)
)

//go:generate stringer -type=Qt__WindowType
//Qt::WindowType
type Qt__WindowType int64

const (
	Qt__Widget                              Qt__WindowType = Qt__WindowType(0x00000000)
	Qt__Window                              Qt__WindowType = Qt__WindowType(0x00000001)
	Qt__Dialog                              Qt__WindowType = Qt__WindowType(0x00000002 | Qt__Window)
	Qt__Sheet                               Qt__WindowType = Qt__WindowType(0x00000004 | Qt__Window)
	Qt__Drawer                              Qt__WindowType = Qt__WindowType(Qt__Sheet | Qt__Dialog)
	Qt__Popup                               Qt__WindowType = Qt__WindowType(0x00000008 | Qt__Window)
	Qt__Tool                                Qt__WindowType = Qt__WindowType(Qt__Popup | Qt__Dialog)
	Qt__ToolTip                             Qt__WindowType = Qt__WindowType(Qt__Popup | Qt__Sheet)
	Qt__SplashScreen                        Qt__WindowType = Qt__WindowType(Qt__ToolTip | Qt__Dialog)
	Qt__Desktop                             Qt__WindowType = Qt__WindowType(0x00000010 | Qt__Window)
	Qt__SubWindow                           Qt__WindowType = Qt__WindowType(0x00000012)
	Qt__ForeignWindow                       Qt__WindowType = Qt__WindowType(0x00000020 | Qt__Window)
	Qt__CoverWindow                         Qt__WindowType = Qt__WindowType(0x00000040 | Qt__Window)
	Qt__WindowType_Mask                     Qt__WindowType = Qt__WindowType(0x000000ff)
	Qt__MSWindowsFixedSizeDialogHint        Qt__WindowType = Qt__WindowType(0x00000100)
	Qt__MSWindowsOwnDC                      Qt__WindowType = Qt__WindowType(0x00000200)
	Qt__BypassWindowManagerHint             Qt__WindowType = Qt__WindowType(0x00000400)
	Qt__X11BypassWindowManagerHint          Qt__WindowType = Qt__WindowType(Qt__BypassWindowManagerHint)
	Qt__FramelessWindowHint                 Qt__WindowType = Qt__WindowType(0x00000800)
	Qt__WindowTitleHint                     Qt__WindowType = Qt__WindowType(0x00001000)
	Qt__WindowSystemMenuHint                Qt__WindowType = Qt__WindowType(0x00002000)
	Qt__WindowMinimizeButtonHint            Qt__WindowType = Qt__WindowType(0x00004000)
	Qt__WindowMaximizeButtonHint            Qt__WindowType = Qt__WindowType(0x00008000)
	Qt__WindowMinMaxButtonsHint             Qt__WindowType = Qt__WindowType(Qt__WindowMinimizeButtonHint | Qt__WindowMaximizeButtonHint)
	Qt__WindowContextHelpButtonHint         Qt__WindowType = Qt__WindowType(0x00010000)
	Qt__WindowShadeButtonHint               Qt__WindowType = Qt__WindowType(0x00020000)
	Qt__WindowStaysOnTopHint                Qt__WindowType = Qt__WindowType(0x00040000)
	Qt__WindowTransparentForInput           Qt__WindowType = Qt__WindowType(0x00080000)
	Qt__WindowOverridesSystemGestures       Qt__WindowType = Qt__WindowType(0x00100000)
	Qt__WindowDoesNotAcceptFocus            Qt__WindowType = Qt__WindowType(0x00200000)
	Qt__MaximizeUsingFullscreenGeometryHint Qt__WindowType = Qt__WindowType(0x00400000)
	Qt__CustomizeWindowHint                 Qt__WindowType = Qt__WindowType(0x02000000)
	Qt__WindowStaysOnBottomHint             Qt__WindowType = Qt__WindowType(0x04000000)
	Qt__WindowCloseButtonHint               Qt__WindowType = Qt__WindowType(0x08000000)
	Qt__MacWindowToolBarButtonHint          Qt__WindowType = Qt__WindowType(0x10000000)
	Qt__BypassGraphicsProxyWidget           Qt__WindowType = Qt__WindowType(0x20000000)
	Qt__NoDropShadowWindowHint              Qt__WindowType = Qt__WindowType(0x40000000)
	Qt__WindowFullscreenButtonHint          Qt__WindowType = Qt__WindowType(0x80000000)
)

//go:generate stringer -type=Qt__WindowState
//Qt::WindowState
type Qt__WindowState int64

const (
	Qt__WindowNoState    Qt__WindowState = Qt__WindowState(0x00000000)
	Qt__WindowMinimized  Qt__WindowState = Qt__WindowState(0x00000001)
	Qt__WindowMaximized  Qt__WindowState = Qt__WindowState(0x00000002)
	Qt__WindowFullScreen Qt__WindowState = Qt__WindowState(0x00000004)
	Qt__WindowActive     Qt__WindowState = Qt__WindowState(0x00000008)
)

//go:generate stringer -type=Qt__ApplicationState
//Qt::ApplicationState
type Qt__ApplicationState int64

const (
	Qt__ApplicationSuspended Qt__ApplicationState = Qt__ApplicationState(0x00000000)
	Qt__ApplicationHidden    Qt__ApplicationState = Qt__ApplicationState(0x00000001)
	Qt__ApplicationInactive  Qt__ApplicationState = Qt__ApplicationState(0x00000002)
	Qt__ApplicationActive    Qt__ApplicationState = Qt__ApplicationState(0x00000004)
)

//go:generate stringer -type=Qt__ScreenOrientation
//Qt::ScreenOrientation
type Qt__ScreenOrientation int64

const (
	Qt__PrimaryOrientation           Qt__ScreenOrientation = Qt__ScreenOrientation(0x00000000)
	Qt__PortraitOrientation          Qt__ScreenOrientation = Qt__ScreenOrientation(0x00000001)
	Qt__LandscapeOrientation         Qt__ScreenOrientation = Qt__ScreenOrientation(0x00000002)
	Qt__InvertedPortraitOrientation  Qt__ScreenOrientation = Qt__ScreenOrientation(0x00000004)
	Qt__InvertedLandscapeOrientation Qt__ScreenOrientation = Qt__ScreenOrientation(0x00000008)
)

//go:generate stringer -type=Qt__WidgetAttribute
//Qt::WidgetAttribute
type Qt__WidgetAttribute int64

const (
	Qt__WA_Disabled                        Qt__WidgetAttribute = Qt__WidgetAttribute(0)
	Qt__WA_UnderMouse                      Qt__WidgetAttribute = Qt__WidgetAttribute(1)
	Qt__WA_MouseTracking                   Qt__WidgetAttribute = Qt__WidgetAttribute(2)
	Qt__WA_ContentsPropagated              Qt__WidgetAttribute = Qt__WidgetAttribute(3)
	Qt__WA_OpaquePaintEvent                Qt__WidgetAttribute = Qt__WidgetAttribute(4)
	Qt__WA_NoBackground                    Qt__WidgetAttribute = Qt__WidgetAttribute(Qt__WA_OpaquePaintEvent)
	Qt__WA_StaticContents                  Qt__WidgetAttribute = Qt__WidgetAttribute(5)
	Qt__WA_LaidOut                         Qt__WidgetAttribute = Qt__WidgetAttribute(7)
	Qt__WA_PaintOnScreen                   Qt__WidgetAttribute = Qt__WidgetAttribute(8)
	Qt__WA_NoSystemBackground              Qt__WidgetAttribute = Qt__WidgetAttribute(9)
	Qt__WA_UpdatesDisabled                 Qt__WidgetAttribute = Qt__WidgetAttribute(10)
	Qt__WA_Mapped                          Qt__WidgetAttribute = Qt__WidgetAttribute(11)
	Qt__WA_MacNoClickThrough               Qt__WidgetAttribute = Qt__WidgetAttribute(12)
	Qt__WA_InputMethodEnabled              Qt__WidgetAttribute = Qt__WidgetAttribute(14)
	Qt__WA_WState_Visible                  Qt__WidgetAttribute = Qt__WidgetAttribute(15)
	Qt__WA_WState_Hidden                   Qt__WidgetAttribute = Qt__WidgetAttribute(16)
	Qt__WA_ForceDisabled                   Qt__WidgetAttribute = Qt__WidgetAttribute(32)
	Qt__WA_KeyCompression                  Qt__WidgetAttribute = Qt__WidgetAttribute(33)
	Qt__WA_PendingMoveEvent                Qt__WidgetAttribute = Qt__WidgetAttribute(34)
	Qt__WA_PendingResizeEvent              Qt__WidgetAttribute = Qt__WidgetAttribute(35)
	Qt__WA_SetPalette                      Qt__WidgetAttribute = Qt__WidgetAttribute(36)
	Qt__WA_SetFont                         Qt__WidgetAttribute = Qt__WidgetAttribute(37)
	Qt__WA_SetCursor                       Qt__WidgetAttribute = Qt__WidgetAttribute(38)
	Qt__WA_NoChildEventsFromChildren       Qt__WidgetAttribute = Qt__WidgetAttribute(39)
	Qt__WA_WindowModified                  Qt__WidgetAttribute = Qt__WidgetAttribute(41)
	Qt__WA_Resized                         Qt__WidgetAttribute = Qt__WidgetAttribute(42)
	Qt__WA_Moved                           Qt__WidgetAttribute = Qt__WidgetAttribute(43)
	Qt__WA_PendingUpdate                   Qt__WidgetAttribute = Qt__WidgetAttribute(44)
	Qt__WA_InvalidSize                     Qt__WidgetAttribute = Qt__WidgetAttribute(45)
	Qt__WA_MacBrushedMetal                 Qt__WidgetAttribute = Qt__WidgetAttribute(46)
	Qt__WA_MacMetalStyle                   Qt__WidgetAttribute = Qt__WidgetAttribute(Qt__WA_MacBrushedMetal)
	Qt__WA_CustomWhatsThis                 Qt__WidgetAttribute = Qt__WidgetAttribute(47)
	Qt__WA_LayoutOnEntireRect              Qt__WidgetAttribute = Qt__WidgetAttribute(48)
	Qt__WA_OutsideWSRange                  Qt__WidgetAttribute = Qt__WidgetAttribute(49)
	Qt__WA_GrabbedShortcut                 Qt__WidgetAttribute = Qt__WidgetAttribute(50)
	Qt__WA_TransparentForMouseEvents       Qt__WidgetAttribute = Qt__WidgetAttribute(51)
	Qt__WA_PaintUnclipped                  Qt__WidgetAttribute = Qt__WidgetAttribute(52)
	Qt__WA_SetWindowIcon                   Qt__WidgetAttribute = Qt__WidgetAttribute(53)
	Qt__WA_NoMouseReplay                   Qt__WidgetAttribute = Qt__WidgetAttribute(54)
	Qt__WA_DeleteOnClose                   Qt__WidgetAttribute = Qt__WidgetAttribute(55)
	Qt__WA_RightToLeft                     Qt__WidgetAttribute = Qt__WidgetAttribute(56)
	Qt__WA_SetLayoutDirection              Qt__WidgetAttribute = Qt__WidgetAttribute(57)
	Qt__WA_NoChildEventsForParent          Qt__WidgetAttribute = Qt__WidgetAttribute(58)
	Qt__WA_ForceUpdatesDisabled            Qt__WidgetAttribute = Qt__WidgetAttribute(59)
	Qt__WA_WState_Created                  Qt__WidgetAttribute = Qt__WidgetAttribute(60)
	Qt__WA_WState_CompressKeys             Qt__WidgetAttribute = Qt__WidgetAttribute(61)
	Qt__WA_WState_InPaintEvent             Qt__WidgetAttribute = Qt__WidgetAttribute(62)
	Qt__WA_WState_Reparented               Qt__WidgetAttribute = Qt__WidgetAttribute(63)
	Qt__WA_WState_ConfigPending            Qt__WidgetAttribute = Qt__WidgetAttribute(64)
	Qt__WA_WState_Polished                 Qt__WidgetAttribute = Qt__WidgetAttribute(66)
	Qt__WA_WState_DND                      Qt__WidgetAttribute = Qt__WidgetAttribute(67)
	Qt__WA_WState_OwnSizePolicy            Qt__WidgetAttribute = Qt__WidgetAttribute(68)
	Qt__WA_WState_ExplicitShowHide         Qt__WidgetAttribute = Qt__WidgetAttribute(69)
	Qt__WA_ShowModal                       Qt__WidgetAttribute = Qt__WidgetAttribute(70)
	Qt__WA_MouseNoMask                     Qt__WidgetAttribute = Qt__WidgetAttribute(71)
	Qt__WA_GroupLeader                     Qt__WidgetAttribute = Qt__WidgetAttribute(72)
	Qt__WA_NoMousePropagation              Qt__WidgetAttribute = Qt__WidgetAttribute(73)
	Qt__WA_Hover                           Qt__WidgetAttribute = Qt__WidgetAttribute(74)
	Qt__WA_InputMethodTransparent          Qt__WidgetAttribute = Qt__WidgetAttribute(75)
	Qt__WA_QuitOnClose                     Qt__WidgetAttribute = Qt__WidgetAttribute(76)
	Qt__WA_KeyboardFocusChange             Qt__WidgetAttribute = Qt__WidgetAttribute(77)
	Qt__WA_AcceptDrops                     Qt__WidgetAttribute = Qt__WidgetAttribute(78)
	Qt__WA_DropSiteRegistered              Qt__WidgetAttribute = Qt__WidgetAttribute(79)
	Qt__WA_ForceAcceptDrops                Qt__WidgetAttribute = Qt__WidgetAttribute(Qt__WA_DropSiteRegistered)
	Qt__WA_WindowPropagation               Qt__WidgetAttribute = Qt__WidgetAttribute(80)
	Qt__WA_NoX11EventCompression           Qt__WidgetAttribute = Qt__WidgetAttribute(81)
	Qt__WA_TintedBackground                Qt__WidgetAttribute = Qt__WidgetAttribute(82)
	Qt__WA_X11OpenGLOverlay                Qt__WidgetAttribute = Qt__WidgetAttribute(83)
	Qt__WA_AlwaysShowToolTips              Qt__WidgetAttribute = Qt__WidgetAttribute(84)
	Qt__WA_MacOpaqueSizeGrip               Qt__WidgetAttribute = Qt__WidgetAttribute(85)
	Qt__WA_SetStyle                        Qt__WidgetAttribute = Qt__WidgetAttribute(86)
	Qt__WA_SetLocale                       Qt__WidgetAttribute = Qt__WidgetAttribute(87)
	Qt__WA_MacShowFocusRect                Qt__WidgetAttribute = Qt__WidgetAttribute(88)
	Qt__WA_MacNormalSize                   Qt__WidgetAttribute = Qt__WidgetAttribute(89)
	Qt__WA_MacSmallSize                    Qt__WidgetAttribute = Qt__WidgetAttribute(90)
	Qt__WA_MacMiniSize                     Qt__WidgetAttribute = Qt__WidgetAttribute(91)
	Qt__WA_LayoutUsesWidgetRect            Qt__WidgetAttribute = Qt__WidgetAttribute(92)
	Qt__WA_StyledBackground                Qt__WidgetAttribute = Qt__WidgetAttribute(93)
	Qt__WA_MSWindowsUseDirect3D            Qt__WidgetAttribute = Qt__WidgetAttribute(94)
	Qt__WA_CanHostQMdiSubWindowTitleBar    Qt__WidgetAttribute = Qt__WidgetAttribute(95)
	Qt__WA_MacAlwaysShowToolWindow         Qt__WidgetAttribute = Qt__WidgetAttribute(96)
	Qt__WA_StyleSheet                      Qt__WidgetAttribute = Qt__WidgetAttribute(97)
	Qt__WA_ShowWithoutActivating           Qt__WidgetAttribute = Qt__WidgetAttribute(98)
	Qt__WA_X11BypassTransientForHint       Qt__WidgetAttribute = Qt__WidgetAttribute(99)
	Qt__WA_NativeWindow                    Qt__WidgetAttribute = Qt__WidgetAttribute(100)
	Qt__WA_DontCreateNativeAncestors       Qt__WidgetAttribute = Qt__WidgetAttribute(101)
	Qt__WA_MacVariableSize                 Qt__WidgetAttribute = Qt__WidgetAttribute(102)
	Qt__WA_DontShowOnScreen                Qt__WidgetAttribute = Qt__WidgetAttribute(103)
	Qt__WA_X11NetWmWindowTypeDesktop       Qt__WidgetAttribute = Qt__WidgetAttribute(104)
	Qt__WA_X11NetWmWindowTypeDock          Qt__WidgetAttribute = Qt__WidgetAttribute(105)
	Qt__WA_X11NetWmWindowTypeToolBar       Qt__WidgetAttribute = Qt__WidgetAttribute(106)
	Qt__WA_X11NetWmWindowTypeMenu          Qt__WidgetAttribute = Qt__WidgetAttribute(107)
	Qt__WA_X11NetWmWindowTypeUtility       Qt__WidgetAttribute = Qt__WidgetAttribute(108)
	Qt__WA_X11NetWmWindowTypeSplash        Qt__WidgetAttribute = Qt__WidgetAttribute(109)
	Qt__WA_X11NetWmWindowTypeDialog        Qt__WidgetAttribute = Qt__WidgetAttribute(110)
	Qt__WA_X11NetWmWindowTypeDropDownMenu  Qt__WidgetAttribute = Qt__WidgetAttribute(111)
	Qt__WA_X11NetWmWindowTypePopupMenu     Qt__WidgetAttribute = Qt__WidgetAttribute(112)
	Qt__WA_X11NetWmWindowTypeToolTip       Qt__WidgetAttribute = Qt__WidgetAttribute(113)
	Qt__WA_X11NetWmWindowTypeNotification  Qt__WidgetAttribute = Qt__WidgetAttribute(114)
	Qt__WA_X11NetWmWindowTypeCombo         Qt__WidgetAttribute = Qt__WidgetAttribute(115)
	Qt__WA_X11NetWmWindowTypeDND           Qt__WidgetAttribute = Qt__WidgetAttribute(116)
	Qt__WA_MacFrameworkScaled              Qt__WidgetAttribute = Qt__WidgetAttribute(117)
	Qt__WA_SetWindowModality               Qt__WidgetAttribute = Qt__WidgetAttribute(118)
	Qt__WA_WState_WindowOpacitySet         Qt__WidgetAttribute = Qt__WidgetAttribute(119)
	Qt__WA_TranslucentBackground           Qt__WidgetAttribute = Qt__WidgetAttribute(120)
	Qt__WA_AcceptTouchEvents               Qt__WidgetAttribute = Qt__WidgetAttribute(121)
	Qt__WA_WState_AcceptedTouchBeginEvent  Qt__WidgetAttribute = Qt__WidgetAttribute(122)
	Qt__WA_TouchPadAcceptSingleTouchEvents Qt__WidgetAttribute = Qt__WidgetAttribute(123)
	Qt__WA_X11DoNotAcceptFocus             Qt__WidgetAttribute = Qt__WidgetAttribute(126)
	Qt__WA_MacNoShadow                     Qt__WidgetAttribute = Qt__WidgetAttribute(127)
	Qt__WA_AlwaysStackOnTop                Qt__WidgetAttribute = Qt__WidgetAttribute(128)
	Qt__WA_TabletTracking                  Qt__WidgetAttribute = Qt__WidgetAttribute(129)
	Qt__WA_ContentsMarginsRespectsSafeArea Qt__WidgetAttribute = Qt__WidgetAttribute(130)
	Qt__WA_StyleSheetTarget                Qt__WidgetAttribute = Qt__WidgetAttribute(131)
	Qt__WA_AttributeCount                  Qt__WidgetAttribute = Qt__WidgetAttribute(132)
)

//go:generate stringer -type=Qt__ApplicationAttribute
//Qt::ApplicationAttribute
type Qt__ApplicationAttribute int64

const (
	Qt__AA_ImmediateWidgetCreation                 Qt__ApplicationAttribute = Qt__ApplicationAttribute(0)
	Qt__AA_MSWindowsUseDirect3DByDefault           Qt__ApplicationAttribute = Qt__ApplicationAttribute(1)
	Qt__AA_DontShowIconsInMenus                    Qt__ApplicationAttribute = Qt__ApplicationAttribute(2)
	Qt__AA_NativeWindows                           Qt__ApplicationAttribute = Qt__ApplicationAttribute(3)
	Qt__AA_DontCreateNativeWidgetSiblings          Qt__ApplicationAttribute = Qt__ApplicationAttribute(4)
	Qt__AA_PluginApplication                       Qt__ApplicationAttribute = Qt__ApplicationAttribute(5)
	Qt__AA_MacPluginApplication                    Qt__ApplicationAttribute = Qt__ApplicationAttribute(Qt__AA_PluginApplication)
	Qt__AA_DontUseNativeMenuBar                    Qt__ApplicationAttribute = Qt__ApplicationAttribute(6)
	Qt__AA_MacDontSwapCtrlAndMeta                  Qt__ApplicationAttribute = Qt__ApplicationAttribute(7)
	Qt__AA_Use96Dpi                                Qt__ApplicationAttribute = Qt__ApplicationAttribute(8)
	Qt__AA_X11InitThreads                          Qt__ApplicationAttribute = Qt__ApplicationAttribute(10)
	Qt__AA_SynthesizeTouchForUnhandledMouseEvents  Qt__ApplicationAttribute = Qt__ApplicationAttribute(11)
	Qt__AA_SynthesizeMouseForUnhandledTouchEvents  Qt__ApplicationAttribute = Qt__ApplicationAttribute(12)
	Qt__AA_UseHighDpiPixmaps                       Qt__ApplicationAttribute = Qt__ApplicationAttribute(13)
	Qt__AA_ForceRasterWidgets                      Qt__ApplicationAttribute = Qt__ApplicationAttribute(14)
	Qt__AA_UseDesktopOpenGL                        Qt__ApplicationAttribute = Qt__ApplicationAttribute(15)
	Qt__AA_UseOpenGLES                             Qt__ApplicationAttribute = Qt__ApplicationAttribute(16)
	Qt__AA_UseSoftwareOpenGL                       Qt__ApplicationAttribute = Qt__ApplicationAttribute(17)
	Qt__AA_ShareOpenGLContexts                     Qt__ApplicationAttribute = Qt__ApplicationAttribute(18)
	Qt__AA_SetPalette                              Qt__ApplicationAttribute = Qt__ApplicationAttribute(19)
	Qt__AA_EnableHighDpiScaling                    Qt__ApplicationAttribute = Qt__ApplicationAttribute(20)
	Qt__AA_DisableHighDpiScaling                   Qt__ApplicationAttribute = Qt__ApplicationAttribute(21)
	Qt__AA_UseStyleSheetPropagationInWidgetStyles  Qt__ApplicationAttribute = Qt__ApplicationAttribute(22)
	Qt__AA_DontUseNativeDialogs                    Qt__ApplicationAttribute = Qt__ApplicationAttribute(23)
	Qt__AA_SynthesizeMouseForUnhandledTabletEvents Qt__ApplicationAttribute = Qt__ApplicationAttribute(24)
	Qt__AA_CompressHighFrequencyEvents             Qt__ApplicationAttribute = Qt__ApplicationAttribute(25)
	Qt__AA_DontCheckOpenGLContextThreadAffinity    Qt__ApplicationAttribute = Qt__ApplicationAttribute(26)
	Qt__AA_DisableShaderDiskCache                  Qt__ApplicationAttribute = Qt__ApplicationAttribute(27)
	Qt__AA_DontShowShortcutsInContextMenus         Qt__ApplicationAttribute = Qt__ApplicationAttribute(28)
	Qt__AA_CompressTabletEvents                    Qt__ApplicationAttribute = Qt__ApplicationAttribute(29)
	Qt__AA_DisableWindowContextHelpButton          Qt__ApplicationAttribute = Qt__ApplicationAttribute(30)
	Qt__AA_AttributeCount                          Qt__ApplicationAttribute = Qt__ApplicationAttribute(31)
)

//go:generate stringer -type=Qt__ImageConversionFlag
//Qt::ImageConversionFlag
type Qt__ImageConversionFlag int64

const (
	Qt__ColorMode_Mask       Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000003)
	Qt__AutoColor            Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000000)
	Qt__ColorOnly            Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000003)
	Qt__MonoOnly             Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000002)
	Qt__AlphaDither_Mask     Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x0000000c)
	Qt__ThresholdAlphaDither Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000000)
	Qt__OrderedAlphaDither   Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000004)
	Qt__DiffuseAlphaDither   Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000008)
	Qt__NoAlpha              Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x0000000c)
	Qt__Dither_Mask          Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000030)
	Qt__DiffuseDither        Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000000)
	Qt__OrderedDither        Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000010)
	Qt__ThresholdDither      Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000020)
	Qt__DitherMode_Mask      Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x000000c0)
	Qt__AutoDither           Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000000)
	Qt__PreferDither         Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000040)
	Qt__AvoidDither          Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000080)
	Qt__NoOpaqueDetection    Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000100)
	Qt__NoFormatConversion   Qt__ImageConversionFlag = Qt__ImageConversionFlag(0x00000200)
)

//go:generate stringer -type=Qt__BGMode
//Qt::BGMode
type Qt__BGMode int64

const (
	Qt__TransparentMode Qt__BGMode = Qt__BGMode(0)
	Qt__OpaqueMode      Qt__BGMode = Qt__BGMode(1)
)

//go:generate stringer -type=Qt__Key
//Qt::Key
type Qt__Key int64

const (
	Qt__Key_Escape                  Qt__Key = Qt__Key(0x01000000)
	Qt__Key_Tab                     Qt__Key = Qt__Key(0x01000001)
	Qt__Key_Backtab                 Qt__Key = Qt__Key(0x01000002)
	Qt__Key_Backspace               Qt__Key = Qt__Key(0x01000003)
	Qt__Key_Return                  Qt__Key = Qt__Key(0x01000004)
	Qt__Key_Enter                   Qt__Key = Qt__Key(0x01000005)
	Qt__Key_Insert                  Qt__Key = Qt__Key(0x01000006)
	Qt__Key_Delete                  Qt__Key = Qt__Key(0x01000007)
	Qt__Key_Pause                   Qt__Key = Qt__Key(0x01000008)
	Qt__Key_Print                   Qt__Key = Qt__Key(0x01000009)
	Qt__Key_SysReq                  Qt__Key = Qt__Key(0x0100000a)
	Qt__Key_Clear                   Qt__Key = Qt__Key(0x0100000b)
	Qt__Key_Home                    Qt__Key = Qt__Key(0x01000010)
	Qt__Key_End                     Qt__Key = Qt__Key(0x01000011)
	Qt__Key_Left                    Qt__Key = Qt__Key(0x01000012)
	Qt__Key_Up                      Qt__Key = Qt__Key(0x01000013)
	Qt__Key_Right                   Qt__Key = Qt__Key(0x01000014)
	Qt__Key_Down                    Qt__Key = Qt__Key(0x01000015)
	Qt__Key_PageUp                  Qt__Key = Qt__Key(0x01000016)
	Qt__Key_PageDown                Qt__Key = Qt__Key(0x01000017)
	Qt__Key_Shift                   Qt__Key = Qt__Key(0x01000020)
	Qt__Key_Control                 Qt__Key = Qt__Key(0x01000021)
	Qt__Key_Meta                    Qt__Key = Qt__Key(0x01000022)
	Qt__Key_Alt                     Qt__Key = Qt__Key(0x01000023)
	Qt__Key_CapsLock                Qt__Key = Qt__Key(0x01000024)
	Qt__Key_NumLock                 Qt__Key = Qt__Key(0x01000025)
	Qt__Key_ScrollLock              Qt__Key = Qt__Key(0x01000026)
	Qt__Key_F1                      Qt__Key = Qt__Key(0x01000030)
	Qt__Key_F2                      Qt__Key = Qt__Key(0x01000031)
	Qt__Key_F3                      Qt__Key = Qt__Key(0x01000032)
	Qt__Key_F4                      Qt__Key = Qt__Key(0x01000033)
	Qt__Key_F5                      Qt__Key = Qt__Key(0x01000034)
	Qt__Key_F6                      Qt__Key = Qt__Key(0x01000035)
	Qt__Key_F7                      Qt__Key = Qt__Key(0x01000036)
	Qt__Key_F8                      Qt__Key = Qt__Key(0x01000037)
	Qt__Key_F9                      Qt__Key = Qt__Key(0x01000038)
	Qt__Key_F10                     Qt__Key = Qt__Key(0x01000039)
	Qt__Key_F11                     Qt__Key = Qt__Key(0x0100003a)
	Qt__Key_F12                     Qt__Key = Qt__Key(0x0100003b)
	Qt__Key_F13                     Qt__Key = Qt__Key(0x0100003c)
	Qt__Key_F14                     Qt__Key = Qt__Key(0x0100003d)
	Qt__Key_F15                     Qt__Key = Qt__Key(0x0100003e)
	Qt__Key_F16                     Qt__Key = Qt__Key(0x0100003f)
	Qt__Key_F17                     Qt__Key = Qt__Key(0x01000040)
	Qt__Key_F18                     Qt__Key = Qt__Key(0x01000041)
	Qt__Key_F19                     Qt__Key = Qt__Key(0x01000042)
	Qt__Key_F20                     Qt__Key = Qt__Key(0x01000043)
	Qt__Key_F21                     Qt__Key = Qt__Key(0x01000044)
	Qt__Key_F22                     Qt__Key = Qt__Key(0x01000045)
	Qt__Key_F23                     Qt__Key = Qt__Key(0x01000046)
	Qt__Key_F24                     Qt__Key = Qt__Key(0x01000047)
	Qt__Key_F25                     Qt__Key = Qt__Key(0x01000048)
	Qt__Key_F26                     Qt__Key = Qt__Key(0x01000049)
	Qt__Key_F27                     Qt__Key = Qt__Key(0x0100004a)
	Qt__Key_F28                     Qt__Key = Qt__Key(0x0100004b)
	Qt__Key_F29                     Qt__Key = Qt__Key(0x0100004c)
	Qt__Key_F30                     Qt__Key = Qt__Key(0x0100004d)
	Qt__Key_F31                     Qt__Key = Qt__Key(0x0100004e)
	Qt__Key_F32                     Qt__Key = Qt__Key(0x0100004f)
	Qt__Key_F33                     Qt__Key = Qt__Key(0x01000050)
	Qt__Key_F34                     Qt__Key = Qt__Key(0x01000051)
	Qt__Key_F35                     Qt__Key = Qt__Key(0x01000052)
	Qt__Key_Super_L                 Qt__Key = Qt__Key(0x01000053)
	Qt__Key_Super_R                 Qt__Key = Qt__Key(0x01000054)
	Qt__Key_Menu                    Qt__Key = Qt__Key(0x01000055)
	Qt__Key_Hyper_L                 Qt__Key = Qt__Key(0x01000056)
	Qt__Key_Hyper_R                 Qt__Key = Qt__Key(0x01000057)
	Qt__Key_Help                    Qt__Key = Qt__Key(0x01000058)
	Qt__Key_Direction_L             Qt__Key = Qt__Key(0x01000059)
	Qt__Key_Direction_R             Qt__Key = Qt__Key(0x01000060)
	Qt__Key_Space                   Qt__Key = Qt__Key(0x20)
	Qt__Key_Any                     Qt__Key = Qt__Key(Qt__Key_Space)
	Qt__Key_Exclam                  Qt__Key = Qt__Key(0x21)
	Qt__Key_QuoteDbl                Qt__Key = Qt__Key(0x22)
	Qt__Key_NumberSign              Qt__Key = Qt__Key(0x23)
	Qt__Key_Dollar                  Qt__Key = Qt__Key(0x24)
	Qt__Key_Percent                 Qt__Key = Qt__Key(0x25)
	Qt__Key_Ampersand               Qt__Key = Qt__Key(0x26)
	Qt__Key_Apostrophe              Qt__Key = Qt__Key(0x27)
	Qt__Key_ParenLeft               Qt__Key = Qt__Key(0x28)
	Qt__Key_ParenRight              Qt__Key = Qt__Key(0x29)
	Qt__Key_Asterisk                Qt__Key = Qt__Key(0x2a)
	Qt__Key_Plus                    Qt__Key = Qt__Key(0x2b)
	Qt__Key_Comma                   Qt__Key = Qt__Key(0x2c)
	Qt__Key_Minus                   Qt__Key = Qt__Key(0x2d)
	Qt__Key_Period                  Qt__Key = Qt__Key(0x2e)
	Qt__Key_Slash                   Qt__Key = Qt__Key(0x2f)
	Qt__Key_0                       Qt__Key = Qt__Key(0x30)
	Qt__Key_1                       Qt__Key = Qt__Key(0x31)
	Qt__Key_2                       Qt__Key = Qt__Key(0x32)
	Qt__Key_3                       Qt__Key = Qt__Key(0x33)
	Qt__Key_4                       Qt__Key = Qt__Key(0x34)
	Qt__Key_5                       Qt__Key = Qt__Key(0x35)
	Qt__Key_6                       Qt__Key = Qt__Key(0x36)
	Qt__Key_7                       Qt__Key = Qt__Key(0x37)
	Qt__Key_8                       Qt__Key = Qt__Key(0x38)
	Qt__Key_9                       Qt__Key = Qt__Key(0x39)
	Qt__Key_Colon                   Qt__Key = Qt__Key(0x3a)
	Qt__Key_Semicolon               Qt__Key = Qt__Key(0x3b)
	Qt__Key_Less                    Qt__Key = Qt__Key(0x3c)
	Qt__Key_Equal                   Qt__Key = Qt__Key(0x3d)
	Qt__Key_Greater                 Qt__Key = Qt__Key(0x3e)
	Qt__Key_Question                Qt__Key = Qt__Key(0x3f)
	Qt__Key_At                      Qt__Key = Qt__Key(0x40)
	Qt__Key_A                       Qt__Key = Qt__Key(0x41)
	Qt__Key_B                       Qt__Key = Qt__Key(0x42)
	Qt__Key_C                       Qt__Key = Qt__Key(0x43)
	Qt__Key_D                       Qt__Key = Qt__Key(0x44)
	Qt__Key_E                       Qt__Key = Qt__Key(0x45)
	Qt__Key_F                       Qt__Key = Qt__Key(0x46)
	Qt__Key_G                       Qt__Key = Qt__Key(0x47)
	Qt__Key_H                       Qt__Key = Qt__Key(0x48)
	Qt__Key_I                       Qt__Key = Qt__Key(0x49)
	Qt__Key_J                       Qt__Key = Qt__Key(0x4a)
	Qt__Key_K                       Qt__Key = Qt__Key(0x4b)
	Qt__Key_L                       Qt__Key = Qt__Key(0x4c)
	Qt__Key_M                       Qt__Key = Qt__Key(0x4d)
	Qt__Key_N                       Qt__Key = Qt__Key(0x4e)
	Qt__Key_O                       Qt__Key = Qt__Key(0x4f)
	Qt__Key_P                       Qt__Key = Qt__Key(0x50)
	Qt__Key_Q                       Qt__Key = Qt__Key(0x51)
	Qt__Key_R                       Qt__Key = Qt__Key(0x52)
	Qt__Key_S                       Qt__Key = Qt__Key(0x53)
	Qt__Key_T                       Qt__Key = Qt__Key(0x54)
	Qt__Key_U                       Qt__Key = Qt__Key(0x55)
	Qt__Key_V                       Qt__Key = Qt__Key(0x56)
	Qt__Key_W                       Qt__Key = Qt__Key(0x57)
	Qt__Key_X                       Qt__Key = Qt__Key(0x58)
	Qt__Key_Y                       Qt__Key = Qt__Key(0x59)
	Qt__Key_Z                       Qt__Key = Qt__Key(0x5a)
	Qt__Key_BracketLeft             Qt__Key = Qt__Key(0x5b)
	Qt__Key_Backslash               Qt__Key = Qt__Key(0x5c)
	Qt__Key_BracketRight            Qt__Key = Qt__Key(0x5d)
	Qt__Key_AsciiCircum             Qt__Key = Qt__Key(0x5e)
	Qt__Key_Underscore              Qt__Key = Qt__Key(0x5f)
	Qt__Key_QuoteLeft               Qt__Key = Qt__Key(0x60)
	Qt__Key_BraceLeft               Qt__Key = Qt__Key(0x7b)
	Qt__Key_Bar                     Qt__Key = Qt__Key(0x7c)
	Qt__Key_BraceRight              Qt__Key = Qt__Key(0x7d)
	Qt__Key_AsciiTilde              Qt__Key = Qt__Key(0x7e)
	Qt__Key_nobreakspace            Qt__Key = Qt__Key(0x0a0)
	Qt__Key_exclamdown              Qt__Key = Qt__Key(0x0a1)
	Qt__Key_cent                    Qt__Key = Qt__Key(0x0a2)
	Qt__Key_sterling                Qt__Key = Qt__Key(0x0a3)
	Qt__Key_currency                Qt__Key = Qt__Key(0x0a4)
	Qt__Key_yen                     Qt__Key = Qt__Key(0x0a5)
	Qt__Key_brokenbar               Qt__Key = Qt__Key(0x0a6)
	Qt__Key_section                 Qt__Key = Qt__Key(0x0a7)
	Qt__Key_diaeresis               Qt__Key = Qt__Key(0x0a8)
	Qt__Key_copyright               Qt__Key = Qt__Key(0x0a9)
	Qt__Key_ordfeminine             Qt__Key = Qt__Key(0x0aa)
	Qt__Key_guillemotleft           Qt__Key = Qt__Key(0x0ab)
	Qt__Key_notsign                 Qt__Key = Qt__Key(0x0ac)
	Qt__Key_hyphen                  Qt__Key = Qt__Key(0x0ad)
	Qt__Key_registered              Qt__Key = Qt__Key(0x0ae)
	Qt__Key_macron                  Qt__Key = Qt__Key(0x0af)
	Qt__Key_degree                  Qt__Key = Qt__Key(0x0b0)
	Qt__Key_plusminus               Qt__Key = Qt__Key(0x0b1)
	Qt__Key_twosuperior             Qt__Key = Qt__Key(0x0b2)
	Qt__Key_threesuperior           Qt__Key = Qt__Key(0x0b3)
	Qt__Key_acute                   Qt__Key = Qt__Key(0x0b4)
	Qt__Key_mu                      Qt__Key = Qt__Key(0x0b5)
	Qt__Key_paragraph               Qt__Key = Qt__Key(0x0b6)
	Qt__Key_periodcentered          Qt__Key = Qt__Key(0x0b7)
	Qt__Key_cedilla                 Qt__Key = Qt__Key(0x0b8)
	Qt__Key_onesuperior             Qt__Key = Qt__Key(0x0b9)
	Qt__Key_masculine               Qt__Key = Qt__Key(0x0ba)
	Qt__Key_guillemotright          Qt__Key = Qt__Key(0x0bb)
	Qt__Key_onequarter              Qt__Key = Qt__Key(0x0bc)
	Qt__Key_onehalf                 Qt__Key = Qt__Key(0x0bd)
	Qt__Key_threequarters           Qt__Key = Qt__Key(0x0be)
	Qt__Key_questiondown            Qt__Key = Qt__Key(0x0bf)
	Qt__Key_Agrave                  Qt__Key = Qt__Key(0x0c0)
	Qt__Key_Aacute                  Qt__Key = Qt__Key(0x0c1)
	Qt__Key_Acircumflex             Qt__Key = Qt__Key(0x0c2)
	Qt__Key_Atilde                  Qt__Key = Qt__Key(0x0c3)
	Qt__Key_Adiaeresis              Qt__Key = Qt__Key(0x0c4)
	Qt__Key_Aring                   Qt__Key = Qt__Key(0x0c5)
	Qt__Key_AE                      Qt__Key = Qt__Key(0x0c6)
	Qt__Key_Ccedilla                Qt__Key = Qt__Key(0x0c7)
	Qt__Key_Egrave                  Qt__Key = Qt__Key(0x0c8)
	Qt__Key_Eacute                  Qt__Key = Qt__Key(0x0c9)
	Qt__Key_Ecircumflex             Qt__Key = Qt__Key(0x0ca)
	Qt__Key_Ediaeresis              Qt__Key = Qt__Key(0x0cb)
	Qt__Key_Igrave                  Qt__Key = Qt__Key(0x0cc)
	Qt__Key_Iacute                  Qt__Key = Qt__Key(0x0cd)
	Qt__Key_Icircumflex             Qt__Key = Qt__Key(0x0ce)
	Qt__Key_Idiaeresis              Qt__Key = Qt__Key(0x0cf)
	Qt__Key_ETH                     Qt__Key = Qt__Key(0x0d0)
	Qt__Key_Ntilde                  Qt__Key = Qt__Key(0x0d1)
	Qt__Key_Ograve                  Qt__Key = Qt__Key(0x0d2)
	Qt__Key_Oacute                  Qt__Key = Qt__Key(0x0d3)
	Qt__Key_Ocircumflex             Qt__Key = Qt__Key(0x0d4)
	Qt__Key_Otilde                  Qt__Key = Qt__Key(0x0d5)
	Qt__Key_Odiaeresis              Qt__Key = Qt__Key(0x0d6)
	Qt__Key_multiply                Qt__Key = Qt__Key(0x0d7)
	Qt__Key_Ooblique                Qt__Key = Qt__Key(0x0d8)
	Qt__Key_Ugrave                  Qt__Key = Qt__Key(0x0d9)
	Qt__Key_Uacute                  Qt__Key = Qt__Key(0x0da)
	Qt__Key_Ucircumflex             Qt__Key = Qt__Key(0x0db)
	Qt__Key_Udiaeresis              Qt__Key = Qt__Key(0x0dc)
	Qt__Key_Yacute                  Qt__Key = Qt__Key(0x0dd)
	Qt__Key_THORN                   Qt__Key = Qt__Key(0x0de)
	Qt__Key_ssharp                  Qt__Key = Qt__Key(0x0df)
	Qt__Key_division                Qt__Key = Qt__Key(0x0f7)
	Qt__Key_ydiaeresis              Qt__Key = Qt__Key(0x0ff)
	Qt__Key_AltGr                   Qt__Key = Qt__Key(0x01001103)
	Qt__Key_Multi_key               Qt__Key = Qt__Key(0x01001120)
	Qt__Key_Codeinput               Qt__Key = Qt__Key(0x01001137)
	Qt__Key_SingleCandidate         Qt__Key = Qt__Key(0x0100113c)
	Qt__Key_MultipleCandidate       Qt__Key = Qt__Key(0x0100113d)
	Qt__Key_PreviousCandidate       Qt__Key = Qt__Key(0x0100113e)
	Qt__Key_Mode_switch             Qt__Key = Qt__Key(0x0100117e)
	Qt__Key_Kanji                   Qt__Key = Qt__Key(0x01001121)
	Qt__Key_Muhenkan                Qt__Key = Qt__Key(0x01001122)
	Qt__Key_Henkan                  Qt__Key = Qt__Key(0x01001123)
	Qt__Key_Romaji                  Qt__Key = Qt__Key(0x01001124)
	Qt__Key_Hiragana                Qt__Key = Qt__Key(0x01001125)
	Qt__Key_Katakana                Qt__Key = Qt__Key(0x01001126)
	Qt__Key_Hiragana_Katakana       Qt__Key = Qt__Key(0x01001127)
	Qt__Key_Zenkaku                 Qt__Key = Qt__Key(0x01001128)
	Qt__Key_Hankaku                 Qt__Key = Qt__Key(0x01001129)
	Qt__Key_Zenkaku_Hankaku         Qt__Key = Qt__Key(0x0100112a)
	Qt__Key_Touroku                 Qt__Key = Qt__Key(0x0100112b)
	Qt__Key_Massyo                  Qt__Key = Qt__Key(0x0100112c)
	Qt__Key_Kana_Lock               Qt__Key = Qt__Key(0x0100112d)
	Qt__Key_Kana_Shift              Qt__Key = Qt__Key(0x0100112e)
	Qt__Key_Eisu_Shift              Qt__Key = Qt__Key(0x0100112f)
	Qt__Key_Eisu_toggle             Qt__Key = Qt__Key(0x01001130)
	Qt__Key_Hangul                  Qt__Key = Qt__Key(0x01001131)
	Qt__Key_Hangul_Start            Qt__Key = Qt__Key(0x01001132)
	Qt__Key_Hangul_End              Qt__Key = Qt__Key(0x01001133)
	Qt__Key_Hangul_Hanja            Qt__Key = Qt__Key(0x01001134)
	Qt__Key_Hangul_Jamo             Qt__Key = Qt__Key(0x01001135)
	Qt__Key_Hangul_Romaja           Qt__Key = Qt__Key(0x01001136)
	Qt__Key_Hangul_Jeonja           Qt__Key = Qt__Key(0x01001138)
	Qt__Key_Hangul_Banja            Qt__Key = Qt__Key(0x01001139)
	Qt__Key_Hangul_PreHanja         Qt__Key = Qt__Key(0x0100113a)
	Qt__Key_Hangul_PostHanja        Qt__Key = Qt__Key(0x0100113b)
	Qt__Key_Hangul_Special          Qt__Key = Qt__Key(0x0100113f)
	Qt__Key_Dead_Grave              Qt__Key = Qt__Key(0x01001250)
	Qt__Key_Dead_Acute              Qt__Key = Qt__Key(0x01001251)
	Qt__Key_Dead_Circumflex         Qt__Key = Qt__Key(0x01001252)
	Qt__Key_Dead_Tilde              Qt__Key = Qt__Key(0x01001253)
	Qt__Key_Dead_Macron             Qt__Key = Qt__Key(0x01001254)
	Qt__Key_Dead_Breve              Qt__Key = Qt__Key(0x01001255)
	Qt__Key_Dead_Abovedot           Qt__Key = Qt__Key(0x01001256)
	Qt__Key_Dead_Diaeresis          Qt__Key = Qt__Key(0x01001257)
	Qt__Key_Dead_Abovering          Qt__Key = Qt__Key(0x01001258)
	Qt__Key_Dead_Doubleacute        Qt__Key = Qt__Key(0x01001259)
	Qt__Key_Dead_Caron              Qt__Key = Qt__Key(0x0100125a)
	Qt__Key_Dead_Cedilla            Qt__Key = Qt__Key(0x0100125b)
	Qt__Key_Dead_Ogonek             Qt__Key = Qt__Key(0x0100125c)
	Qt__Key_Dead_Iota               Qt__Key = Qt__Key(0x0100125d)
	Qt__Key_Dead_Voiced_Sound       Qt__Key = Qt__Key(0x0100125e)
	Qt__Key_Dead_Semivoiced_Sound   Qt__Key = Qt__Key(0x0100125f)
	Qt__Key_Dead_Belowdot           Qt__Key = Qt__Key(0x01001260)
	Qt__Key_Dead_Hook               Qt__Key = Qt__Key(0x01001261)
	Qt__Key_Dead_Horn               Qt__Key = Qt__Key(0x01001262)
	Qt__Key_Dead_Stroke             Qt__Key = Qt__Key(0x01001263)
	Qt__Key_Dead_Abovecomma         Qt__Key = Qt__Key(0x01001264)
	Qt__Key_Dead_Abovereversedcomma Qt__Key = Qt__Key(0x01001265)
	Qt__Key_Dead_Doublegrave        Qt__Key = Qt__Key(0x01001266)
	Qt__Key_Dead_Belowring          Qt__Key = Qt__Key(0x01001267)
	Qt__Key_Dead_Belowmacron        Qt__Key = Qt__Key(0x01001268)
	Qt__Key_Dead_Belowcircumflex    Qt__Key = Qt__Key(0x01001269)
	Qt__Key_Dead_Belowtilde         Qt__Key = Qt__Key(0x0100126a)
	Qt__Key_Dead_Belowbreve         Qt__Key = Qt__Key(0x0100126b)
	Qt__Key_Dead_Belowdiaeresis     Qt__Key = Qt__Key(0x0100126c)
	Qt__Key_Dead_Invertedbreve      Qt__Key = Qt__Key(0x0100126d)
	Qt__Key_Dead_Belowcomma         Qt__Key = Qt__Key(0x0100126e)
	Qt__Key_Dead_Currency           Qt__Key = Qt__Key(0x0100126f)
	Qt__Key_Dead_a                  Qt__Key = Qt__Key(0x01001280)
	Qt__Key_Dead_A                  Qt__Key = Qt__Key(0x01001281)
	Qt__Key_Dead_e                  Qt__Key = Qt__Key(0x01001282)
	Qt__Key_Dead_E                  Qt__Key = Qt__Key(0x01001283)
	Qt__Key_Dead_i                  Qt__Key = Qt__Key(0x01001284)
	Qt__Key_Dead_I                  Qt__Key = Qt__Key(0x01001285)
	Qt__Key_Dead_o                  Qt__Key = Qt__Key(0x01001286)
	Qt__Key_Dead_O                  Qt__Key = Qt__Key(0x01001287)
	Qt__Key_Dead_u                  Qt__Key = Qt__Key(0x01001288)
	Qt__Key_Dead_U                  Qt__Key = Qt__Key(0x01001289)
	Qt__Key_Dead_Small_Schwa        Qt__Key = Qt__Key(0x0100128a)
	Qt__Key_Dead_Capital_Schwa      Qt__Key = Qt__Key(0x0100128b)
	Qt__Key_Dead_Greek              Qt__Key = Qt__Key(0x0100128c)
	Qt__Key_Dead_Lowline            Qt__Key = Qt__Key(0x01001290)
	Qt__Key_Dead_Aboveverticalline  Qt__Key = Qt__Key(0x01001291)
	Qt__Key_Dead_Belowverticalline  Qt__Key = Qt__Key(0x01001292)
	Qt__Key_Dead_Longsolidusoverlay Qt__Key = Qt__Key(0x01001293)
	Qt__Key_Back                    Qt__Key = Qt__Key(0x01000061)
	Qt__Key_Forward                 Qt__Key = Qt__Key(0x01000062)
	Qt__Key_Stop                    Qt__Key = Qt__Key(0x01000063)
	Qt__Key_Refresh                 Qt__Key = Qt__Key(0x01000064)
	Qt__Key_VolumeDown              Qt__Key = Qt__Key(0x01000070)
	Qt__Key_VolumeMute              Qt__Key = Qt__Key(0x01000071)
	Qt__Key_VolumeUp                Qt__Key = Qt__Key(0x01000072)
	Qt__Key_BassBoost               Qt__Key = Qt__Key(0x01000073)
	Qt__Key_BassUp                  Qt__Key = Qt__Key(0x01000074)
	Qt__Key_BassDown                Qt__Key = Qt__Key(0x01000075)
	Qt__Key_TrebleUp                Qt__Key = Qt__Key(0x01000076)
	Qt__Key_TrebleDown              Qt__Key = Qt__Key(0x01000077)
	Qt__Key_MediaPlay               Qt__Key = Qt__Key(0x01000080)
	Qt__Key_MediaStop               Qt__Key = Qt__Key(0x01000081)
	Qt__Key_MediaPrevious           Qt__Key = Qt__Key(0x01000082)
	Qt__Key_MediaNext               Qt__Key = Qt__Key(0x01000083)
	Qt__Key_MediaRecord             Qt__Key = Qt__Key(0x01000084)
	Qt__Key_MediaPause              Qt__Key = Qt__Key(0x1000085)
	Qt__Key_MediaTogglePlayPause    Qt__Key = Qt__Key(0x1000086)
	Qt__Key_HomePage                Qt__Key = Qt__Key(0x01000090)
	Qt__Key_Favorites               Qt__Key = Qt__Key(0x01000091)
	Qt__Key_Search                  Qt__Key = Qt__Key(0x01000092)
	Qt__Key_Standby                 Qt__Key = Qt__Key(0x01000093)
	Qt__Key_OpenUrl                 Qt__Key = Qt__Key(0x01000094)
	Qt__Key_LaunchMail              Qt__Key = Qt__Key(0x010000a0)
	Qt__Key_LaunchMedia             Qt__Key = Qt__Key(0x010000a1)
	Qt__Key_Launch0                 Qt__Key = Qt__Key(0x010000a2)
	Qt__Key_Launch1                 Qt__Key = Qt__Key(0x010000a3)
	Qt__Key_Launch2                 Qt__Key = Qt__Key(0x010000a4)
	Qt__Key_Launch3                 Qt__Key = Qt__Key(0x010000a5)
	Qt__Key_Launch4                 Qt__Key = Qt__Key(0x010000a6)
	Qt__Key_Launch5                 Qt__Key = Qt__Key(0x010000a7)
	Qt__Key_Launch6                 Qt__Key = Qt__Key(0x010000a8)
	Qt__Key_Launch7                 Qt__Key = Qt__Key(0x010000a9)
	Qt__Key_Launch8                 Qt__Key = Qt__Key(0x010000aa)
	Qt__Key_Launch9                 Qt__Key = Qt__Key(0x010000ab)
	Qt__Key_LaunchA                 Qt__Key = Qt__Key(0x010000ac)
	Qt__Key_LaunchB                 Qt__Key = Qt__Key(0x010000ad)
	Qt__Key_LaunchC                 Qt__Key = Qt__Key(0x010000ae)
	Qt__Key_LaunchD                 Qt__Key = Qt__Key(0x010000af)
	Qt__Key_LaunchE                 Qt__Key = Qt__Key(0x010000b0)
	Qt__Key_LaunchF                 Qt__Key = Qt__Key(0x010000b1)
	Qt__Key_MonBrightnessUp         Qt__Key = Qt__Key(0x010000b2)
	Qt__Key_MonBrightnessDown       Qt__Key = Qt__Key(0x010000b3)
	Qt__Key_KeyboardLightOnOff      Qt__Key = Qt__Key(0x010000b4)
	Qt__Key_KeyboardBrightnessUp    Qt__Key = Qt__Key(0x010000b5)
	Qt__Key_KeyboardBrightnessDown  Qt__Key = Qt__Key(0x010000b6)
	Qt__Key_PowerOff                Qt__Key = Qt__Key(0x010000b7)
	Qt__Key_WakeUp                  Qt__Key = Qt__Key(0x010000b8)
	Qt__Key_Eject                   Qt__Key = Qt__Key(0x010000b9)
	Qt__Key_ScreenSaver             Qt__Key = Qt__Key(0x010000ba)
	Qt__Key_WWW                     Qt__Key = Qt__Key(0x010000bb)
	Qt__Key_Memo                    Qt__Key = Qt__Key(0x010000bc)
	Qt__Key_LightBulb               Qt__Key = Qt__Key(0x010000bd)
	Qt__Key_Shop                    Qt__Key = Qt__Key(0x010000be)
	Qt__Key_History                 Qt__Key = Qt__Key(0x010000bf)
	Qt__Key_AddFavorite             Qt__Key = Qt__Key(0x010000c0)
	Qt__Key_HotLinks                Qt__Key = Qt__Key(0x010000c1)
	Qt__Key_BrightnessAdjust        Qt__Key = Qt__Key(0x010000c2)
	Qt__Key_Finance                 Qt__Key = Qt__Key(0x010000c3)
	Qt__Key_Community               Qt__Key = Qt__Key(0x010000c4)
	Qt__Key_AudioRewind             Qt__Key = Qt__Key(0x010000c5)
	Qt__Key_BackForward             Qt__Key = Qt__Key(0x010000c6)
	Qt__Key_ApplicationLeft         Qt__Key = Qt__Key(0x010000c7)
	Qt__Key_ApplicationRight        Qt__Key = Qt__Key(0x010000c8)
	Qt__Key_Book                    Qt__Key = Qt__Key(0x010000c9)
	Qt__Key_CD                      Qt__Key = Qt__Key(0x010000ca)
	Qt__Key_Calculator              Qt__Key = Qt__Key(0x010000cb)
	Qt__Key_ToDoList                Qt__Key = Qt__Key(0x010000cc)
	Qt__Key_ClearGrab               Qt__Key = Qt__Key(0x010000cd)
	Qt__Key_Close                   Qt__Key = Qt__Key(0x010000ce)
	Qt__Key_Copy                    Qt__Key = Qt__Key(0x010000cf)
	Qt__Key_Cut                     Qt__Key = Qt__Key(0x010000d0)
	Qt__Key_Display                 Qt__Key = Qt__Key(0x010000d1)
	Qt__Key_DOS                     Qt__Key = Qt__Key(0x010000d2)
	Qt__Key_Documents               Qt__Key = Qt__Key(0x010000d3)
	Qt__Key_Excel                   Qt__Key = Qt__Key(0x010000d4)
	Qt__Key_Explorer                Qt__Key = Qt__Key(0x010000d5)
	Qt__Key_Game                    Qt__Key = Qt__Key(0x010000d6)
	Qt__Key_Go                      Qt__Key = Qt__Key(0x010000d7)
	Qt__Key_iTouch                  Qt__Key = Qt__Key(0x010000d8)
	Qt__Key_LogOff                  Qt__Key = Qt__Key(0x010000d9)
	Qt__Key_Market                  Qt__Key = Qt__Key(0x010000da)
	Qt__Key_Meeting                 Qt__Key = Qt__Key(0x010000db)
	Qt__Key_MenuKB                  Qt__Key = Qt__Key(0x010000dc)
	Qt__Key_MenuPB                  Qt__Key = Qt__Key(0x010000dd)
	Qt__Key_MySites                 Qt__Key = Qt__Key(0x010000de)
	Qt__Key_News                    Qt__Key = Qt__Key(0x010000df)
	Qt__Key_OfficeHome              Qt__Key = Qt__Key(0x010000e0)
	Qt__Key_Option                  Qt__Key = Qt__Key(0x010000e1)
	Qt__Key_Paste                   Qt__Key = Qt__Key(0x010000e2)
	Qt__Key_Phone                   Qt__Key = Qt__Key(0x010000e3)
	Qt__Key_Calendar                Qt__Key = Qt__Key(0x010000e4)
	Qt__Key_Reply                   Qt__Key = Qt__Key(0x010000e5)
	Qt__Key_Reload                  Qt__Key = Qt__Key(0x010000e6)
	Qt__Key_RotateWindows           Qt__Key = Qt__Key(0x010000e7)
	Qt__Key_RotationPB              Qt__Key = Qt__Key(0x010000e8)
	Qt__Key_RotationKB              Qt__Key = Qt__Key(0x010000e9)
	Qt__Key_Save                    Qt__Key = Qt__Key(0x010000ea)
	Qt__Key_Send                    Qt__Key = Qt__Key(0x010000eb)
	Qt__Key_Spell                   Qt__Key = Qt__Key(0x010000ec)
	Qt__Key_SplitScreen             Qt__Key = Qt__Key(0x010000ed)
	Qt__Key_Support                 Qt__Key = Qt__Key(0x010000ee)
	Qt__Key_TaskPane                Qt__Key = Qt__Key(0x010000ef)
	Qt__Key_Terminal                Qt__Key = Qt__Key(0x010000f0)
	Qt__Key_Tools                   Qt__Key = Qt__Key(0x010000f1)
	Qt__Key_Travel                  Qt__Key = Qt__Key(0x010000f2)
	Qt__Key_Video                   Qt__Key = Qt__Key(0x010000f3)
	Qt__Key_Word                    Qt__Key = Qt__Key(0x010000f4)
	Qt__Key_Xfer                    Qt__Key = Qt__Key(0x010000f5)
	Qt__Key_ZoomIn                  Qt__Key = Qt__Key(0x010000f6)
	Qt__Key_ZoomOut                 Qt__Key = Qt__Key(0x010000f7)
	Qt__Key_Away                    Qt__Key = Qt__Key(0x010000f8)
	Qt__Key_Messenger               Qt__Key = Qt__Key(0x010000f9)
	Qt__Key_WebCam                  Qt__Key = Qt__Key(0x010000fa)
	Qt__Key_MailForward             Qt__Key = Qt__Key(0x010000fb)
	Qt__Key_Pictures                Qt__Key = Qt__Key(0x010000fc)
	Qt__Key_Music                   Qt__Key = Qt__Key(0x010000fd)
	Qt__Key_Battery                 Qt__Key = Qt__Key(0x010000fe)
	Qt__Key_Bluetooth               Qt__Key = Qt__Key(0x010000ff)
	Qt__Key_WLAN                    Qt__Key = Qt__Key(0x01000100)
	Qt__Key_UWB                     Qt__Key = Qt__Key(0x01000101)
	Qt__Key_AudioForward            Qt__Key = Qt__Key(0x01000102)
	Qt__Key_AudioRepeat             Qt__Key = Qt__Key(0x01000103)
	Qt__Key_AudioRandomPlay         Qt__Key = Qt__Key(0x01000104)
	Qt__Key_Subtitle                Qt__Key = Qt__Key(0x01000105)
	Qt__Key_AudioCycleTrack         Qt__Key = Qt__Key(0x01000106)
	Qt__Key_Time                    Qt__Key = Qt__Key(0x01000107)
	Qt__Key_Hibernate               Qt__Key = Qt__Key(0x01000108)
	Qt__Key_View                    Qt__Key = Qt__Key(0x01000109)
	Qt__Key_TopMenu                 Qt__Key = Qt__Key(0x0100010a)
	Qt__Key_PowerDown               Qt__Key = Qt__Key(0x0100010b)
	Qt__Key_Suspend                 Qt__Key = Qt__Key(0x0100010c)
	Qt__Key_ContrastAdjust          Qt__Key = Qt__Key(0x0100010d)
	Qt__Key_LaunchG                 Qt__Key = Qt__Key(0x0100010e)
	Qt__Key_LaunchH                 Qt__Key = Qt__Key(0x0100010f)
	Qt__Key_TouchpadToggle          Qt__Key = Qt__Key(0x01000110)
	Qt__Key_TouchpadOn              Qt__Key = Qt__Key(0x01000111)
	Qt__Key_TouchpadOff             Qt__Key = Qt__Key(0x01000112)
	Qt__Key_MicMute                 Qt__Key = Qt__Key(0x01000113)
	Qt__Key_Red                     Qt__Key = Qt__Key(0x01000114)
	Qt__Key_Green                   Qt__Key = Qt__Key(0x01000115)
	Qt__Key_Yellow                  Qt__Key = Qt__Key(0x01000116)
	Qt__Key_Blue                    Qt__Key = Qt__Key(0x01000117)
	Qt__Key_ChannelUp               Qt__Key = Qt__Key(0x01000118)
	Qt__Key_ChannelDown             Qt__Key = Qt__Key(0x01000119)
	Qt__Key_Guide                   Qt__Key = Qt__Key(0x0100011a)
	Qt__Key_Info                    Qt__Key = Qt__Key(0x0100011b)
	Qt__Key_Settings                Qt__Key = Qt__Key(0x0100011c)
	Qt__Key_MicVolumeUp             Qt__Key = Qt__Key(0x0100011d)
	Qt__Key_MicVolumeDown           Qt__Key = Qt__Key(0x0100011e)
	Qt__Key_New                     Qt__Key = Qt__Key(0x01000120)
	Qt__Key_Open                    Qt__Key = Qt__Key(0x01000121)
	Qt__Key_Find                    Qt__Key = Qt__Key(0x01000122)
	Qt__Key_Undo                    Qt__Key = Qt__Key(0x01000123)
	Qt__Key_Redo                    Qt__Key = Qt__Key(0x01000124)
	Qt__Key_MediaLast               Qt__Key = Qt__Key(0x0100ffff)
	Qt__Key_Select                  Qt__Key = Qt__Key(0x01010000)
	Qt__Key_Yes                     Qt__Key = Qt__Key(0x01010001)
	Qt__Key_No                      Qt__Key = Qt__Key(0x01010002)
	Qt__Key_Cancel                  Qt__Key = Qt__Key(0x01020001)
	Qt__Key_Printer                 Qt__Key = Qt__Key(0x01020002)
	Qt__Key_Execute                 Qt__Key = Qt__Key(0x01020003)
	Qt__Key_Sleep                   Qt__Key = Qt__Key(0x01020004)
	Qt__Key_Play                    Qt__Key = Qt__Key(0x01020005)
	Qt__Key_Zoom                    Qt__Key = Qt__Key(0x01020006)
	Qt__Key_Exit                    Qt__Key = Qt__Key(0x0102000a)
	Qt__Key_Context1                Qt__Key = Qt__Key(0x01100000)
	Qt__Key_Context2                Qt__Key = Qt__Key(0x01100001)
	Qt__Key_Context3                Qt__Key = Qt__Key(0x01100002)
	Qt__Key_Context4                Qt__Key = Qt__Key(0x01100003)
	Qt__Key_Call                    Qt__Key = Qt__Key(0x01100004)
	Qt__Key_Hangup                  Qt__Key = Qt__Key(0x01100005)
	Qt__Key_Flip                    Qt__Key = Qt__Key(0x01100006)
	Qt__Key_ToggleCallHangup        Qt__Key = Qt__Key(0x01100007)
	Qt__Key_VoiceDial               Qt__Key = Qt__Key(0x01100008)
	Qt__Key_LastNumberRedial        Qt__Key = Qt__Key(0x01100009)
	Qt__Key_Camera                  Qt__Key = Qt__Key(0x01100020)
	Qt__Key_CameraFocus             Qt__Key = Qt__Key(0x01100021)
	Qt__Key_unknown                 Qt__Key = Qt__Key(0x01ffffff)
)

//go:generate stringer -type=Qt__ArrowType
//Qt::ArrowType
type Qt__ArrowType int64

const (
	Qt__NoArrow    Qt__ArrowType = Qt__ArrowType(0)
	Qt__UpArrow    Qt__ArrowType = Qt__ArrowType(1)
	Qt__DownArrow  Qt__ArrowType = Qt__ArrowType(2)
	Qt__LeftArrow  Qt__ArrowType = Qt__ArrowType(3)
	Qt__RightArrow Qt__ArrowType = Qt__ArrowType(4)
)

//go:generate stringer -type=Qt__PenStyle
//Qt::PenStyle
type Qt__PenStyle int64

var (
	Qt__NoPen          Qt__PenStyle = Qt__PenStyle(0)
	Qt__SolidLine      Qt__PenStyle = Qt__PenStyle(1)
	Qt__DashLine       Qt__PenStyle = Qt__PenStyle(2)
	Qt__DotLine        Qt__PenStyle = Qt__PenStyle(3)
	Qt__DashDotLine    Qt__PenStyle = Qt__PenStyle(4)
	Qt__DashDotDotLine Qt__PenStyle = Qt__PenStyle(5)
	Qt__CustomDashLine Qt__PenStyle = Qt__PenStyle(6)
	Qt__MPenStyle      Qt__PenStyle = Qt__PenStyle(0x0f)
)

//go:generate stringer -type=Qt__PenCapStyle
//Qt::PenCapStyle
type Qt__PenCapStyle int64

var (
	Qt__FlatCap      Qt__PenCapStyle = Qt__PenCapStyle(0x00)
	Qt__SquareCap    Qt__PenCapStyle = Qt__PenCapStyle(0x10)
	Qt__RoundCap     Qt__PenCapStyle = Qt__PenCapStyle(0x20)
	Qt__MPenCapStyle Qt__PenCapStyle = Qt__PenCapStyle(0x30)
)

//go:generate stringer -type=Qt__PenJoinStyle
//Qt::PenJoinStyle
type Qt__PenJoinStyle int64

var (
	Qt__MiterJoin     Qt__PenJoinStyle = Qt__PenJoinStyle(0x00)
	Qt__BevelJoin     Qt__PenJoinStyle = Qt__PenJoinStyle(0x40)
	Qt__RoundJoin     Qt__PenJoinStyle = Qt__PenJoinStyle(0x80)
	Qt__SvgMiterJoin  Qt__PenJoinStyle = Qt__PenJoinStyle(0x100)
	Qt__MPenJoinStyle Qt__PenJoinStyle = Qt__PenJoinStyle(0x1c0)
)

//go:generate stringer -type=Qt__BrushStyle
//Qt::BrushStyle
type Qt__BrushStyle int64

var (
	Qt__NoBrush                Qt__BrushStyle = Qt__BrushStyle(0)
	Qt__SolidPattern           Qt__BrushStyle = Qt__BrushStyle(1)
	Qt__Dense1Pattern          Qt__BrushStyle = Qt__BrushStyle(2)
	Qt__Dense2Pattern          Qt__BrushStyle = Qt__BrushStyle(3)
	Qt__Dense3Pattern          Qt__BrushStyle = Qt__BrushStyle(4)
	Qt__Dense4Pattern          Qt__BrushStyle = Qt__BrushStyle(5)
	Qt__Dense5Pattern          Qt__BrushStyle = Qt__BrushStyle(6)
	Qt__Dense6Pattern          Qt__BrushStyle = Qt__BrushStyle(7)
	Qt__Dense7Pattern          Qt__BrushStyle = Qt__BrushStyle(8)
	Qt__HorPattern             Qt__BrushStyle = Qt__BrushStyle(9)
	Qt__VerPattern             Qt__BrushStyle = Qt__BrushStyle(10)
	Qt__CrossPattern           Qt__BrushStyle = Qt__BrushStyle(11)
	Qt__BDiagPattern           Qt__BrushStyle = Qt__BrushStyle(12)
	Qt__FDiagPattern           Qt__BrushStyle = Qt__BrushStyle(13)
	Qt__DiagCrossPattern       Qt__BrushStyle = Qt__BrushStyle(14)
	Qt__LinearGradientPattern  Qt__BrushStyle = Qt__BrushStyle(15)
	Qt__RadialGradientPattern  Qt__BrushStyle = Qt__BrushStyle(16)
	Qt__ConicalGradientPattern Qt__BrushStyle = Qt__BrushStyle(17)
	Qt__TexturePattern         Qt__BrushStyle = Qt__BrushStyle(24)
)

//go:generate stringer -type=Qt__SizeMode
//Qt::SizeMode
type Qt__SizeMode int64

const (
	Qt__AbsoluteSize Qt__SizeMode = Qt__SizeMode(0)
	Qt__RelativeSize Qt__SizeMode = Qt__SizeMode(1)
)

//go:generate stringer -type=Qt__UIEffect
//Qt::UIEffect
type Qt__UIEffect int64

const (
	Qt__UI_General        Qt__UIEffect = Qt__UIEffect(0)
	Qt__UI_AnimateMenu    Qt__UIEffect = Qt__UIEffect(1)
	Qt__UI_FadeMenu       Qt__UIEffect = Qt__UIEffect(2)
	Qt__UI_AnimateCombo   Qt__UIEffect = Qt__UIEffect(3)
	Qt__UI_AnimateTooltip Qt__UIEffect = Qt__UIEffect(4)
	Qt__UI_FadeTooltip    Qt__UIEffect = Qt__UIEffect(5)
	Qt__UI_AnimateToolBox Qt__UIEffect = Qt__UIEffect(6)
)

//go:generate stringer -type=Qt__CursorShape
//Qt::CursorShape
type Qt__CursorShape int64

const (
	Qt__ArrowCursor        Qt__CursorShape = Qt__CursorShape(0)
	Qt__UpArrowCursor      Qt__CursorShape = Qt__CursorShape(1)
	Qt__CrossCursor        Qt__CursorShape = Qt__CursorShape(2)
	Qt__WaitCursor         Qt__CursorShape = Qt__CursorShape(3)
	Qt__IBeamCursor        Qt__CursorShape = Qt__CursorShape(4)
	Qt__SizeVerCursor      Qt__CursorShape = Qt__CursorShape(5)
	Qt__SizeHorCursor      Qt__CursorShape = Qt__CursorShape(6)
	Qt__SizeBDiagCursor    Qt__CursorShape = Qt__CursorShape(7)
	Qt__SizeFDiagCursor    Qt__CursorShape = Qt__CursorShape(8)
	Qt__SizeAllCursor      Qt__CursorShape = Qt__CursorShape(9)
	Qt__BlankCursor        Qt__CursorShape = Qt__CursorShape(10)
	Qt__SplitVCursor       Qt__CursorShape = Qt__CursorShape(11)
	Qt__SplitHCursor       Qt__CursorShape = Qt__CursorShape(12)
	Qt__PointingHandCursor Qt__CursorShape = Qt__CursorShape(13)
	Qt__ForbiddenCursor    Qt__CursorShape = Qt__CursorShape(14)
	Qt__WhatsThisCursor    Qt__CursorShape = Qt__CursorShape(15)
	Qt__BusyCursor         Qt__CursorShape = Qt__CursorShape(16)
	Qt__OpenHandCursor     Qt__CursorShape = Qt__CursorShape(17)
	Qt__ClosedHandCursor   Qt__CursorShape = Qt__CursorShape(18)
	Qt__DragCopyCursor     Qt__CursorShape = Qt__CursorShape(19)
	Qt__DragMoveCursor     Qt__CursorShape = Qt__CursorShape(20)
	Qt__DragLinkCursor     Qt__CursorShape = Qt__CursorShape(21)
	Qt__LastCursor         Qt__CursorShape = Qt__CursorShape(Qt__DragLinkCursor)
	Qt__BitmapCursor       Qt__CursorShape = Qt__CursorShape(24)
	Qt__CustomCursor       Qt__CursorShape = Qt__CursorShape(25)
)

//go:generate stringer -type=Qt__TextFormat
//Qt::TextFormat
type Qt__TextFormat int64

const (
	Qt__PlainText Qt__TextFormat = Qt__TextFormat(0)
	Qt__RichText  Qt__TextFormat = Qt__TextFormat(1)
	Qt__AutoText  Qt__TextFormat = Qt__TextFormat(2)
)

//go:generate stringer -type=Qt__AspectRatioMode
//Qt::AspectRatioMode
type Qt__AspectRatioMode int64

const (
	Qt__IgnoreAspectRatio          Qt__AspectRatioMode = Qt__AspectRatioMode(0)
	Qt__KeepAspectRatio            Qt__AspectRatioMode = Qt__AspectRatioMode(1)
	Qt__KeepAspectRatioByExpanding Qt__AspectRatioMode = Qt__AspectRatioMode(2)
)

//go:generate stringer -type=Qt__DockWidgetArea
//Qt::DockWidgetArea
type Qt__DockWidgetArea int64

const (
	Qt__LeftDockWidgetArea   Qt__DockWidgetArea = Qt__DockWidgetArea(0x1)
	Qt__RightDockWidgetArea  Qt__DockWidgetArea = Qt__DockWidgetArea(0x2)
	Qt__TopDockWidgetArea    Qt__DockWidgetArea = Qt__DockWidgetArea(0x4)
	Qt__BottomDockWidgetArea Qt__DockWidgetArea = Qt__DockWidgetArea(0x8)
	Qt__DockWidgetArea_Mask  Qt__DockWidgetArea = Qt__DockWidgetArea(0xf)
	Qt__AllDockWidgetAreas   Qt__DockWidgetArea = Qt__DockWidgetArea(Qt__DockWidgetArea_Mask)
	Qt__NoDockWidgetArea     Qt__DockWidgetArea = Qt__DockWidgetArea(0)
)

//go:generate stringer -type=Qt__ToolBarArea
//Qt::ToolBarArea
type Qt__ToolBarArea int64

const (
	Qt__LeftToolBarArea   Qt__ToolBarArea = Qt__ToolBarArea(0x1)
	Qt__RightToolBarArea  Qt__ToolBarArea = Qt__ToolBarArea(0x2)
	Qt__TopToolBarArea    Qt__ToolBarArea = Qt__ToolBarArea(0x4)
	Qt__BottomToolBarArea Qt__ToolBarArea = Qt__ToolBarArea(0x8)
	Qt__ToolBarArea_Mask  Qt__ToolBarArea = Qt__ToolBarArea(0xf)
	Qt__AllToolBarAreas   Qt__ToolBarArea = Qt__ToolBarArea(Qt__ToolBarArea_Mask)
	Qt__NoToolBarArea     Qt__ToolBarArea = Qt__ToolBarArea(0)
)

//go:generate stringer -type=Qt__DateFormat
//Qt::DateFormat
type Qt__DateFormat int64

const (
	Qt__TextDate               Qt__DateFormat = Qt__DateFormat(0)
	Qt__ISODate                Qt__DateFormat = Qt__DateFormat(1)
	Qt__SystemLocaleDate       Qt__DateFormat = Qt__DateFormat(2)
	Qt__LocalDate              Qt__DateFormat = Qt__DateFormat(Qt__SystemLocaleDate)
	Qt__LocaleDate             Qt__DateFormat = Qt__DateFormat(3)
	Qt__SystemLocaleShortDate  Qt__DateFormat = Qt__DateFormat(4)
	Qt__SystemLocaleLongDate   Qt__DateFormat = Qt__DateFormat(5)
	Qt__DefaultLocaleShortDate Qt__DateFormat = Qt__DateFormat(6)
	Qt__DefaultLocaleLongDate  Qt__DateFormat = Qt__DateFormat(7)
	Qt__RFC2822Date            Qt__DateFormat = Qt__DateFormat(8)
	Qt__ISODateWithMs          Qt__DateFormat = Qt__DateFormat(9)
)

//go:generate stringer -type=Qt__TimeSpec
//Qt::TimeSpec
type Qt__TimeSpec int64

const (
	Qt__LocalTime     Qt__TimeSpec = Qt__TimeSpec(0)
	Qt__UTC           Qt__TimeSpec = Qt__TimeSpec(1)
	Qt__OffsetFromUTC Qt__TimeSpec = Qt__TimeSpec(2)
	Qt__TimeZone      Qt__TimeSpec = Qt__TimeSpec(3)
)

//go:generate stringer -type=Qt__DayOfWeek
//Qt::DayOfWeek
type Qt__DayOfWeek int64

const (
	Qt__Monday    Qt__DayOfWeek = Qt__DayOfWeek(1)
	Qt__Tuesday   Qt__DayOfWeek = Qt__DayOfWeek(2)
	Qt__Wednesday Qt__DayOfWeek = Qt__DayOfWeek(3)
	Qt__Thursday  Qt__DayOfWeek = Qt__DayOfWeek(4)
	Qt__Friday    Qt__DayOfWeek = Qt__DayOfWeek(5)
	Qt__Saturday  Qt__DayOfWeek = Qt__DayOfWeek(6)
	Qt__Sunday    Qt__DayOfWeek = Qt__DayOfWeek(7)
)

//go:generate stringer -type=Qt__ScrollBarPolicy
//Qt::ScrollBarPolicy
type Qt__ScrollBarPolicy int64

const (
	Qt__ScrollBarAsNeeded  Qt__ScrollBarPolicy = Qt__ScrollBarPolicy(0)
	Qt__ScrollBarAlwaysOff Qt__ScrollBarPolicy = Qt__ScrollBarPolicy(1)
	Qt__ScrollBarAlwaysOn  Qt__ScrollBarPolicy = Qt__ScrollBarPolicy(2)
)

//go:generate stringer -type=Qt__CaseSensitivity
//Qt::CaseSensitivity
type Qt__CaseSensitivity int64

const (
	Qt__CaseInsensitive Qt__CaseSensitivity = Qt__CaseSensitivity(0)
	Qt__CaseSensitive   Qt__CaseSensitivity = Qt__CaseSensitivity(1)
)

//go:generate stringer -type=Qt__Corner
//Qt::Corner
type Qt__Corner int64

const (
	Qt__TopLeftCorner     Qt__Corner = Qt__Corner(0x00000)
	Qt__TopRightCorner    Qt__Corner = Qt__Corner(0x00001)
	Qt__BottomLeftCorner  Qt__Corner = Qt__Corner(0x00002)
	Qt__BottomRightCorner Qt__Corner = Qt__Corner(0x00003)
)

//go:generate stringer -type=Qt__Edge
//Qt::Edge
type Qt__Edge int64

const (
	Qt__TopEdge    Qt__Edge = Qt__Edge(0x00001)
	Qt__LeftEdge   Qt__Edge = Qt__Edge(0x00002)
	Qt__RightEdge  Qt__Edge = Qt__Edge(0x00004)
	Qt__BottomEdge Qt__Edge = Qt__Edge(0x00008)
)

//go:generate stringer -type=Qt__ShortcutContext
//Qt::ShortcutContext
type Qt__ShortcutContext int64

const (
	Qt__WidgetShortcut             Qt__ShortcutContext = Qt__ShortcutContext(0)
	Qt__WindowShortcut             Qt__ShortcutContext = Qt__ShortcutContext(1)
	Qt__ApplicationShortcut        Qt__ShortcutContext = Qt__ShortcutContext(2)
	Qt__WidgetWithChildrenShortcut Qt__ShortcutContext = Qt__ShortcutContext(3)
)

//go:generate stringer -type=Qt__ConnectionType
//Qt::ConnectionType
type Qt__ConnectionType int64

const (
	Qt__AutoConnection           Qt__ConnectionType = Qt__ConnectionType(0)
	Qt__DirectConnection         Qt__ConnectionType = Qt__ConnectionType(1)
	Qt__QueuedConnection         Qt__ConnectionType = Qt__ConnectionType(2)
	Qt__BlockingQueuedConnection Qt__ConnectionType = Qt__ConnectionType(3)
	Qt__UniqueConnection         Qt__ConnectionType = Qt__ConnectionType(0x80)
)

//go:generate stringer -type=Qt__FillRule
//Qt::FillRule
type Qt__FillRule int64

const (
	Qt__OddEvenFill Qt__FillRule = Qt__FillRule(0)
	Qt__WindingFill Qt__FillRule = Qt__FillRule(1)
)

//go:generate stringer -type=Qt__MaskMode
//Qt::MaskMode
type Qt__MaskMode int64

const (
	Qt__MaskInColor  Qt__MaskMode = Qt__MaskMode(0)
	Qt__MaskOutColor Qt__MaskMode = Qt__MaskMode(1)
)

//go:generate stringer -type=Qt__ClipOperation
//Qt::ClipOperation
type Qt__ClipOperation int64

const (
	Qt__NoClip        Qt__ClipOperation = Qt__ClipOperation(0)
	Qt__ReplaceClip   Qt__ClipOperation = Qt__ClipOperation(1)
	Qt__IntersectClip Qt__ClipOperation = Qt__ClipOperation(2)
)

//go:generate stringer -type=Qt__ItemSelectionMode
//Qt::ItemSelectionMode
type Qt__ItemSelectionMode int64

const (
	Qt__ContainsItemShape          Qt__ItemSelectionMode = Qt__ItemSelectionMode(0x0)
	Qt__IntersectsItemShape        Qt__ItemSelectionMode = Qt__ItemSelectionMode(0x1)
	Qt__ContainsItemBoundingRect   Qt__ItemSelectionMode = Qt__ItemSelectionMode(0x2)
	Qt__IntersectsItemBoundingRect Qt__ItemSelectionMode = Qt__ItemSelectionMode(0x3)
)

//go:generate stringer -type=Qt__ItemSelectionOperation
//Qt::ItemSelectionOperation
type Qt__ItemSelectionOperation int64

const (
	Qt__ReplaceSelection Qt__ItemSelectionOperation = Qt__ItemSelectionOperation(0)
	Qt__AddToSelection   Qt__ItemSelectionOperation = Qt__ItemSelectionOperation(1)
)

//go:generate stringer -type=Qt__TransformationMode
//Qt::TransformationMode
type Qt__TransformationMode int64

const (
	Qt__FastTransformation   Qt__TransformationMode = Qt__TransformationMode(0)
	Qt__SmoothTransformation Qt__TransformationMode = Qt__TransformationMode(1)
)

//go:generate stringer -type=Qt__Axis
//Qt::Axis
type Qt__Axis int64

const (
	Qt__XAxis Qt__Axis = Qt__Axis(0)
	Qt__YAxis Qt__Axis = Qt__Axis(1)
	Qt__ZAxis Qt__Axis = Qt__Axis(2)
)

//go:generate stringer -type=Qt__FocusReason
//Qt::FocusReason
type Qt__FocusReason int64

const (
	Qt__MouseFocusReason        Qt__FocusReason = Qt__FocusReason(0)
	Qt__TabFocusReason          Qt__FocusReason = Qt__FocusReason(1)
	Qt__BacktabFocusReason      Qt__FocusReason = Qt__FocusReason(2)
	Qt__ActiveWindowFocusReason Qt__FocusReason = Qt__FocusReason(3)
	Qt__PopupFocusReason        Qt__FocusReason = Qt__FocusReason(4)
	Qt__ShortcutFocusReason     Qt__FocusReason = Qt__FocusReason(5)
	Qt__MenuBarFocusReason      Qt__FocusReason = Qt__FocusReason(6)
	Qt__OtherFocusReason        Qt__FocusReason = Qt__FocusReason(7)
	Qt__NoFocusReason           Qt__FocusReason = Qt__FocusReason(8)
)

//go:generate stringer -type=Qt__ContextMenuPolicy
//Qt::ContextMenuPolicy
type Qt__ContextMenuPolicy int64

const (
	Qt__NoContextMenu      Qt__ContextMenuPolicy = Qt__ContextMenuPolicy(0)
	Qt__DefaultContextMenu Qt__ContextMenuPolicy = Qt__ContextMenuPolicy(1)
	Qt__ActionsContextMenu Qt__ContextMenuPolicy = Qt__ContextMenuPolicy(2)
	Qt__CustomContextMenu  Qt__ContextMenuPolicy = Qt__ContextMenuPolicy(3)
	Qt__PreventContextMenu Qt__ContextMenuPolicy = Qt__ContextMenuPolicy(4)
)

//go:generate stringer -type=Qt__InputMethodQuery
//Qt::InputMethodQuery
type Qt__InputMethodQuery int64

const (
	Qt__ImEnabled                Qt__InputMethodQuery = Qt__InputMethodQuery(0x1)
	Qt__ImCursorRectangle        Qt__InputMethodQuery = Qt__InputMethodQuery(0x2)
	Qt__ImMicroFocus             Qt__InputMethodQuery = Qt__InputMethodQuery(0x2)
	Qt__ImFont                   Qt__InputMethodQuery = Qt__InputMethodQuery(0x4)
	Qt__ImCursorPosition         Qt__InputMethodQuery = Qt__InputMethodQuery(0x8)
	Qt__ImSurroundingText        Qt__InputMethodQuery = Qt__InputMethodQuery(0x10)
	Qt__ImCurrentSelection       Qt__InputMethodQuery = Qt__InputMethodQuery(0x20)
	Qt__ImMaximumTextLength      Qt__InputMethodQuery = Qt__InputMethodQuery(0x40)
	Qt__ImAnchorPosition         Qt__InputMethodQuery = Qt__InputMethodQuery(0x80)
	Qt__ImHints                  Qt__InputMethodQuery = Qt__InputMethodQuery(0x100)
	Qt__ImPreferredLanguage      Qt__InputMethodQuery = Qt__InputMethodQuery(0x200)
	Qt__ImAbsolutePosition       Qt__InputMethodQuery = Qt__InputMethodQuery(0x400)
	Qt__ImTextBeforeCursor       Qt__InputMethodQuery = Qt__InputMethodQuery(0x800)
	Qt__ImTextAfterCursor        Qt__InputMethodQuery = Qt__InputMethodQuery(0x1000)
	Qt__ImEnterKeyType           Qt__InputMethodQuery = Qt__InputMethodQuery(0x2000)
	Qt__ImAnchorRectangle        Qt__InputMethodQuery = Qt__InputMethodQuery(0x4000)
	Qt__ImInputItemClipRectangle Qt__InputMethodQuery = Qt__InputMethodQuery(0x8000)
	Qt__ImPlatformData           Qt__InputMethodQuery = Qt__InputMethodQuery(0x80000000)
	Qt__ImQueryAll               Qt__InputMethodQuery = Qt__InputMethodQuery(0xffffffff)
)

//go:generate stringer -type=Qt__InputMethodHint
//Qt::InputMethodHint
type Qt__InputMethodHint int64

const (
	Qt__ImhNone                   Qt__InputMethodHint = Qt__InputMethodHint(0x0)
	Qt__ImhHiddenText             Qt__InputMethodHint = Qt__InputMethodHint(0x1)
	Qt__ImhSensitiveData          Qt__InputMethodHint = Qt__InputMethodHint(0x2)
	Qt__ImhNoAutoUppercase        Qt__InputMethodHint = Qt__InputMethodHint(0x4)
	Qt__ImhPreferNumbers          Qt__InputMethodHint = Qt__InputMethodHint(0x8)
	Qt__ImhPreferUppercase        Qt__InputMethodHint = Qt__InputMethodHint(0x10)
	Qt__ImhPreferLowercase        Qt__InputMethodHint = Qt__InputMethodHint(0x20)
	Qt__ImhNoPredictiveText       Qt__InputMethodHint = Qt__InputMethodHint(0x40)
	Qt__ImhDate                   Qt__InputMethodHint = Qt__InputMethodHint(0x80)
	Qt__ImhTime                   Qt__InputMethodHint = Qt__InputMethodHint(0x100)
	Qt__ImhPreferLatin            Qt__InputMethodHint = Qt__InputMethodHint(0x200)
	Qt__ImhMultiLine              Qt__InputMethodHint = Qt__InputMethodHint(0x400)
	Qt__ImhNoEditMenu             Qt__InputMethodHint = Qt__InputMethodHint(0x800)
	Qt__ImhNoTextHandles          Qt__InputMethodHint = Qt__InputMethodHint(0x1000)
	Qt__ImhDigitsOnly             Qt__InputMethodHint = Qt__InputMethodHint(0x10000)
	Qt__ImhFormattedNumbersOnly   Qt__InputMethodHint = Qt__InputMethodHint(0x20000)
	Qt__ImhUppercaseOnly          Qt__InputMethodHint = Qt__InputMethodHint(0x40000)
	Qt__ImhLowercaseOnly          Qt__InputMethodHint = Qt__InputMethodHint(0x80000)
	Qt__ImhDialableCharactersOnly Qt__InputMethodHint = Qt__InputMethodHint(0x100000)
	Qt__ImhEmailCharactersOnly    Qt__InputMethodHint = Qt__InputMethodHint(0x200000)
	Qt__ImhUrlCharactersOnly      Qt__InputMethodHint = Qt__InputMethodHint(0x400000)
	Qt__ImhLatinOnly              Qt__InputMethodHint = Qt__InputMethodHint(0x800000)
	Qt__ImhExclusiveInputMask     Qt__InputMethodHint = Qt__InputMethodHint(0xffff0000)
)

//go:generate stringer -type=Qt__EnterKeyType
//Qt::EnterKeyType
type Qt__EnterKeyType int64

const (
	Qt__EnterKeyDefault  Qt__EnterKeyType = Qt__EnterKeyType(0)
	Qt__EnterKeyReturn   Qt__EnterKeyType = Qt__EnterKeyType(1)
	Qt__EnterKeyDone     Qt__EnterKeyType = Qt__EnterKeyType(2)
	Qt__EnterKeyGo       Qt__EnterKeyType = Qt__EnterKeyType(3)
	Qt__EnterKeySend     Qt__EnterKeyType = Qt__EnterKeyType(4)
	Qt__EnterKeySearch   Qt__EnterKeyType = Qt__EnterKeyType(5)
	Qt__EnterKeyNext     Qt__EnterKeyType = Qt__EnterKeyType(6)
	Qt__EnterKeyPrevious Qt__EnterKeyType = Qt__EnterKeyType(7)
)

//go:generate stringer -type=Qt__ToolButtonStyle
//Qt::ToolButtonStyle
type Qt__ToolButtonStyle int64

var (
	Qt__ToolButtonIconOnly       Qt__ToolButtonStyle = Qt__ToolButtonStyle(0)
	Qt__ToolButtonTextOnly       Qt__ToolButtonStyle = Qt__ToolButtonStyle(1)
	Qt__ToolButtonTextBesideIcon Qt__ToolButtonStyle = Qt__ToolButtonStyle(2)
	Qt__ToolButtonTextUnderIcon  Qt__ToolButtonStyle = Qt__ToolButtonStyle(3)
	Qt__ToolButtonFollowStyle    Qt__ToolButtonStyle = Qt__ToolButtonStyle(4)
)

//go:generate stringer -type=Qt__LayoutDirection
//Qt::LayoutDirection
type Qt__LayoutDirection int64

const (
	Qt__LeftToRight         Qt__LayoutDirection = Qt__LayoutDirection(0)
	Qt__RightToLeft         Qt__LayoutDirection = Qt__LayoutDirection(1)
	Qt__LayoutDirectionAuto Qt__LayoutDirection = Qt__LayoutDirection(2)
)

//go:generate stringer -type=Qt__AnchorPoint
//Qt::AnchorPoint
type Qt__AnchorPoint int64

const (
	Qt__AnchorLeft             Qt__AnchorPoint = Qt__AnchorPoint(0)
	Qt__AnchorHorizontalCenter Qt__AnchorPoint = Qt__AnchorPoint(1)
	Qt__AnchorRight            Qt__AnchorPoint = Qt__AnchorPoint(2)
	Qt__AnchorTop              Qt__AnchorPoint = Qt__AnchorPoint(3)
	Qt__AnchorVerticalCenter   Qt__AnchorPoint = Qt__AnchorPoint(4)
	Qt__AnchorBottom           Qt__AnchorPoint = Qt__AnchorPoint(5)
)

//go:generate stringer -type=Qt__FindChildOption
//Qt::FindChildOption
type Qt__FindChildOption int64

const (
	Qt__FindDirectChildrenOnly  Qt__FindChildOption = Qt__FindChildOption(0x0)
	Qt__FindChildrenRecursively Qt__FindChildOption = Qt__FindChildOption(0x1)
)

//go:generate stringer -type=Qt__DropAction
//Qt::DropAction
type Qt__DropAction int64

const (
	Qt__CopyAction       Qt__DropAction = Qt__DropAction(0x1)
	Qt__MoveAction       Qt__DropAction = Qt__DropAction(0x2)
	Qt__LinkAction       Qt__DropAction = Qt__DropAction(0x4)
	Qt__ActionMask       Qt__DropAction = Qt__DropAction(0xff)
	Qt__TargetMoveAction Qt__DropAction = Qt__DropAction(0x8002)
	Qt__IgnoreAction     Qt__DropAction = Qt__DropAction(0x0)
)

//go:generate stringer -type=Qt__CheckState
//Qt::CheckState
type Qt__CheckState int64

const (
	Qt__Unchecked        Qt__CheckState = Qt__CheckState(0)
	Qt__PartiallyChecked Qt__CheckState = Qt__CheckState(1)
	Qt__Checked          Qt__CheckState = Qt__CheckState(2)
)

//go:generate stringer -type=Qt__ItemDataRole
//Qt::ItemDataRole
type Qt__ItemDataRole int64

const (
	Qt__DisplayRole               Qt__ItemDataRole = Qt__ItemDataRole(0)
	Qt__DecorationRole            Qt__ItemDataRole = Qt__ItemDataRole(1)
	Qt__EditRole                  Qt__ItemDataRole = Qt__ItemDataRole(2)
	Qt__ToolTipRole               Qt__ItemDataRole = Qt__ItemDataRole(3)
	Qt__StatusTipRole             Qt__ItemDataRole = Qt__ItemDataRole(4)
	Qt__WhatsThisRole             Qt__ItemDataRole = Qt__ItemDataRole(5)
	Qt__FontRole                  Qt__ItemDataRole = Qt__ItemDataRole(6)
	Qt__TextAlignmentRole         Qt__ItemDataRole = Qt__ItemDataRole(7)
	Qt__BackgroundRole            Qt__ItemDataRole = Qt__ItemDataRole(8)
	Qt__ForegroundRole            Qt__ItemDataRole = Qt__ItemDataRole(9)
	Qt__BackgroundColorRole       Qt__ItemDataRole = Qt__ItemDataRole(Qt__BackgroundRole)
	Qt__TextColorRole             Qt__ItemDataRole = Qt__ItemDataRole(Qt__ForegroundRole)
	Qt__CheckStateRole            Qt__ItemDataRole = Qt__ItemDataRole(10)
	Qt__AccessibleTextRole        Qt__ItemDataRole = Qt__ItemDataRole(11)
	Qt__AccessibleDescriptionRole Qt__ItemDataRole = Qt__ItemDataRole(12)
	Qt__SizeHintRole              Qt__ItemDataRole = Qt__ItemDataRole(13)
	Qt__InitialSortOrderRole      Qt__ItemDataRole = Qt__ItemDataRole(14)
	Qt__DisplayPropertyRole       Qt__ItemDataRole = Qt__ItemDataRole(27)
	Qt__DecorationPropertyRole    Qt__ItemDataRole = Qt__ItemDataRole(28)
	Qt__ToolTipPropertyRole       Qt__ItemDataRole = Qt__ItemDataRole(29)
	Qt__StatusTipPropertyRole     Qt__ItemDataRole = Qt__ItemDataRole(30)
	Qt__WhatsThisPropertyRole     Qt__ItemDataRole = Qt__ItemDataRole(31)
	Qt__UserRole                  Qt__ItemDataRole = Qt__ItemDataRole(0x0100)
)

//go:generate stringer -type=Qt__ItemFlag
//Qt::ItemFlag
type Qt__ItemFlag int64

const (
	Qt__NoItemFlags          Qt__ItemFlag = Qt__ItemFlag(0)
	Qt__ItemIsSelectable     Qt__ItemFlag = Qt__ItemFlag(1)
	Qt__ItemIsEditable       Qt__ItemFlag = Qt__ItemFlag(2)
	Qt__ItemIsDragEnabled    Qt__ItemFlag = Qt__ItemFlag(4)
	Qt__ItemIsDropEnabled    Qt__ItemFlag = Qt__ItemFlag(8)
	Qt__ItemIsUserCheckable  Qt__ItemFlag = Qt__ItemFlag(16)
	Qt__ItemIsEnabled        Qt__ItemFlag = Qt__ItemFlag(32)
	Qt__ItemIsAutoTristate   Qt__ItemFlag = Qt__ItemFlag(64)
	Qt__ItemIsTristate       Qt__ItemFlag = Qt__ItemFlag(Qt__ItemIsAutoTristate)
	Qt__ItemNeverHasChildren Qt__ItemFlag = Qt__ItemFlag(128)
	Qt__ItemIsUserTristate   Qt__ItemFlag = Qt__ItemFlag(256)
)

//go:generate stringer -type=Qt__MatchFlag
//Qt::MatchFlag
type Qt__MatchFlag int64

const (
	Qt__MatchExactly       Qt__MatchFlag = Qt__MatchFlag(0)
	Qt__MatchContains      Qt__MatchFlag = Qt__MatchFlag(1)
	Qt__MatchStartsWith    Qt__MatchFlag = Qt__MatchFlag(2)
	Qt__MatchEndsWith      Qt__MatchFlag = Qt__MatchFlag(3)
	Qt__MatchRegExp        Qt__MatchFlag = Qt__MatchFlag(4)
	Qt__MatchWildcard      Qt__MatchFlag = Qt__MatchFlag(5)
	Qt__MatchFixedString   Qt__MatchFlag = Qt__MatchFlag(8)
	Qt__MatchCaseSensitive Qt__MatchFlag = Qt__MatchFlag(16)
	Qt__MatchWrap          Qt__MatchFlag = Qt__MatchFlag(32)
	Qt__MatchRecursive     Qt__MatchFlag = Qt__MatchFlag(64)
)

//go:generate stringer -type=Qt__WindowModality
//Qt::WindowModality
type Qt__WindowModality int64

const (
	Qt__NonModal         Qt__WindowModality = Qt__WindowModality(0)
	Qt__WindowModal      Qt__WindowModality = Qt__WindowModality(1)
	Qt__ApplicationModal Qt__WindowModality = Qt__WindowModality(2)
)

//go:generate stringer -type=Qt__TextInteractionFlag
//Qt::TextInteractionFlag
type Qt__TextInteractionFlag int64

const (
	Qt__NoTextInteraction         Qt__TextInteractionFlag = Qt__TextInteractionFlag(0)
	Qt__TextSelectableByMouse     Qt__TextInteractionFlag = Qt__TextInteractionFlag(1)
	Qt__TextSelectableByKeyboard  Qt__TextInteractionFlag = Qt__TextInteractionFlag(2)
	Qt__LinksAccessibleByMouse    Qt__TextInteractionFlag = Qt__TextInteractionFlag(4)
	Qt__LinksAccessibleByKeyboard Qt__TextInteractionFlag = Qt__TextInteractionFlag(8)
	Qt__TextEditable              Qt__TextInteractionFlag = Qt__TextInteractionFlag(16)
	Qt__TextEditorInteraction     Qt__TextInteractionFlag = Qt__TextInteractionFlag(Qt__TextSelectableByMouse | Qt__TextSelectableByKeyboard | Qt__TextEditable)
	Qt__TextBrowserInteraction    Qt__TextInteractionFlag = Qt__TextInteractionFlag(Qt__TextSelectableByMouse | Qt__LinksAccessibleByMouse | Qt__LinksAccessibleByKeyboard)
)

//go:generate stringer -type=Qt__EventPriority
//Qt::EventPriority
type Qt__EventPriority int64

const (
	Qt__HighEventPriority   Qt__EventPriority = Qt__EventPriority(1)
	Qt__NormalEventPriority Qt__EventPriority = Qt__EventPriority(0)
	Qt__LowEventPriority    Qt__EventPriority = Qt__EventPriority(-1)
)

//go:generate stringer -type=Qt__SizeHint
//Qt::SizeHint
type Qt__SizeHint int64

const (
	Qt__MinimumSize    Qt__SizeHint = Qt__SizeHint(0)
	Qt__PreferredSize  Qt__SizeHint = Qt__SizeHint(1)
	Qt__MaximumSize    Qt__SizeHint = Qt__SizeHint(2)
	Qt__MinimumDescent Qt__SizeHint = Qt__SizeHint(3)
	Qt__NSizeHints     Qt__SizeHint = Qt__SizeHint(4)
)

//go:generate stringer -type=Qt__WindowFrameSection
//Qt::WindowFrameSection
type Qt__WindowFrameSection int64

const (
	Qt__NoSection          Qt__WindowFrameSection = Qt__WindowFrameSection(0)
	Qt__LeftSection        Qt__WindowFrameSection = Qt__WindowFrameSection(1)
	Qt__TopLeftSection     Qt__WindowFrameSection = Qt__WindowFrameSection(2)
	Qt__TopSection         Qt__WindowFrameSection = Qt__WindowFrameSection(3)
	Qt__TopRightSection    Qt__WindowFrameSection = Qt__WindowFrameSection(4)
	Qt__RightSection       Qt__WindowFrameSection = Qt__WindowFrameSection(5)
	Qt__BottomRightSection Qt__WindowFrameSection = Qt__WindowFrameSection(6)
	Qt__BottomSection      Qt__WindowFrameSection = Qt__WindowFrameSection(7)
	Qt__BottomLeftSection  Qt__WindowFrameSection = Qt__WindowFrameSection(8)
	Qt__TitleBarArea       Qt__WindowFrameSection = Qt__WindowFrameSection(9)
)

//go:generate stringer -type=Qt__CoordinateSystem
//Qt::CoordinateSystem
type Qt__CoordinateSystem int64

const (
	Qt__DeviceCoordinates  Qt__CoordinateSystem = Qt__CoordinateSystem(0)
	Qt__LogicalCoordinates Qt__CoordinateSystem = Qt__CoordinateSystem(1)
)

//go:generate stringer -type=Qt__TouchPointState
//Qt::TouchPointState
type Qt__TouchPointState int64

const (
	Qt__TouchPointPressed    Qt__TouchPointState = Qt__TouchPointState(0x01)
	Qt__TouchPointMoved      Qt__TouchPointState = Qt__TouchPointState(0x02)
	Qt__TouchPointStationary Qt__TouchPointState = Qt__TouchPointState(0x04)
	Qt__TouchPointReleased   Qt__TouchPointState = Qt__TouchPointState(0x08)
)

//go:generate stringer -type=Qt__GestureState
//Qt::GestureState
type Qt__GestureState int64

const (
	Qt__NoGesture       Qt__GestureState = Qt__GestureState(0)
	Qt__GestureStarted  Qt__GestureState = Qt__GestureState(1)
	Qt__GestureUpdated  Qt__GestureState = Qt__GestureState(2)
	Qt__GestureFinished Qt__GestureState = Qt__GestureState(3)
	Qt__GestureCanceled Qt__GestureState = Qt__GestureState(4)
)

//go:generate stringer -type=Qt__GestureType
//Qt::GestureType
type Qt__GestureType int64

var (
	Qt__TapGesture        Qt__GestureType = Qt__GestureType(1)
	Qt__TapAndHoldGesture Qt__GestureType = Qt__GestureType(2)
	Qt__PanGesture        Qt__GestureType = Qt__GestureType(3)
	Qt__PinchGesture      Qt__GestureType = Qt__GestureType(4)
	Qt__SwipeGesture      Qt__GestureType = Qt__GestureType(5)
	Qt__CustomGesture     Qt__GestureType = Qt__GestureType(0x0100)
	Qt__LastGestureType   Qt__GestureType = Qt__GestureType(C.Qt_LastGestureType_Type())
)

//go:generate stringer -type=Qt__GestureFlag
//Qt::GestureFlag
type Qt__GestureFlag int64

const (
	Qt__DontStartGestureOnChildren       Qt__GestureFlag = Qt__GestureFlag(0x01)
	Qt__ReceivePartialGestures           Qt__GestureFlag = Qt__GestureFlag(0x02)
	Qt__IgnoredGesturesPropagateToParent Qt__GestureFlag = Qt__GestureFlag(0x04)
)

//go:generate stringer -type=Qt__NativeGestureType
//Qt::NativeGestureType
type Qt__NativeGestureType int64

const (
	Qt__BeginNativeGesture     Qt__NativeGestureType = Qt__NativeGestureType(0)
	Qt__EndNativeGesture       Qt__NativeGestureType = Qt__NativeGestureType(1)
	Qt__PanNativeGesture       Qt__NativeGestureType = Qt__NativeGestureType(2)
	Qt__ZoomNativeGesture      Qt__NativeGestureType = Qt__NativeGestureType(3)
	Qt__SmartZoomNativeGesture Qt__NativeGestureType = Qt__NativeGestureType(4)
	Qt__RotateNativeGesture    Qt__NativeGestureType = Qt__NativeGestureType(5)
	Qt__SwipeNativeGesture     Qt__NativeGestureType = Qt__NativeGestureType(6)
)

//go:generate stringer -type=Qt__NavigationMode
//Qt::NavigationMode
type Qt__NavigationMode int64

const (
	Qt__NavigationModeNone               Qt__NavigationMode = Qt__NavigationMode(0)
	Qt__NavigationModeKeypadTabOrder     Qt__NavigationMode = Qt__NavigationMode(1)
	Qt__NavigationModeKeypadDirectional  Qt__NavigationMode = Qt__NavigationMode(2)
	Qt__NavigationModeCursorAuto         Qt__NavigationMode = Qt__NavigationMode(3)
	Qt__NavigationModeCursorForceVisible Qt__NavigationMode = Qt__NavigationMode(4)
)

//go:generate stringer -type=Qt__CursorMoveStyle
//Qt::CursorMoveStyle
type Qt__CursorMoveStyle int64

var (
	Qt__LogicalMoveStyle Qt__CursorMoveStyle = Qt__CursorMoveStyle(0)
	Qt__VisualMoveStyle  Qt__CursorMoveStyle = Qt__CursorMoveStyle(1)
)

//go:generate stringer -type=Qt__TimerType
//Qt::TimerType
type Qt__TimerType int64

const (
	Qt__PreciseTimer    Qt__TimerType = Qt__TimerType(0)
	Qt__CoarseTimer     Qt__TimerType = Qt__TimerType(1)
	Qt__VeryCoarseTimer Qt__TimerType = Qt__TimerType(2)
)

//go:generate stringer -type=Qt__ScrollPhase
//Qt::ScrollPhase
type Qt__ScrollPhase int64

const (
	Qt__NoScrollPhase  Qt__ScrollPhase = Qt__ScrollPhase(0)
	Qt__ScrollBegin    Qt__ScrollPhase = Qt__ScrollPhase(1)
	Qt__ScrollUpdate   Qt__ScrollPhase = Qt__ScrollPhase(2)
	Qt__ScrollEnd      Qt__ScrollPhase = Qt__ScrollPhase(3)
	Qt__ScrollMomentum Qt__ScrollPhase = Qt__ScrollPhase(4)
)

//go:generate stringer -type=Qt__MouseEventSource
//Qt::MouseEventSource
type Qt__MouseEventSource int64

const (
	Qt__MouseEventNotSynthesized           Qt__MouseEventSource = Qt__MouseEventSource(0)
	Qt__MouseEventSynthesizedBySystem      Qt__MouseEventSource = Qt__MouseEventSource(1)
	Qt__MouseEventSynthesizedByQt          Qt__MouseEventSource = Qt__MouseEventSource(2)
	Qt__MouseEventSynthesizedByApplication Qt__MouseEventSource = Qt__MouseEventSource(3)
)

//go:generate stringer -type=Qt__MouseEventFlag
//Qt::MouseEventFlag
type Qt__MouseEventFlag int64

const (
	Qt__MouseEventCreatedDoubleClick Qt__MouseEventFlag = Qt__MouseEventFlag(0x01)
	Qt__MouseEventFlagMask           Qt__MouseEventFlag = Qt__MouseEventFlag(0xFF)
)

//go:generate stringer -type=Qt__ChecksumType
//Qt::ChecksumType
type Qt__ChecksumType int64

const (
	Qt__ChecksumIso3309 Qt__ChecksumType = Qt__ChecksumType(0)
	Qt__ChecksumItuV41  Qt__ChecksumType = Qt__ChecksumType(1)
)

func Qt_ConvertFromPlainText(plain string, mode Qt__WhiteSpaceMode) string {
	var plainC *C.char
	if plain != "" {
		plainC = C.CString(plain)
		defer C.free(unsafe.Pointer(plainC))
	}
	return cGoUnpackString(C.Qt_Qt_ConvertFromPlainText(C.struct_QtCore_PackedString{data: plainC, len: C.longlong(len(plain))}, C.longlong(mode)))
}

func (ptr *Qt) ConvertFromPlainText(plain string, mode Qt__WhiteSpaceMode) string {
	var plainC *C.char
	if plain != "" {
		plainC = C.CString(plain)
		defer C.free(unsafe.Pointer(plainC))
	}
	return cGoUnpackString(C.Qt_Qt_ConvertFromPlainText(C.struct_QtCore_PackedString{data: plainC, len: C.longlong(len(plain))}, C.longlong(mode)))
}

func Qt_MightBeRichText(text string) bool {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return int8(C.Qt_Qt_MightBeRichText(C.struct_QtCore_PackedString{data: textC, len: C.longlong(len(text))})) != 0
}

func (ptr *Qt) MightBeRichText(text string) bool {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return int8(C.Qt_Qt_MightBeRichText(C.struct_QtCore_PackedString{data: textC, len: C.longlong(len(text))})) != 0
}

type QtGlobal struct {
	ptr unsafe.Pointer
}

type QtGlobal_ITF interface {
	QtGlobal_PTR() *QtGlobal
}

func (ptr *QtGlobal) QtGlobal_PTR() *QtGlobal {
	return ptr
}

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

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

func PointerFromQtGlobal(ptr QtGlobal_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QtGlobal_PTR().Pointer()
	}
	return nil
}

func NewQtGlobalFromPointer(ptr unsafe.Pointer) (n *QtGlobal) {
	n = new(QtGlobal)
	n.SetPointer(ptr)
	return
}

func (ptr *QtGlobal) DestroyQtGlobal() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func QtGlobal_qEnvironmentVariable(varName string) string {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return cGoUnpackString(C.QtGlobal_QtGlobal_qEnvironmentVariable(varNameC))
}

func (ptr *QtGlobal) qEnvironmentVariable(varName string) string {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return cGoUnpackString(C.QtGlobal_QtGlobal_qEnvironmentVariable(varNameC))
}

func QtGlobal_qEnvironmentVariable2(varName string, defaultValue string) string {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	var defaultValueC *C.char
	if defaultValue != "" {
		defaultValueC = C.CString(defaultValue)
		defer C.free(unsafe.Pointer(defaultValueC))
	}
	return cGoUnpackString(C.QtGlobal_QtGlobal_qEnvironmentVariable2(varNameC, C.struct_QtCore_PackedString{data: defaultValueC, len: C.longlong(len(defaultValue))}))
}

func (ptr *QtGlobal) qEnvironmentVariable2(varName string, defaultValue string) string {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	var defaultValueC *C.char
	if defaultValue != "" {
		defaultValueC = C.CString(defaultValue)
		defer C.free(unsafe.Pointer(defaultValueC))
	}
	return cGoUnpackString(C.QtGlobal_QtGlobal_qEnvironmentVariable2(varNameC, C.struct_QtCore_PackedString{data: defaultValueC, len: C.longlong(len(defaultValue))}))
}

func QtGlobal_qEnvironmentVariableIntValue(varName string, ok *bool) int {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return int(int32(C.QtGlobal_QtGlobal_qEnvironmentVariableIntValue(varNameC, &okC)))
}

func (ptr *QtGlobal) qEnvironmentVariableIntValue(varName string, ok *bool) int {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return int(int32(C.QtGlobal_QtGlobal_qEnvironmentVariableIntValue(varNameC, &okC)))
}

func QtGlobal_qEnvironmentVariableIsEmpty(varName string) bool {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return int8(C.QtGlobal_QtGlobal_qEnvironmentVariableIsEmpty(varNameC)) != 0
}

func (ptr *QtGlobal) qEnvironmentVariableIsEmpty(varName string) bool {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return int8(C.QtGlobal_QtGlobal_qEnvironmentVariableIsEmpty(varNameC)) != 0
}

func QtGlobal_qEnvironmentVariableIsSet(varName string) bool {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return int8(C.QtGlobal_QtGlobal_qEnvironmentVariableIsSet(varNameC)) != 0
}

func (ptr *QtGlobal) qEnvironmentVariableIsSet(varName string) bool {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return int8(C.QtGlobal_QtGlobal_qEnvironmentVariableIsSet(varNameC)) != 0
}

func QtGlobal_qVersion() string {
	return cGoUnpackString(C.QtGlobal_QtGlobal_qVersion())
}

func (ptr *QtGlobal) qVersion() string {
	return cGoUnpackString(C.QtGlobal_QtGlobal_qVersion())
}

func QtGlobal_qgetenv(varName string) *QByteArray {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QtGlobal_QtGlobal_qgetenv(varNameC))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func (ptr *QtGlobal) qgetenv(varName string) *QByteArray {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	tmpValue := NewQByteArrayFromPointer(C.QtGlobal_QtGlobal_qgetenv(varNameC))
	runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
	return tmpValue
}

func QtGlobal_qputenv(varName string, value QByteArray_ITF) bool {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return int8(C.QtGlobal_QtGlobal_qputenv(varNameC, PointerFromQByteArray(value))) != 0
}

func (ptr *QtGlobal) qputenv(varName string, value QByteArray_ITF) bool {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return int8(C.QtGlobal_QtGlobal_qputenv(varNameC, PointerFromQByteArray(value))) != 0
}

func QtGlobal_qunsetenv(varName string) bool {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return int8(C.QtGlobal_QtGlobal_qunsetenv(varNameC)) != 0
}

func (ptr *QtGlobal) qunsetenv(varName string) bool {
	var varNameC *C.char
	if varName != "" {
		varNameC = C.CString(varName)
		defer C.free(unsafe.Pointer(varNameC))
	}
	return int8(C.QtGlobal_QtGlobal_qunsetenv(varNameC)) != 0
}

type qfloat16 struct {
	ptr unsafe.Pointer
}

type qfloat16_ITF interface {
	qfloat16_PTR() *qfloat16
}

func (ptr *qfloat16) qfloat16_PTR() *qfloat16 {
	return ptr
}

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

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

func PointerFromQfloat16(ptr qfloat16_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.qfloat16_PTR().Pointer()
	}
	return nil
}

func NewQfloat16FromPointer(ptr unsafe.Pointer) (n *qfloat16) {
	n = new(qfloat16)
	n.SetPointer(ptr)
	return
}

func (ptr *qfloat16) Destroyqfloat16() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}