cutego/core/core.go

package core

//#include "core.h"
import "C"
import (
	"github.com/therecipe/qt"
	"strings"
	"unsafe"
)

type QAbstractAnimation struct {
	QObject
}

type QAbstractAnimation_ITF interface {
	QObject_ITF
	QAbstractAnimation_PTR() *QAbstractAnimation
}

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

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

func newQAbstractAnimationFromPointer(ptr unsafe.Pointer) *QAbstractAnimation {
	var n = NewQAbstractAnimationFromPointer(ptr)
	for len(n.ObjectName()) < len("QAbstractAnimation_") {
		n.SetObjectName("QAbstractAnimation_" + qt.Identifier())
	}
	return n
}

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

//QAbstractAnimation::DeletionPolicy
type QAbstractAnimation__DeletionPolicy int64

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

//QAbstractAnimation::Direction
type QAbstractAnimation__Direction int64

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

//QAbstractAnimation::State
type QAbstractAnimation__State int64

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

func (ptr *QAbstractAnimation) CurrentLoop() int {
	defer qt.Recovering("QAbstractAnimation::currentLoop")

	if ptr.Pointer() != nil {
		return int(C.QAbstractAnimation_CurrentLoop(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractAnimation) CurrentTime() int {
	defer qt.Recovering("QAbstractAnimation::currentTime")

	if ptr.Pointer() != nil {
		return int(C.QAbstractAnimation_CurrentTime(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractAnimation) Direction() QAbstractAnimation__Direction {
	defer qt.Recovering("QAbstractAnimation::direction")

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

func (ptr *QAbstractAnimation) LoopCount() int {
	defer qt.Recovering("QAbstractAnimation::loopCount")

	if ptr.Pointer() != nil {
		return int(C.QAbstractAnimation_LoopCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractAnimation) SetCurrentTime(msecs int) {
	defer qt.Recovering("QAbstractAnimation::setCurrentTime")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetCurrentTime(ptr.Pointer(), C.int(msecs))
	}
}

func (ptr *QAbstractAnimation) SetDirection(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QAbstractAnimation::setDirection")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QAbstractAnimation) SetLoopCount(loopCount int) {
	defer qt.Recovering("QAbstractAnimation::setLoopCount")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetLoopCount(ptr.Pointer(), C.int(loopCount))
	}
}

func (ptr *QAbstractAnimation) State() QAbstractAnimation__State {
	defer qt.Recovering("QAbstractAnimation::state")

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

func (ptr *QAbstractAnimation) ConnectCurrentLoopChanged(f func(currentLoop int)) {
	defer qt.Recovering("connect QAbstractAnimation::currentLoopChanged")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_ConnectCurrentLoopChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "currentLoopChanged", f)
	}
}

func (ptr *QAbstractAnimation) DisconnectCurrentLoopChanged() {
	defer qt.Recovering("disconnect QAbstractAnimation::currentLoopChanged")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DisconnectCurrentLoopChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "currentLoopChanged")
	}
}

//export callbackQAbstractAnimationCurrentLoopChanged
func callbackQAbstractAnimationCurrentLoopChanged(ptr unsafe.Pointer, ptrName *C.char, currentLoop C.int) {
	defer qt.Recovering("callback QAbstractAnimation::currentLoopChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "currentLoopChanged"); signal != nil {
		signal.(func(int))(int(currentLoop))
	}

}

func (ptr *QAbstractAnimation) CurrentLoopChanged(currentLoop int) {
	defer qt.Recovering("QAbstractAnimation::currentLoopChanged")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_CurrentLoopChanged(ptr.Pointer(), C.int(currentLoop))
	}
}

func (ptr *QAbstractAnimation) CurrentLoopTime() int {
	defer qt.Recovering("QAbstractAnimation::currentLoopTime")

	if ptr.Pointer() != nil {
		return int(C.QAbstractAnimation_CurrentLoopTime(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractAnimation) ConnectDirectionChanged(f func(newDirection QAbstractAnimation__Direction)) {
	defer qt.Recovering("connect QAbstractAnimation::directionChanged")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_ConnectDirectionChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "directionChanged", f)
	}
}

func (ptr *QAbstractAnimation) DisconnectDirectionChanged() {
	defer qt.Recovering("disconnect QAbstractAnimation::directionChanged")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DisconnectDirectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "directionChanged")
	}
}

//export callbackQAbstractAnimationDirectionChanged
func callbackQAbstractAnimationDirectionChanged(ptr unsafe.Pointer, ptrName *C.char, newDirection C.int) {
	defer qt.Recovering("callback QAbstractAnimation::directionChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "directionChanged"); signal != nil {
		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(newDirection))
	}

}

func (ptr *QAbstractAnimation) DirectionChanged(newDirection QAbstractAnimation__Direction) {
	defer qt.Recovering("QAbstractAnimation::directionChanged")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DirectionChanged(ptr.Pointer(), C.int(newDirection))
	}
}

func (ptr *QAbstractAnimation) Duration() int {
	defer qt.Recovering("QAbstractAnimation::duration")

	if ptr.Pointer() != nil {
		return int(C.QAbstractAnimation_Duration(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractAnimation) Event(event QEvent_ITF) bool {
	defer qt.Recovering("QAbstractAnimation::event")

	if ptr.Pointer() != nil {
		return C.QAbstractAnimation_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QAbstractAnimation) ConnectFinished(f func()) {
	defer qt.Recovering("connect QAbstractAnimation::finished")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_ConnectFinished(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "finished", f)
	}
}

func (ptr *QAbstractAnimation) DisconnectFinished() {
	defer qt.Recovering("disconnect QAbstractAnimation::finished")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "finished")
	}
}

//export callbackQAbstractAnimationFinished
func callbackQAbstractAnimationFinished(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractAnimation::finished")

	if signal := qt.GetSignal(C.GoString(ptrName), "finished"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractAnimation) Finished() {
	defer qt.Recovering("QAbstractAnimation::finished")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Finished(ptr.Pointer())
	}
}

func (ptr *QAbstractAnimation) Group() *QAnimationGroup {
	defer qt.Recovering("QAbstractAnimation::group")

	if ptr.Pointer() != nil {
		return NewQAnimationGroupFromPointer(C.QAbstractAnimation_Group(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAbstractAnimation) Pause() {
	defer qt.Recovering("QAbstractAnimation::pause")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Pause(ptr.Pointer())
	}
}

func (ptr *QAbstractAnimation) Resume() {
	defer qt.Recovering("QAbstractAnimation::resume")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Resume(ptr.Pointer())
	}
}

func (ptr *QAbstractAnimation) SetPaused(paused bool) {
	defer qt.Recovering("QAbstractAnimation::setPaused")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
	}
}

func (ptr *QAbstractAnimation) Start(policy QAbstractAnimation__DeletionPolicy) {
	defer qt.Recovering("QAbstractAnimation::start")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Start(ptr.Pointer(), C.int(policy))
	}
}

func (ptr *QAbstractAnimation) ConnectStateChanged(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
	defer qt.Recovering("connect QAbstractAnimation::stateChanged")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_ConnectStateChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "stateChanged", f)
	}
}

func (ptr *QAbstractAnimation) DisconnectStateChanged() {
	defer qt.Recovering("disconnect QAbstractAnimation::stateChanged")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DisconnectStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "stateChanged")
	}
}

//export callbackQAbstractAnimationStateChanged
func callbackQAbstractAnimationStateChanged(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
	defer qt.Recovering("callback QAbstractAnimation::stateChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "stateChanged"); signal != nil {
		signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	}

}

func (ptr *QAbstractAnimation) StateChanged(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QAbstractAnimation::stateChanged")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_StateChanged(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QAbstractAnimation) Stop() {
	defer qt.Recovering("QAbstractAnimation::stop")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_Stop(ptr.Pointer())
	}
}

func (ptr *QAbstractAnimation) TotalDuration() int {
	defer qt.Recovering("QAbstractAnimation::totalDuration")

	if ptr.Pointer() != nil {
		return int(C.QAbstractAnimation_TotalDuration(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
	defer qt.Recovering("connect QAbstractAnimation::updateDirection")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
	}
}

func (ptr *QAbstractAnimation) DisconnectUpdateDirection() {
	defer qt.Recovering("disconnect QAbstractAnimation::updateDirection")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractAnimationUpdateDirection
func callbackQAbstractAnimationUpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
	defer qt.Recovering("callback QAbstractAnimation::updateDirection")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
	} else {
		NewQAbstractAnimationFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
	}
}

func (ptr *QAbstractAnimation) UpdateDirection(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QAbstractAnimation::updateDirection")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_UpdateDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QAbstractAnimation) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QAbstractAnimation::updateDirection")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QAbstractAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
	defer qt.Recovering("connect QAbstractAnimation::updateState")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
	}
}

func (ptr *QAbstractAnimation) DisconnectUpdateState() {
	defer qt.Recovering("disconnect QAbstractAnimation::updateState")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractAnimationUpdateState
func callbackQAbstractAnimationUpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
	defer qt.Recovering("callback QAbstractAnimation::updateState")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
		signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	} else {
		NewQAbstractAnimationFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	}
}

func (ptr *QAbstractAnimation) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QAbstractAnimation::updateState")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QAbstractAnimation) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QAbstractAnimation::updateState")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QAbstractAnimation) DestroyQAbstractAnimation() {
	defer qt.Recovering("QAbstractAnimation::~QAbstractAnimation")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_DestroyQAbstractAnimation(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QAbstractAnimation::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QAbstractAnimation) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QAbstractAnimation::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQAbstractAnimationTimerEvent
func callbackQAbstractAnimationTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractAnimation::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQAbstractAnimationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QAbstractAnimation) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractAnimation::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractAnimation) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractAnimation::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QAbstractAnimation::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QAbstractAnimation) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QAbstractAnimation::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQAbstractAnimationChildEvent
func callbackQAbstractAnimationChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractAnimation::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQAbstractAnimationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QAbstractAnimation) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractAnimation::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractAnimation) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractAnimation::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractAnimation) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QAbstractAnimation::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QAbstractAnimation) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QAbstractAnimation::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQAbstractAnimationCustomEvent
func callbackQAbstractAnimationCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractAnimation::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQAbstractAnimationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QAbstractAnimation) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QAbstractAnimation::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractAnimation) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QAbstractAnimation::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractAnimation_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QAbstractEventDispatcher struct {
	QObject
}

type QAbstractEventDispatcher_ITF interface {
	QObject_ITF
	QAbstractEventDispatcher_PTR() *QAbstractEventDispatcher
}

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

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

func newQAbstractEventDispatcherFromPointer(ptr unsafe.Pointer) *QAbstractEventDispatcher {
	var n = NewQAbstractEventDispatcherFromPointer(ptr)
	for len(n.ObjectName()) < len("QAbstractEventDispatcher_") {
		n.SetObjectName("QAbstractEventDispatcher_" + qt.Identifier())
	}
	return n
}

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

func (ptr *QAbstractEventDispatcher) ConnectAboutToBlock(f func()) {
	defer qt.Recovering("connect QAbstractEventDispatcher::aboutToBlock")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_ConnectAboutToBlock(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "aboutToBlock", f)
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectAboutToBlock() {
	defer qt.Recovering("disconnect QAbstractEventDispatcher::aboutToBlock")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_DisconnectAboutToBlock(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "aboutToBlock")
	}
}

//export callbackQAbstractEventDispatcherAboutToBlock
func callbackQAbstractEventDispatcherAboutToBlock(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractEventDispatcher::aboutToBlock")

	if signal := qt.GetSignal(C.GoString(ptrName), "aboutToBlock"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractEventDispatcher) AboutToBlock() {
	defer qt.Recovering("QAbstractEventDispatcher::aboutToBlock")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_AboutToBlock(ptr.Pointer())
	}
}

func (ptr *QAbstractEventDispatcher) ConnectAwake(f func()) {
	defer qt.Recovering("connect QAbstractEventDispatcher::awake")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_ConnectAwake(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "awake", f)
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectAwake() {
	defer qt.Recovering("disconnect QAbstractEventDispatcher::awake")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_DisconnectAwake(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "awake")
	}
}

//export callbackQAbstractEventDispatcherAwake
func callbackQAbstractEventDispatcherAwake(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractEventDispatcher::awake")

	if signal := qt.GetSignal(C.GoString(ptrName), "awake"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractEventDispatcher) Awake() {
	defer qt.Recovering("QAbstractEventDispatcher::awake")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_Awake(ptr.Pointer())
	}
}

func (ptr *QAbstractEventDispatcher) Flush() {
	defer qt.Recovering("QAbstractEventDispatcher::flush")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_Flush(ptr.Pointer())
	}
}

func (ptr *QAbstractEventDispatcher) InstallNativeEventFilter(filterObj QAbstractNativeEventFilter_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::installNativeEventFilter")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_InstallNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filterObj))
	}
}

func QAbstractEventDispatcher_Instance(thread QThread_ITF) *QAbstractEventDispatcher {
	defer qt.Recovering("QAbstractEventDispatcher::instance")

	return NewQAbstractEventDispatcherFromPointer(C.QAbstractEventDispatcher_QAbstractEventDispatcher_Instance(PointerFromQThread(thread)))
}

func (ptr *QAbstractEventDispatcher) Interrupt() {
	defer qt.Recovering("QAbstractEventDispatcher::interrupt")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_Interrupt(ptr.Pointer())
	}
}

func (ptr *QAbstractEventDispatcher) ProcessEvents(flags QEventLoop__ProcessEventsFlag) bool {
	defer qt.Recovering("QAbstractEventDispatcher::processEvents")

	if ptr.Pointer() != nil {
		return C.QAbstractEventDispatcher_ProcessEvents(ptr.Pointer(), C.int(flags)) != 0
	}
	return false
}

func (ptr *QAbstractEventDispatcher) RegisterSocketNotifier(notifier QSocketNotifier_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::registerSocketNotifier")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_RegisterSocketNotifier(ptr.Pointer(), PointerFromQSocketNotifier(notifier))
	}
}

func (ptr *QAbstractEventDispatcher) RemainingTime(timerId int) int {
	defer qt.Recovering("QAbstractEventDispatcher::remainingTime")

	if ptr.Pointer() != nil {
		return int(C.QAbstractEventDispatcher_RemainingTime(ptr.Pointer(), C.int(timerId)))
	}
	return 0
}

func (ptr *QAbstractEventDispatcher) RemoveNativeEventFilter(filter QAbstractNativeEventFilter_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::removeNativeEventFilter")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_RemoveNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filter))
	}
}

func (ptr *QAbstractEventDispatcher) UnregisterSocketNotifier(notifier QSocketNotifier_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::unregisterSocketNotifier")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_UnregisterSocketNotifier(ptr.Pointer(), PointerFromQSocketNotifier(notifier))
	}
}

func (ptr *QAbstractEventDispatcher) UnregisterTimer(timerId int) bool {
	defer qt.Recovering("QAbstractEventDispatcher::unregisterTimer")

	if ptr.Pointer() != nil {
		return C.QAbstractEventDispatcher_UnregisterTimer(ptr.Pointer(), C.int(timerId)) != 0
	}
	return false
}

func (ptr *QAbstractEventDispatcher) UnregisterTimers(object QObject_ITF) bool {
	defer qt.Recovering("QAbstractEventDispatcher::unregisterTimers")

	if ptr.Pointer() != nil {
		return C.QAbstractEventDispatcher_UnregisterTimers(ptr.Pointer(), PointerFromQObject(object)) != 0
	}
	return false
}

func (ptr *QAbstractEventDispatcher) WakeUp() {
	defer qt.Recovering("QAbstractEventDispatcher::wakeUp")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_WakeUp(ptr.Pointer())
	}
}

func (ptr *QAbstractEventDispatcher) DestroyQAbstractEventDispatcher() {
	defer qt.Recovering("QAbstractEventDispatcher::~QAbstractEventDispatcher")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_DestroyQAbstractEventDispatcher(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractEventDispatcher) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QAbstractEventDispatcher::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QAbstractEventDispatcher::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQAbstractEventDispatcherTimerEvent
func callbackQAbstractEventDispatcherTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractEventDispatcher::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQAbstractEventDispatcherFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QAbstractEventDispatcher) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractEventDispatcher) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractEventDispatcher) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QAbstractEventDispatcher::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QAbstractEventDispatcher::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQAbstractEventDispatcherChildEvent
func callbackQAbstractEventDispatcherChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractEventDispatcher::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQAbstractEventDispatcherFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QAbstractEventDispatcher) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractEventDispatcher) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractEventDispatcher) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QAbstractEventDispatcher::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QAbstractEventDispatcher) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QAbstractEventDispatcher::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQAbstractEventDispatcherCustomEvent
func callbackQAbstractEventDispatcherCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractEventDispatcher::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQAbstractEventDispatcherFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QAbstractEventDispatcher) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractEventDispatcher) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QAbstractEventDispatcher::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractEventDispatcher_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QAbstractItemModel struct {
	QObject
}

type QAbstractItemModel_ITF interface {
	QObject_ITF
	QAbstractItemModel_PTR() *QAbstractItemModel
}

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

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

func newQAbstractItemModelFromPointer(ptr unsafe.Pointer) *QAbstractItemModel {
	var n = NewQAbstractItemModelFromPointer(ptr)
	for len(n.ObjectName()) < len("QAbstractItemModel_") {
		n.SetObjectName("QAbstractItemModel_" + qt.Identifier())
	}
	return n
}

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

//QAbstractItemModel::LayoutChangeHint
type QAbstractItemModel__LayoutChangeHint int64

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

func (ptr *QAbstractItemModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::canDropMimeData")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) CanFetchMore(parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::canFetchMore")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) ColumnCount(parent QModelIndex_ITF) int {
	defer qt.Recovering("QAbstractItemModel::columnCount")

	if ptr.Pointer() != nil {
		return int(C.QAbstractItemModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
	}
	return 0
}

func (ptr *QAbstractItemModel) Data(index QModelIndex_ITF, role int) *QVariant {
	defer qt.Recovering("QAbstractItemModel::data")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QAbstractItemModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
	}
	return nil
}

func (ptr *QAbstractItemModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::dropMimeData")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
	defer qt.Recovering("QAbstractItemModel::flags")

	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QAbstractItemModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return 0
}

func (ptr *QAbstractItemModel) HasChildren(parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::hasChildren")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) HasIndex(row int, column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::hasIndex")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_HasIndex(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
	defer qt.Recovering("QAbstractItemModel::headerData")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QAbstractItemModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
	}
	return nil
}

func (ptr *QAbstractItemModel) ConnectHeaderDataChanged(f func(orientation Qt__Orientation, first int, last int)) {
	defer qt.Recovering("connect QAbstractItemModel::headerDataChanged")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_ConnectHeaderDataChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "headerDataChanged", f)
	}
}

func (ptr *QAbstractItemModel) DisconnectHeaderDataChanged() {
	defer qt.Recovering("disconnect QAbstractItemModel::headerDataChanged")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectHeaderDataChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "headerDataChanged")
	}
}

//export callbackQAbstractItemModelHeaderDataChanged
func callbackQAbstractItemModelHeaderDataChanged(ptr unsafe.Pointer, ptrName *C.char, orientation C.int, first C.int, last C.int) {
	defer qt.Recovering("callback QAbstractItemModel::headerDataChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "headerDataChanged"); signal != nil {
		signal.(func(Qt__Orientation, int, int))(Qt__Orientation(orientation), int(first), int(last))
	}

}

func (ptr *QAbstractItemModel) HeaderDataChanged(orientation Qt__Orientation, first int, last int) {
	defer qt.Recovering("QAbstractItemModel::headerDataChanged")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_HeaderDataChanged(ptr.Pointer(), C.int(orientation), C.int(first), C.int(last))
	}
}

func (ptr *QAbstractItemModel) InsertColumn(column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::insertColumn")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_InsertColumn(ptr.Pointer(), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::insertColumns")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) InsertRow(row int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::insertRow")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_InsertRow(ptr.Pointer(), C.int(row), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::insertRows")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) MimeTypes() []string {
	defer qt.Recovering("QAbstractItemModel::mimeTypes")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QAbstractItemModel_MimeTypes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QAbstractItemModel) ConnectModelAboutToBeReset(f func()) {
	defer qt.Recovering("connect QAbstractItemModel::modelAboutToBeReset")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_ConnectModelAboutToBeReset(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "modelAboutToBeReset", f)
	}
}

func (ptr *QAbstractItemModel) DisconnectModelAboutToBeReset() {
	defer qt.Recovering("disconnect QAbstractItemModel::modelAboutToBeReset")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectModelAboutToBeReset(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "modelAboutToBeReset")
	}
}

//export callbackQAbstractItemModelModelAboutToBeReset
func callbackQAbstractItemModelModelAboutToBeReset(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractItemModel::modelAboutToBeReset")

	if signal := qt.GetSignal(C.GoString(ptrName), "modelAboutToBeReset"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractItemModel) ConnectModelReset(f func()) {
	defer qt.Recovering("connect QAbstractItemModel::modelReset")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_ConnectModelReset(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "modelReset", f)
	}
}

func (ptr *QAbstractItemModel) DisconnectModelReset() {
	defer qt.Recovering("disconnect QAbstractItemModel::modelReset")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DisconnectModelReset(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "modelReset")
	}
}

//export callbackQAbstractItemModelModelReset
func callbackQAbstractItemModelModelReset(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractItemModel::modelReset")

	if signal := qt.GetSignal(C.GoString(ptrName), "modelReset"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractItemModel) MoveColumn(sourceParent QModelIndex_ITF, sourceColumn int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	defer qt.Recovering("QAbstractItemModel::moveColumn")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_MoveColumn(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) MoveColumns(sourceParent QModelIndex_ITF, sourceColumn int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	defer qt.Recovering("QAbstractItemModel::moveColumns")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_MoveColumns(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceColumn), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) MoveRow(sourceParent QModelIndex_ITF, sourceRow int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	defer qt.Recovering("QAbstractItemModel::moveRow")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_MoveRow(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) MoveRows(sourceParent QModelIndex_ITF, sourceRow int, count int, destinationParent QModelIndex_ITF, destinationChild int) bool {
	defer qt.Recovering("QAbstractItemModel::moveRows")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_MoveRows(ptr.Pointer(), PointerFromQModelIndex(sourceParent), C.int(sourceRow), C.int(count), PointerFromQModelIndex(destinationParent), C.int(destinationChild)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) RemoveColumn(column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::removeColumn")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_RemoveColumn(ptr.Pointer(), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::removeColumns")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) RemoveRow(row int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::removeRow")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_RemoveRow(ptr.Pointer(), C.int(row), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractItemModel::removeRows")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) ConnectRevert(f func()) {
	defer qt.Recovering("connect QAbstractItemModel::revert")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
	}
}

func (ptr *QAbstractItemModel) DisconnectRevert() {
	defer qt.Recovering("disconnect QAbstractItemModel::revert")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractItemModelRevert
func callbackQAbstractItemModelRevert(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QAbstractItemModel::revert")

	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QAbstractItemModel) Revert() {
	defer qt.Recovering("QAbstractItemModel::revert")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_Revert(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) RevertDefault() {
	defer qt.Recovering("QAbstractItemModel::revert")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_RevertDefault(ptr.Pointer())
	}
}

func (ptr *QAbstractItemModel) RowCount(parent QModelIndex_ITF) int {
	defer qt.Recovering("QAbstractItemModel::rowCount")

	if ptr.Pointer() != nil {
		return int(C.QAbstractItemModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
	}
	return 0
}

func (ptr *QAbstractItemModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
	defer qt.Recovering("QAbstractItemModel::setData")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
	defer qt.Recovering("QAbstractItemModel::setHeaderData")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
	defer qt.Recovering("connect QAbstractItemModel::sort")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
	}
}

func (ptr *QAbstractItemModel) DisconnectSort() {
	defer qt.Recovering("disconnect QAbstractItemModel::sort")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractItemModelSort
func callbackQAbstractItemModelSort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
	defer qt.Recovering("callback QAbstractItemModel::sort")

	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
	} else {
		NewQAbstractItemModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
	}
}

func (ptr *QAbstractItemModel) Sort(column int, order Qt__SortOrder) {
	defer qt.Recovering("QAbstractItemModel::sort")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QAbstractItemModel) SortDefault(column int, order Qt__SortOrder) {
	defer qt.Recovering("QAbstractItemModel::sort")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QAbstractItemModel) Span(index QModelIndex_ITF) *QSize {
	defer qt.Recovering("QAbstractItemModel::span")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QAbstractItemModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return nil
}

func (ptr *QAbstractItemModel) Submit() bool {
	defer qt.Recovering("QAbstractItemModel::submit")

	if ptr.Pointer() != nil {
		return C.QAbstractItemModel_Submit(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QAbstractItemModel) SupportedDragActions() Qt__DropAction {
	defer qt.Recovering("QAbstractItemModel::supportedDragActions")

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

func (ptr *QAbstractItemModel) SupportedDropActions() Qt__DropAction {
	defer qt.Recovering("QAbstractItemModel::supportedDropActions")

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

func (ptr *QAbstractItemModel) DestroyQAbstractItemModel() {
	defer qt.Recovering("QAbstractItemModel::~QAbstractItemModel")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_DestroyQAbstractItemModel(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractItemModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QAbstractItemModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QAbstractItemModel) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QAbstractItemModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQAbstractItemModelTimerEvent
func callbackQAbstractItemModelTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractItemModel::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQAbstractItemModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QAbstractItemModel) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractItemModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractItemModel) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractItemModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractItemModel) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QAbstractItemModel::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QAbstractItemModel) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QAbstractItemModel::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQAbstractItemModelChildEvent
func callbackQAbstractItemModelChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractItemModel::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQAbstractItemModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QAbstractItemModel) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractItemModel::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractItemModel) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractItemModel::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractItemModel) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QAbstractItemModel::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QAbstractItemModel) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QAbstractItemModel::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQAbstractItemModelCustomEvent
func callbackQAbstractItemModelCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractItemModel::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQAbstractItemModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QAbstractItemModel) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QAbstractItemModel::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractItemModel) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QAbstractItemModel::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractItemModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QAbstractListModel struct {
	QAbstractItemModel
}

type QAbstractListModel_ITF interface {
	QAbstractItemModel_ITF
	QAbstractListModel_PTR() *QAbstractListModel
}

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

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

func newQAbstractListModelFromPointer(ptr unsafe.Pointer) *QAbstractListModel {
	var n = NewQAbstractListModelFromPointer(ptr)
	for len(n.ObjectName()) < len("QAbstractListModel_") {
		n.SetObjectName("QAbstractListModel_" + qt.Identifier())
	}
	return n
}

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

func (ptr *QAbstractListModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractListModel::dropMimeData")

	if ptr.Pointer() != nil {
		return C.QAbstractListModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractListModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
	defer qt.Recovering("QAbstractListModel::flags")

	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QAbstractListModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return 0
}

func (ptr *QAbstractListModel) DestroyQAbstractListModel() {
	defer qt.Recovering("QAbstractListModel::~QAbstractListModel")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_DestroyQAbstractListModel(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractListModel) ConnectRevert(f func()) {
	defer qt.Recovering("connect QAbstractListModel::revert")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
	}
}

func (ptr *QAbstractListModel) DisconnectRevert() {
	defer qt.Recovering("disconnect QAbstractListModel::revert")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractListModelRevert
func callbackQAbstractListModelRevert(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QAbstractListModel::revert")

	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QAbstractListModel) Revert() {
	defer qt.Recovering("QAbstractListModel::revert")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_Revert(ptr.Pointer())
	}
}

func (ptr *QAbstractListModel) RevertDefault() {
	defer qt.Recovering("QAbstractListModel::revert")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_RevertDefault(ptr.Pointer())
	}
}

func (ptr *QAbstractListModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
	defer qt.Recovering("connect QAbstractListModel::sort")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
	}
}

func (ptr *QAbstractListModel) DisconnectSort() {
	defer qt.Recovering("disconnect QAbstractListModel::sort")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractListModelSort
func callbackQAbstractListModelSort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
	defer qt.Recovering("callback QAbstractListModel::sort")

	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
	} else {
		NewQAbstractListModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
	}
}

func (ptr *QAbstractListModel) Sort(column int, order Qt__SortOrder) {
	defer qt.Recovering("QAbstractListModel::sort")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QAbstractListModel) SortDefault(column int, order Qt__SortOrder) {
	defer qt.Recovering("QAbstractListModel::sort")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QAbstractListModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QAbstractListModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QAbstractListModel) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QAbstractListModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQAbstractListModelTimerEvent
func callbackQAbstractListModelTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractListModel::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQAbstractListModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QAbstractListModel) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractListModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractListModel) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractListModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractListModel) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QAbstractListModel::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QAbstractListModel) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QAbstractListModel::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQAbstractListModelChildEvent
func callbackQAbstractListModelChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractListModel::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQAbstractListModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QAbstractListModel) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractListModel::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractListModel) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractListModel::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractListModel) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QAbstractListModel::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QAbstractListModel) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QAbstractListModel::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQAbstractListModelCustomEvent
func callbackQAbstractListModelCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractListModel::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQAbstractListModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QAbstractListModel) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QAbstractListModel::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractListModel) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QAbstractListModel::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractListModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QAbstractNativeEventFilter struct {
	ptr unsafe.Pointer
}

type QAbstractNativeEventFilter_ITF interface {
	QAbstractNativeEventFilter_PTR() *QAbstractNativeEventFilter
}

func (p *QAbstractNativeEventFilter) Pointer() unsafe.Pointer {
	return p.ptr
}

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

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

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

func newQAbstractNativeEventFilterFromPointer(ptr unsafe.Pointer) *QAbstractNativeEventFilter {
	var n = NewQAbstractNativeEventFilterFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAbstractNativeEventFilter_") {
		n.SetObjectNameAbs("QAbstractNativeEventFilter_" + qt.Identifier())
	}
	return n
}

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

func (ptr *QAbstractNativeEventFilter) DestroyQAbstractNativeEventFilter() {
	defer qt.Recovering("QAbstractNativeEventFilter::~QAbstractNativeEventFilter")

	if ptr.Pointer() != nil {
		C.QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(ptr.Pointer())
	}
}

func (ptr *QAbstractNativeEventFilter) ObjectNameAbs() string {
	defer qt.Recovering("QAbstractNativeEventFilter::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAbstractNativeEventFilter_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QAbstractNativeEventFilter) SetObjectNameAbs(name string) {
	defer qt.Recovering("QAbstractNativeEventFilter::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QAbstractNativeEventFilter_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QAbstractProxyModel struct {
	QAbstractItemModel
}

type QAbstractProxyModel_ITF interface {
	QAbstractItemModel_ITF
	QAbstractProxyModel_PTR() *QAbstractProxyModel
}

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

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

func newQAbstractProxyModelFromPointer(ptr unsafe.Pointer) *QAbstractProxyModel {
	var n = NewQAbstractProxyModelFromPointer(ptr)
	for len(n.ObjectName()) < len("QAbstractProxyModel_") {
		n.SetObjectName("QAbstractProxyModel_" + qt.Identifier())
	}
	return n
}

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

func (ptr *QAbstractProxyModel) CanDropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractProxyModel::canDropMimeData")

	if ptr.Pointer() != nil {
		return C.QAbstractProxyModel_CanDropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractProxyModel) CanFetchMore(parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractProxyModel::canFetchMore")

	if ptr.Pointer() != nil {
		return C.QAbstractProxyModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractProxyModel) Data(proxyIndex QModelIndex_ITF, role int) *QVariant {
	defer qt.Recovering("QAbstractProxyModel::data")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QAbstractProxyModel_Data(ptr.Pointer(), PointerFromQModelIndex(proxyIndex), C.int(role)))
	}
	return nil
}

func (ptr *QAbstractProxyModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractProxyModel::dropMimeData")

	if ptr.Pointer() != nil {
		return C.QAbstractProxyModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractProxyModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
	defer qt.Recovering("QAbstractProxyModel::flags")

	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QAbstractProxyModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return 0
}

func (ptr *QAbstractProxyModel) HasChildren(parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractProxyModel::hasChildren")

	if ptr.Pointer() != nil {
		return C.QAbstractProxyModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractProxyModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
	defer qt.Recovering("QAbstractProxyModel::headerData")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QAbstractProxyModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
	}
	return nil
}

func (ptr *QAbstractProxyModel) MimeTypes() []string {
	defer qt.Recovering("QAbstractProxyModel::mimeTypes")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QAbstractProxyModel_MimeTypes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QAbstractProxyModel) ConnectRevert(f func()) {
	defer qt.Recovering("connect QAbstractProxyModel::revert")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
	}
}

func (ptr *QAbstractProxyModel) DisconnectRevert() {
	defer qt.Recovering("disconnect QAbstractProxyModel::revert")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractProxyModelRevert
func callbackQAbstractProxyModelRevert(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QAbstractProxyModel::revert")

	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QAbstractProxyModel) Revert() {
	defer qt.Recovering("QAbstractProxyModel::revert")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_Revert(ptr.Pointer())
	}
}

func (ptr *QAbstractProxyModel) RevertDefault() {
	defer qt.Recovering("QAbstractProxyModel::revert")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_RevertDefault(ptr.Pointer())
	}
}

func (ptr *QAbstractProxyModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
	defer qt.Recovering("QAbstractProxyModel::setData")

	if ptr.Pointer() != nil {
		return C.QAbstractProxyModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
	}
	return false
}

func (ptr *QAbstractProxyModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
	defer qt.Recovering("QAbstractProxyModel::setHeaderData")

	if ptr.Pointer() != nil {
		return C.QAbstractProxyModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
	}
	return false
}

func (ptr *QAbstractProxyModel) ConnectSetSourceModel(f func(sourceModel *QAbstractItemModel)) {
	defer qt.Recovering("connect QAbstractProxyModel::setSourceModel")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "setSourceModel", f)
	}
}

func (ptr *QAbstractProxyModel) DisconnectSetSourceModel() {
	defer qt.Recovering("disconnect QAbstractProxyModel::setSourceModel")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "setSourceModel")
	}
}

//export callbackQAbstractProxyModelSetSourceModel
func callbackQAbstractProxyModelSetSourceModel(ptr unsafe.Pointer, ptrName *C.char, sourceModel unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractProxyModel::setSourceModel")

	if signal := qt.GetSignal(C.GoString(ptrName), "setSourceModel"); signal != nil {
		signal.(func(*QAbstractItemModel))(NewQAbstractItemModelFromPointer(sourceModel))
	} else {
		NewQAbstractProxyModelFromPointer(ptr).SetSourceModelDefault(NewQAbstractItemModelFromPointer(sourceModel))
	}
}

func (ptr *QAbstractProxyModel) SetSourceModel(sourceModel QAbstractItemModel_ITF) {
	defer qt.Recovering("QAbstractProxyModel::setSourceModel")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_SetSourceModel(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
	}
}

func (ptr *QAbstractProxyModel) SetSourceModelDefault(sourceModel QAbstractItemModel_ITF) {
	defer qt.Recovering("QAbstractProxyModel::setSourceModel")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_SetSourceModelDefault(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
	}
}

func (ptr *QAbstractProxyModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
	defer qt.Recovering("connect QAbstractProxyModel::sort")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
	}
}

func (ptr *QAbstractProxyModel) DisconnectSort() {
	defer qt.Recovering("disconnect QAbstractProxyModel::sort")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractProxyModelSort
func callbackQAbstractProxyModelSort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
	defer qt.Recovering("callback QAbstractProxyModel::sort")

	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
	} else {
		NewQAbstractProxyModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
	}
}

func (ptr *QAbstractProxyModel) Sort(column int, order Qt__SortOrder) {
	defer qt.Recovering("QAbstractProxyModel::sort")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QAbstractProxyModel) SortDefault(column int, order Qt__SortOrder) {
	defer qt.Recovering("QAbstractProxyModel::sort")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QAbstractProxyModel) SourceModel() *QAbstractItemModel {
	defer qt.Recovering("QAbstractProxyModel::sourceModel")

	if ptr.Pointer() != nil {
		return NewQAbstractItemModelFromPointer(C.QAbstractProxyModel_SourceModel(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAbstractProxyModel) ConnectSourceModelChanged(f func()) {
	defer qt.Recovering("connect QAbstractProxyModel::sourceModelChanged")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_ConnectSourceModelChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "sourceModelChanged", f)
	}
}

func (ptr *QAbstractProxyModel) DisconnectSourceModelChanged() {
	defer qt.Recovering("disconnect QAbstractProxyModel::sourceModelChanged")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_DisconnectSourceModelChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "sourceModelChanged")
	}
}

//export callbackQAbstractProxyModelSourceModelChanged
func callbackQAbstractProxyModelSourceModelChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractProxyModel::sourceModelChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "sourceModelChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractProxyModel) Span(index QModelIndex_ITF) *QSize {
	defer qt.Recovering("QAbstractProxyModel::span")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QAbstractProxyModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return nil
}

func (ptr *QAbstractProxyModel) Submit() bool {
	defer qt.Recovering("QAbstractProxyModel::submit")

	if ptr.Pointer() != nil {
		return C.QAbstractProxyModel_Submit(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QAbstractProxyModel) SupportedDragActions() Qt__DropAction {
	defer qt.Recovering("QAbstractProxyModel::supportedDragActions")

	if ptr.Pointer() != nil {
		return Qt__DropAction(C.QAbstractProxyModel_SupportedDragActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractProxyModel) SupportedDropActions() Qt__DropAction {
	defer qt.Recovering("QAbstractProxyModel::supportedDropActions")

	if ptr.Pointer() != nil {
		return Qt__DropAction(C.QAbstractProxyModel_SupportedDropActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractProxyModel) DestroyQAbstractProxyModel() {
	defer qt.Recovering("QAbstractProxyModel::~QAbstractProxyModel")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_DestroyQAbstractProxyModel(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractProxyModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QAbstractProxyModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QAbstractProxyModel) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QAbstractProxyModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQAbstractProxyModelTimerEvent
func callbackQAbstractProxyModelTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractProxyModel::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQAbstractProxyModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QAbstractProxyModel) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractProxyModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractProxyModel) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractProxyModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractProxyModel) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QAbstractProxyModel::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QAbstractProxyModel) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QAbstractProxyModel::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQAbstractProxyModelChildEvent
func callbackQAbstractProxyModelChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractProxyModel::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQAbstractProxyModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QAbstractProxyModel) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractProxyModel::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractProxyModel) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractProxyModel::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractProxyModel) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QAbstractProxyModel::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QAbstractProxyModel) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QAbstractProxyModel::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQAbstractProxyModelCustomEvent
func callbackQAbstractProxyModelCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractProxyModel::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQAbstractProxyModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QAbstractProxyModel) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QAbstractProxyModel::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractProxyModel) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QAbstractProxyModel::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractProxyModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QAbstractState struct {
	QObject
}

type QAbstractState_ITF interface {
	QObject_ITF
	QAbstractState_PTR() *QAbstractState
}

func PointerFromQAbstractState(ptr QAbstractState_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractState_PTR().Pointer()
	}
	return nil
}

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

func newQAbstractStateFromPointer(ptr unsafe.Pointer) *QAbstractState {
	var n = NewQAbstractStateFromPointer(ptr)
	for len(n.ObjectName()) < len("QAbstractState_") {
		n.SetObjectName("QAbstractState_" + qt.Identifier())
	}
	return n
}

func (ptr *QAbstractState) QAbstractState_PTR() *QAbstractState {
	return ptr
}

func (ptr *QAbstractState) Active() bool {
	defer qt.Recovering("QAbstractState::active")

	if ptr.Pointer() != nil {
		return C.QAbstractState_Active(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QAbstractState) ConnectActiveChanged(f func(active bool)) {
	defer qt.Recovering("connect QAbstractState::activeChanged")

	if ptr.Pointer() != nil {
		C.QAbstractState_ConnectActiveChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "activeChanged", f)
	}
}

func (ptr *QAbstractState) DisconnectActiveChanged() {
	defer qt.Recovering("disconnect QAbstractState::activeChanged")

	if ptr.Pointer() != nil {
		C.QAbstractState_DisconnectActiveChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "activeChanged")
	}
}

//export callbackQAbstractStateActiveChanged
func callbackQAbstractStateActiveChanged(ptr unsafe.Pointer, ptrName *C.char, active C.int) {
	defer qt.Recovering("callback QAbstractState::activeChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "activeChanged"); signal != nil {
		signal.(func(bool))(int(active) != 0)
	}

}

func (ptr *QAbstractState) ActiveChanged(active bool) {
	defer qt.Recovering("QAbstractState::activeChanged")

	if ptr.Pointer() != nil {
		C.QAbstractState_ActiveChanged(ptr.Pointer(), C.int(qt.GoBoolToInt(active)))
	}
}

func (ptr *QAbstractState) ConnectEntered(f func()) {
	defer qt.Recovering("connect QAbstractState::entered")

	if ptr.Pointer() != nil {
		C.QAbstractState_ConnectEntered(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "entered", f)
	}
}

func (ptr *QAbstractState) DisconnectEntered() {
	defer qt.Recovering("disconnect QAbstractState::entered")

	if ptr.Pointer() != nil {
		C.QAbstractState_DisconnectEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "entered")
	}
}

//export callbackQAbstractStateEntered
func callbackQAbstractStateEntered(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractState::entered")

	if signal := qt.GetSignal(C.GoString(ptrName), "entered"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractState) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QAbstractState::event")

	if ptr.Pointer() != nil {
		return C.QAbstractState_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QAbstractState) ConnectExited(f func()) {
	defer qt.Recovering("connect QAbstractState::exited")

	if ptr.Pointer() != nil {
		C.QAbstractState_ConnectExited(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "exited", f)
	}
}

func (ptr *QAbstractState) DisconnectExited() {
	defer qt.Recovering("disconnect QAbstractState::exited")

	if ptr.Pointer() != nil {
		C.QAbstractState_DisconnectExited(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "exited")
	}
}

//export callbackQAbstractStateExited
func callbackQAbstractStateExited(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractState::exited")

	if signal := qt.GetSignal(C.GoString(ptrName), "exited"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractState) Machine() *QStateMachine {
	defer qt.Recovering("QAbstractState::machine")

	if ptr.Pointer() != nil {
		return NewQStateMachineFromPointer(C.QAbstractState_Machine(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAbstractState) ParentState() *QState {
	defer qt.Recovering("QAbstractState::parentState")

	if ptr.Pointer() != nil {
		return NewQStateFromPointer(C.QAbstractState_ParentState(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAbstractState) DestroyQAbstractState() {
	defer qt.Recovering("QAbstractState::~QAbstractState")

	if ptr.Pointer() != nil {
		C.QAbstractState_DestroyQAbstractState(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractState) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QAbstractState::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QAbstractState) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QAbstractState::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQAbstractStateTimerEvent
func callbackQAbstractStateTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractState::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQAbstractStateFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QAbstractState) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractState::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractState_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractState) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractState::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractState_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractState) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QAbstractState::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QAbstractState) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QAbstractState::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQAbstractStateChildEvent
func callbackQAbstractStateChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractState::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQAbstractStateFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QAbstractState) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractState::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractState_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractState) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractState::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractState_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractState) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QAbstractState::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QAbstractState) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QAbstractState::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQAbstractStateCustomEvent
func callbackQAbstractStateCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractState::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQAbstractStateFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QAbstractState) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QAbstractState::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractState_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractState) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QAbstractState::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractState_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QAbstractTableModel struct {
	QAbstractItemModel
}

type QAbstractTableModel_ITF interface {
	QAbstractItemModel_ITF
	QAbstractTableModel_PTR() *QAbstractTableModel
}

func PointerFromQAbstractTableModel(ptr QAbstractTableModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractTableModel_PTR().Pointer()
	}
	return nil
}

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

func newQAbstractTableModelFromPointer(ptr unsafe.Pointer) *QAbstractTableModel {
	var n = NewQAbstractTableModelFromPointer(ptr)
	for len(n.ObjectName()) < len("QAbstractTableModel_") {
		n.SetObjectName("QAbstractTableModel_" + qt.Identifier())
	}
	return n
}

func (ptr *QAbstractTableModel) QAbstractTableModel_PTR() *QAbstractTableModel {
	return ptr
}

func (ptr *QAbstractTableModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QAbstractTableModel::dropMimeData")

	if ptr.Pointer() != nil {
		return C.QAbstractTableModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QAbstractTableModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
	defer qt.Recovering("QAbstractTableModel::flags")

	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QAbstractTableModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return 0
}

func (ptr *QAbstractTableModel) DestroyQAbstractTableModel() {
	defer qt.Recovering("QAbstractTableModel::~QAbstractTableModel")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_DestroyQAbstractTableModel(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractTableModel) ConnectRevert(f func()) {
	defer qt.Recovering("connect QAbstractTableModel::revert")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
	}
}

func (ptr *QAbstractTableModel) DisconnectRevert() {
	defer qt.Recovering("disconnect QAbstractTableModel::revert")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractTableModelRevert
func callbackQAbstractTableModelRevert(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QAbstractTableModel::revert")

	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QAbstractTableModel) Revert() {
	defer qt.Recovering("QAbstractTableModel::revert")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_Revert(ptr.Pointer())
	}
}

func (ptr *QAbstractTableModel) RevertDefault() {
	defer qt.Recovering("QAbstractTableModel::revert")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_RevertDefault(ptr.Pointer())
	}
}

func (ptr *QAbstractTableModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
	defer qt.Recovering("connect QAbstractTableModel::sort")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
	}
}

func (ptr *QAbstractTableModel) DisconnectSort() {
	defer qt.Recovering("disconnect QAbstractTableModel::sort")

	if ptr.Pointer() != nil {

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

//export callbackQAbstractTableModelSort
func callbackQAbstractTableModelSort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
	defer qt.Recovering("callback QAbstractTableModel::sort")

	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
	} else {
		NewQAbstractTableModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
	}
}

func (ptr *QAbstractTableModel) Sort(column int, order Qt__SortOrder) {
	defer qt.Recovering("QAbstractTableModel::sort")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QAbstractTableModel) SortDefault(column int, order Qt__SortOrder) {
	defer qt.Recovering("QAbstractTableModel::sort")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QAbstractTableModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QAbstractTableModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QAbstractTableModel) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QAbstractTableModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQAbstractTableModelTimerEvent
func callbackQAbstractTableModelTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractTableModel::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQAbstractTableModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QAbstractTableModel) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractTableModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractTableModel) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractTableModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractTableModel) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QAbstractTableModel::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QAbstractTableModel) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QAbstractTableModel::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQAbstractTableModelChildEvent
func callbackQAbstractTableModelChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractTableModel::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQAbstractTableModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QAbstractTableModel) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractTableModel::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractTableModel) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractTableModel::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractTableModel) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QAbstractTableModel::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QAbstractTableModel) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QAbstractTableModel::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQAbstractTableModelCustomEvent
func callbackQAbstractTableModelCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractTableModel::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQAbstractTableModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QAbstractTableModel) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QAbstractTableModel::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractTableModel) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QAbstractTableModel::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTableModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QAbstractTransition struct {
	QObject
}

type QAbstractTransition_ITF interface {
	QObject_ITF
	QAbstractTransition_PTR() *QAbstractTransition
}

func PointerFromQAbstractTransition(ptr QAbstractTransition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractTransition_PTR().Pointer()
	}
	return nil
}

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

func newQAbstractTransitionFromPointer(ptr unsafe.Pointer) *QAbstractTransition {
	var n = NewQAbstractTransitionFromPointer(ptr)
	for len(n.ObjectName()) < len("QAbstractTransition_") {
		n.SetObjectName("QAbstractTransition_" + qt.Identifier())
	}
	return n
}

func (ptr *QAbstractTransition) QAbstractTransition_PTR() *QAbstractTransition {
	return ptr
}

//QAbstractTransition::TransitionType
type QAbstractTransition__TransitionType int64

const (
	QAbstractTransition__ExternalTransition = QAbstractTransition__TransitionType(0)
	QAbstractTransition__InternalTransition = QAbstractTransition__TransitionType(1)
)

func (ptr *QAbstractTransition) AddAnimation(animation QAbstractAnimation_ITF) {
	defer qt.Recovering("QAbstractTransition::addAnimation")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_AddAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QAbstractTransition) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QAbstractTransition::event")

	if ptr.Pointer() != nil {
		return C.QAbstractTransition_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QAbstractTransition) Machine() *QStateMachine {
	defer qt.Recovering("QAbstractTransition::machine")

	if ptr.Pointer() != nil {
		return NewQStateMachineFromPointer(C.QAbstractTransition_Machine(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAbstractTransition) RemoveAnimation(animation QAbstractAnimation_ITF) {
	defer qt.Recovering("QAbstractTransition::removeAnimation")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_RemoveAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QAbstractTransition) SetTargetState(target QAbstractState_ITF) {
	defer qt.Recovering("QAbstractTransition::setTargetState")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_SetTargetState(ptr.Pointer(), PointerFromQAbstractState(target))
	}
}

func (ptr *QAbstractTransition) SetTransitionType(ty QAbstractTransition__TransitionType) {
	defer qt.Recovering("QAbstractTransition::setTransitionType")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_SetTransitionType(ptr.Pointer(), C.int(ty))
	}
}

func (ptr *QAbstractTransition) SourceState() *QState {
	defer qt.Recovering("QAbstractTransition::sourceState")

	if ptr.Pointer() != nil {
		return NewQStateFromPointer(C.QAbstractTransition_SourceState(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAbstractTransition) TargetState() *QAbstractState {
	defer qt.Recovering("QAbstractTransition::targetState")

	if ptr.Pointer() != nil {
		return NewQAbstractStateFromPointer(C.QAbstractTransition_TargetState(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAbstractTransition) ConnectTargetStateChanged(f func()) {
	defer qt.Recovering("connect QAbstractTransition::targetStateChanged")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_ConnectTargetStateChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "targetStateChanged", f)
	}
}

func (ptr *QAbstractTransition) DisconnectTargetStateChanged() {
	defer qt.Recovering("disconnect QAbstractTransition::targetStateChanged")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_DisconnectTargetStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "targetStateChanged")
	}
}

//export callbackQAbstractTransitionTargetStateChanged
func callbackQAbstractTransitionTargetStateChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractTransition::targetStateChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "targetStateChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractTransition) ConnectTargetStatesChanged(f func()) {
	defer qt.Recovering("connect QAbstractTransition::targetStatesChanged")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_ConnectTargetStatesChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "targetStatesChanged", f)
	}
}

func (ptr *QAbstractTransition) DisconnectTargetStatesChanged() {
	defer qt.Recovering("disconnect QAbstractTransition::targetStatesChanged")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_DisconnectTargetStatesChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "targetStatesChanged")
	}
}

//export callbackQAbstractTransitionTargetStatesChanged
func callbackQAbstractTransitionTargetStatesChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractTransition::targetStatesChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "targetStatesChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractTransition) TransitionType() QAbstractTransition__TransitionType {
	defer qt.Recovering("QAbstractTransition::transitionType")

	if ptr.Pointer() != nil {
		return QAbstractTransition__TransitionType(C.QAbstractTransition_TransitionType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractTransition) ConnectTriggered(f func()) {
	defer qt.Recovering("connect QAbstractTransition::triggered")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_ConnectTriggered(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "triggered", f)
	}
}

func (ptr *QAbstractTransition) DisconnectTriggered() {
	defer qt.Recovering("disconnect QAbstractTransition::triggered")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_DisconnectTriggered(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "triggered")
	}
}

//export callbackQAbstractTransitionTriggered
func callbackQAbstractTransitionTriggered(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QAbstractTransition::triggered")

	if signal := qt.GetSignal(C.GoString(ptrName), "triggered"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QAbstractTransition) DestroyQAbstractTransition() {
	defer qt.Recovering("QAbstractTransition::~QAbstractTransition")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_DestroyQAbstractTransition(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractTransition) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QAbstractTransition::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QAbstractTransition) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QAbstractTransition::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQAbstractTransitionTimerEvent
func callbackQAbstractTransitionTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractTransition::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQAbstractTransitionFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QAbstractTransition) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractTransition::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractTransition) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QAbstractTransition::timerEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QAbstractTransition) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QAbstractTransition::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QAbstractTransition) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QAbstractTransition::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQAbstractTransitionChildEvent
func callbackQAbstractTransitionChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractTransition::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQAbstractTransitionFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QAbstractTransition) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractTransition::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractTransition) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QAbstractTransition::childEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QAbstractTransition) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QAbstractTransition::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QAbstractTransition) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QAbstractTransition::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQAbstractTransitionCustomEvent
func callbackQAbstractTransitionCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QAbstractTransition::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQAbstractTransitionFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QAbstractTransition) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QAbstractTransition::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QAbstractTransition) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QAbstractTransition::customEvent")

	if ptr.Pointer() != nil {
		C.QAbstractTransition_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QAnimationGroup struct {
	QAbstractAnimation
}

type QAnimationGroup_ITF interface {
	QAbstractAnimation_ITF
	QAnimationGroup_PTR() *QAnimationGroup
}

func PointerFromQAnimationGroup(ptr QAnimationGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAnimationGroup_PTR().Pointer()
	}
	return nil
}

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

func newQAnimationGroupFromPointer(ptr unsafe.Pointer) *QAnimationGroup {
	var n = NewQAnimationGroupFromPointer(ptr)
	for len(n.ObjectName()) < len("QAnimationGroup_") {
		n.SetObjectName("QAnimationGroup_" + qt.Identifier())
	}
	return n
}

func (ptr *QAnimationGroup) QAnimationGroup_PTR() *QAnimationGroup {
	return ptr
}

type QAssociativeIterable struct {
	ptr unsafe.Pointer
}

type QAssociativeIterable_ITF interface {
	QAssociativeIterable_PTR() *QAssociativeIterable
}

func (p *QAssociativeIterable) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QAssociativeIterable) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQAssociativeIterable(ptr QAssociativeIterable_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAssociativeIterable_PTR().Pointer()
	}
	return nil
}

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

func newQAssociativeIterableFromPointer(ptr unsafe.Pointer) *QAssociativeIterable {
	var n = NewQAssociativeIterableFromPointer(ptr)
	return n
}

func (ptr *QAssociativeIterable) QAssociativeIterable_PTR() *QAssociativeIterable {
	return ptr
}

func (ptr *QAssociativeIterable) Size() int {
	defer qt.Recovering("QAssociativeIterable::size")

	if ptr.Pointer() != nil {
		return int(C.QAssociativeIterable_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAssociativeIterable) Value(key QVariant_ITF) *QVariant {
	defer qt.Recovering("QAssociativeIterable::value")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QAssociativeIterable_Value(ptr.Pointer(), PointerFromQVariant(key)))
	}
	return nil
}

type QAtomicInt struct {
	QAtomicInteger
}

type QAtomicInt_ITF interface {
	QAtomicInteger_ITF
	QAtomicInt_PTR() *QAtomicInt
}

func PointerFromQAtomicInt(ptr QAtomicInt_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAtomicInt_PTR().Pointer()
	}
	return nil
}

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

func newQAtomicIntFromPointer(ptr unsafe.Pointer) *QAtomicInt {
	var n = NewQAtomicIntFromPointer(ptr)
	return n
}

func (ptr *QAtomicInt) QAtomicInt_PTR() *QAtomicInt {
	return ptr
}

type QAtomicInteger struct {
	ptr unsafe.Pointer
}

type QAtomicInteger_ITF interface {
	QAtomicInteger_PTR() *QAtomicInteger
}

func (p *QAtomicInteger) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QAtomicInteger) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQAtomicInteger(ptr QAtomicInteger_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAtomicInteger_PTR().Pointer()
	}
	return nil
}

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

func newQAtomicIntegerFromPointer(ptr unsafe.Pointer) *QAtomicInteger {
	var n = NewQAtomicIntegerFromPointer(ptr)
	return n
}

func (ptr *QAtomicInteger) QAtomicInteger_PTR() *QAtomicInteger {
	return ptr
}

type QAtomicPointer struct {
	ptr unsafe.Pointer
}

type QAtomicPointer_ITF interface {
	QAtomicPointer_PTR() *QAtomicPointer
}

func (p *QAtomicPointer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QAtomicPointer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQAtomicPointer(ptr QAtomicPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAtomicPointer_PTR().Pointer()
	}
	return nil
}

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

func newQAtomicPointerFromPointer(ptr unsafe.Pointer) *QAtomicPointer {
	var n = NewQAtomicPointerFromPointer(ptr)
	return n
}

func (ptr *QAtomicPointer) QAtomicPointer_PTR() *QAtomicPointer {
	return ptr
}

type QBasicTimer struct {
	ptr unsafe.Pointer
}

type QBasicTimer_ITF interface {
	QBasicTimer_PTR() *QBasicTimer
}

func (p *QBasicTimer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QBasicTimer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQBasicTimer(ptr QBasicTimer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBasicTimer_PTR().Pointer()
	}
	return nil
}

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

func newQBasicTimerFromPointer(ptr unsafe.Pointer) *QBasicTimer {
	var n = NewQBasicTimerFromPointer(ptr)
	return n
}

func (ptr *QBasicTimer) QBasicTimer_PTR() *QBasicTimer {
	return ptr
}

func (ptr *QBasicTimer) Start(msec int, object QObject_ITF) {
	defer qt.Recovering("QBasicTimer::start")

	if ptr.Pointer() != nil {
		C.QBasicTimer_Start(ptr.Pointer(), C.int(msec), PointerFromQObject(object))
	}
}

func NewQBasicTimer() *QBasicTimer {
	defer qt.Recovering("QBasicTimer::QBasicTimer")

	return newQBasicTimerFromPointer(C.QBasicTimer_NewQBasicTimer())
}

func (ptr *QBasicTimer) IsActive() bool {
	defer qt.Recovering("QBasicTimer::isActive")

	if ptr.Pointer() != nil {
		return C.QBasicTimer_IsActive(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QBasicTimer) Start2(msec int, timerType Qt__TimerType, obj QObject_ITF) {
	defer qt.Recovering("QBasicTimer::start")

	if ptr.Pointer() != nil {
		C.QBasicTimer_Start2(ptr.Pointer(), C.int(msec), C.int(timerType), PointerFromQObject(obj))
	}
}

func (ptr *QBasicTimer) Stop() {
	defer qt.Recovering("QBasicTimer::stop")

	if ptr.Pointer() != nil {
		C.QBasicTimer_Stop(ptr.Pointer())
	}
}

func (ptr *QBasicTimer) TimerId() int {
	defer qt.Recovering("QBasicTimer::timerId")

	if ptr.Pointer() != nil {
		return int(C.QBasicTimer_TimerId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QBasicTimer) DestroyQBasicTimer() {
	defer qt.Recovering("QBasicTimer::~QBasicTimer")

	if ptr.Pointer() != nil {
		C.QBasicTimer_DestroyQBasicTimer(ptr.Pointer())
	}
}

type QBitArray struct {
	ptr unsafe.Pointer
}

type QBitArray_ITF interface {
	QBitArray_PTR() *QBitArray
}

func (p *QBitArray) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QBitArray) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQBitArray(ptr QBitArray_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBitArray_PTR().Pointer()
	}
	return nil
}

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

func newQBitArrayFromPointer(ptr unsafe.Pointer) *QBitArray {
	var n = NewQBitArrayFromPointer(ptr)
	return n
}

func (ptr *QBitArray) QBitArray_PTR() *QBitArray {
	return ptr
}

func NewQBitArray() *QBitArray {
	defer qt.Recovering("QBitArray::QBitArray")

	return newQBitArrayFromPointer(C.QBitArray_NewQBitArray())
}

func NewQBitArray4(other QBitArray_ITF) *QBitArray {
	defer qt.Recovering("QBitArray::QBitArray")

	return newQBitArrayFromPointer(C.QBitArray_NewQBitArray4(PointerFromQBitArray(other)))
}

func NewQBitArray3(other QBitArray_ITF) *QBitArray {
	defer qt.Recovering("QBitArray::QBitArray")

	return newQBitArrayFromPointer(C.QBitArray_NewQBitArray3(PointerFromQBitArray(other)))
}

func NewQBitArray2(size int, value bool) *QBitArray {
	defer qt.Recovering("QBitArray::QBitArray")

	return newQBitArrayFromPointer(C.QBitArray_NewQBitArray2(C.int(size), C.int(qt.GoBoolToInt(value))))
}

func (ptr *QBitArray) At(i int) bool {
	defer qt.Recovering("QBitArray::at")

	if ptr.Pointer() != nil {
		return C.QBitArray_At(ptr.Pointer(), C.int(i)) != 0
	}
	return false
}

func (ptr *QBitArray) Clear() {
	defer qt.Recovering("QBitArray::clear")

	if ptr.Pointer() != nil {
		C.QBitArray_Clear(ptr.Pointer())
	}
}

func (ptr *QBitArray) ClearBit(i int) {
	defer qt.Recovering("QBitArray::clearBit")

	if ptr.Pointer() != nil {
		C.QBitArray_ClearBit(ptr.Pointer(), C.int(i))
	}
}

func (ptr *QBitArray) Count() int {
	defer qt.Recovering("QBitArray::count")

	if ptr.Pointer() != nil {
		return int(C.QBitArray_Count(ptr.Pointer()))
	}
	return 0
}

func (ptr *QBitArray) Count2(on bool) int {
	defer qt.Recovering("QBitArray::count")

	if ptr.Pointer() != nil {
		return int(C.QBitArray_Count2(ptr.Pointer(), C.int(qt.GoBoolToInt(on))))
	}
	return 0
}

func (ptr *QBitArray) Fill(value bool, size int) bool {
	defer qt.Recovering("QBitArray::fill")

	if ptr.Pointer() != nil {
		return C.QBitArray_Fill(ptr.Pointer(), C.int(qt.GoBoolToInt(value)), C.int(size)) != 0
	}
	return false
}

func (ptr *QBitArray) Fill2(value bool, begin int, end int) {
	defer qt.Recovering("QBitArray::fill")

	if ptr.Pointer() != nil {
		C.QBitArray_Fill2(ptr.Pointer(), C.int(qt.GoBoolToInt(value)), C.int(begin), C.int(end))
	}
}

func (ptr *QBitArray) IsEmpty() bool {
	defer qt.Recovering("QBitArray::isEmpty")

	if ptr.Pointer() != nil {
		return C.QBitArray_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QBitArray) IsNull() bool {
	defer qt.Recovering("QBitArray::isNull")

	if ptr.Pointer() != nil {
		return C.QBitArray_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QBitArray) Resize(size int) {
	defer qt.Recovering("QBitArray::resize")

	if ptr.Pointer() != nil {
		C.QBitArray_Resize(ptr.Pointer(), C.int(size))
	}
}

func (ptr *QBitArray) SetBit(i int) {
	defer qt.Recovering("QBitArray::setBit")

	if ptr.Pointer() != nil {
		C.QBitArray_SetBit(ptr.Pointer(), C.int(i))
	}
}

func (ptr *QBitArray) SetBit2(i int, value bool) {
	defer qt.Recovering("QBitArray::setBit")

	if ptr.Pointer() != nil {
		C.QBitArray_SetBit2(ptr.Pointer(), C.int(i), C.int(qt.GoBoolToInt(value)))
	}
}

func (ptr *QBitArray) Size() int {
	defer qt.Recovering("QBitArray::size")

	if ptr.Pointer() != nil {
		return int(C.QBitArray_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QBitArray) Swap(other QBitArray_ITF) {
	defer qt.Recovering("QBitArray::swap")

	if ptr.Pointer() != nil {
		C.QBitArray_Swap(ptr.Pointer(), PointerFromQBitArray(other))
	}
}

func (ptr *QBitArray) TestBit(i int) bool {
	defer qt.Recovering("QBitArray::testBit")

	if ptr.Pointer() != nil {
		return C.QBitArray_TestBit(ptr.Pointer(), C.int(i)) != 0
	}
	return false
}

func (ptr *QBitArray) ToggleBit(i int) bool {
	defer qt.Recovering("QBitArray::toggleBit")

	if ptr.Pointer() != nil {
		return C.QBitArray_ToggleBit(ptr.Pointer(), C.int(i)) != 0
	}
	return false
}

func (ptr *QBitArray) Truncate(pos int) {
	defer qt.Recovering("QBitArray::truncate")

	if ptr.Pointer() != nil {
		C.QBitArray_Truncate(ptr.Pointer(), C.int(pos))
	}
}

type QBuffer struct {
	QIODevice
}

type QBuffer_ITF interface {
	QIODevice_ITF
	QBuffer_PTR() *QBuffer
}

func PointerFromQBuffer(ptr QBuffer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBuffer_PTR().Pointer()
	}
	return nil
}

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

func newQBufferFromPointer(ptr unsafe.Pointer) *QBuffer {
	var n = NewQBufferFromPointer(ptr)
	for len(n.ObjectName()) < len("QBuffer_") {
		n.SetObjectName("QBuffer_" + qt.Identifier())
	}
	return n
}

func (ptr *QBuffer) QBuffer_PTR() *QBuffer {
	return ptr
}

func NewQBuffer2(byteArray string, parent QObject_ITF) *QBuffer {
	defer qt.Recovering("QBuffer::QBuffer")

	return newQBufferFromPointer(C.QBuffer_NewQBuffer2(C.CString(byteArray), PointerFromQObject(parent)))
}

func NewQBuffer(parent QObject_ITF) *QBuffer {
	defer qt.Recovering("QBuffer::QBuffer")

	return newQBufferFromPointer(C.QBuffer_NewQBuffer(PointerFromQObject(parent)))
}

func (ptr *QBuffer) AtEnd() bool {
	defer qt.Recovering("QBuffer::atEnd")

	if ptr.Pointer() != nil {
		return C.QBuffer_AtEnd(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QBuffer) Buffer() string {
	defer qt.Recovering("QBuffer::buffer")

	if ptr.Pointer() != nil {
		return C.GoString(C.QBuffer_Buffer(ptr.Pointer()))
	}
	return ""
}

func (ptr *QBuffer) Buffer2() string {
	defer qt.Recovering("QBuffer::buffer")

	if ptr.Pointer() != nil {
		return C.GoString(C.QBuffer_Buffer2(ptr.Pointer()))
	}
	return ""
}

func (ptr *QBuffer) CanReadLine() bool {
	defer qt.Recovering("QBuffer::canReadLine")

	if ptr.Pointer() != nil {
		return C.QBuffer_CanReadLine(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QBuffer) ConnectClose(f func()) {
	defer qt.Recovering("connect QBuffer::close")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "close", f)
	}
}

func (ptr *QBuffer) DisconnectClose() {
	defer qt.Recovering("disconnect QBuffer::close")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "close")
	}
}

//export callbackQBufferClose
func callbackQBufferClose(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QBuffer::close")

	if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
		signal.(func())()
	} else {
		NewQBufferFromPointer(ptr).CloseDefault()
	}
}

func (ptr *QBuffer) Close() {
	defer qt.Recovering("QBuffer::close")

	if ptr.Pointer() != nil {
		C.QBuffer_Close(ptr.Pointer())
	}
}

func (ptr *QBuffer) CloseDefault() {
	defer qt.Recovering("QBuffer::close")

	if ptr.Pointer() != nil {
		C.QBuffer_CloseDefault(ptr.Pointer())
	}
}

func (ptr *QBuffer) Data() string {
	defer qt.Recovering("QBuffer::data")

	if ptr.Pointer() != nil {
		return C.GoString(C.QBuffer_Data(ptr.Pointer()))
	}
	return ""
}

func (ptr *QBuffer) Open(flags QIODevice__OpenModeFlag) bool {
	defer qt.Recovering("QBuffer::open")

	if ptr.Pointer() != nil {
		return C.QBuffer_Open(ptr.Pointer(), C.int(flags)) != 0
	}
	return false
}

func (ptr *QBuffer) Pos() int64 {
	defer qt.Recovering("QBuffer::pos")

	if ptr.Pointer() != nil {
		return int64(C.QBuffer_Pos(ptr.Pointer()))
	}
	return 0
}

func (ptr *QBuffer) ReadData(data string, len int64) int64 {
	defer qt.Recovering("QBuffer::readData")

	if ptr.Pointer() != nil {
		return int64(C.QBuffer_ReadData(ptr.Pointer(), C.CString(data), C.longlong(len)))
	}
	return 0
}

func (ptr *QBuffer) Seek(pos int64) bool {
	defer qt.Recovering("QBuffer::seek")

	if ptr.Pointer() != nil {
		return C.QBuffer_Seek(ptr.Pointer(), C.longlong(pos)) != 0
	}
	return false
}

func (ptr *QBuffer) SetBuffer(byteArray string) {
	defer qt.Recovering("QBuffer::setBuffer")

	if ptr.Pointer() != nil {
		C.QBuffer_SetBuffer(ptr.Pointer(), C.CString(byteArray))
	}
}

func (ptr *QBuffer) SetData(data string) {
	defer qt.Recovering("QBuffer::setData")

	if ptr.Pointer() != nil {
		C.QBuffer_SetData(ptr.Pointer(), C.CString(data))
	}
}

func (ptr *QBuffer) SetData2(data string, size int) {
	defer qt.Recovering("QBuffer::setData")

	if ptr.Pointer() != nil {
		C.QBuffer_SetData2(ptr.Pointer(), C.CString(data), C.int(size))
	}
}

func (ptr *QBuffer) Size() int64 {
	defer qt.Recovering("QBuffer::size")

	if ptr.Pointer() != nil {
		return int64(C.QBuffer_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QBuffer) WriteData(data string, len int64) int64 {
	defer qt.Recovering("QBuffer::writeData")

	if ptr.Pointer() != nil {
		return int64(C.QBuffer_WriteData(ptr.Pointer(), C.CString(data), C.longlong(len)))
	}
	return 0
}

func (ptr *QBuffer) DestroyQBuffer() {
	defer qt.Recovering("QBuffer::~QBuffer")

	if ptr.Pointer() != nil {
		C.QBuffer_DestroyQBuffer(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QBuffer) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QBuffer::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QBuffer) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QBuffer::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQBufferTimerEvent
func callbackQBufferTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QBuffer::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQBufferFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QBuffer) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QBuffer::timerEvent")

	if ptr.Pointer() != nil {
		C.QBuffer_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QBuffer) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QBuffer::timerEvent")

	if ptr.Pointer() != nil {
		C.QBuffer_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QBuffer) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QBuffer::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QBuffer) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QBuffer::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQBufferChildEvent
func callbackQBufferChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QBuffer::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQBufferFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QBuffer) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QBuffer::childEvent")

	if ptr.Pointer() != nil {
		C.QBuffer_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QBuffer) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QBuffer::childEvent")

	if ptr.Pointer() != nil {
		C.QBuffer_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QBuffer) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QBuffer::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QBuffer) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QBuffer::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQBufferCustomEvent
func callbackQBufferCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QBuffer::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQBufferFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QBuffer) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QBuffer::customEvent")

	if ptr.Pointer() != nil {
		C.QBuffer_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QBuffer) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QBuffer::customEvent")

	if ptr.Pointer() != nil {
		C.QBuffer_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QByteArray struct {
	ptr unsafe.Pointer
}

type QByteArray_ITF interface {
	QByteArray_PTR() *QByteArray
}

func (p *QByteArray) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QByteArray) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQByteArray(ptr QByteArray_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QByteArray_PTR().Pointer()
	}
	return nil
}

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

func newQByteArrayFromPointer(ptr unsafe.Pointer) *QByteArray {
	var n = NewQByteArrayFromPointer(ptr)
	return n
}

func (ptr *QByteArray) QByteArray_PTR() *QByteArray {
	return ptr
}

//QByteArray::Base64Option
type QByteArray__Base64Option int64

const (
	QByteArray__Base64Encoding     = QByteArray__Base64Option(0)
	QByteArray__Base64UrlEncoding  = QByteArray__Base64Option(1)
	QByteArray__KeepTrailingEquals = QByteArray__Base64Option(0)
	QByteArray__OmitTrailingEquals = QByteArray__Base64Option(2)
)

type QByteArrayList struct {
	QList
}

type QByteArrayList_ITF interface {
	QList_ITF
	QByteArrayList_PTR() *QByteArrayList
}

func PointerFromQByteArrayList(ptr QByteArrayList_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QByteArrayList_PTR().Pointer()
	}
	return nil
}

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

func newQByteArrayListFromPointer(ptr unsafe.Pointer) *QByteArrayList {
	var n = NewQByteArrayListFromPointer(ptr)
	return n
}

func (ptr *QByteArrayList) QByteArrayList_PTR() *QByteArrayList {
	return ptr
}

func (ptr *QByteArrayList) Join() string {
	defer qt.Recovering("QByteArrayList::join")

	if ptr.Pointer() != nil {
		return C.GoString(C.QByteArrayList_Join(ptr.Pointer()))
	}
	return ""
}

func (ptr *QByteArrayList) Join3(separator string) string {
	defer qt.Recovering("QByteArrayList::join")

	if ptr.Pointer() != nil {
		return C.GoString(C.QByteArrayList_Join3(ptr.Pointer(), C.CString(separator)))
	}
	return ""
}

func (ptr *QByteArrayList) Join2(separator string) string {
	defer qt.Recovering("QByteArrayList::join")

	if ptr.Pointer() != nil {
		return C.GoString(C.QByteArrayList_Join2(ptr.Pointer(), C.CString(separator)))
	}
	return ""
}

type QByteArrayMatcher struct {
	ptr unsafe.Pointer
}

type QByteArrayMatcher_ITF interface {
	QByteArrayMatcher_PTR() *QByteArrayMatcher
}

func (p *QByteArrayMatcher) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QByteArrayMatcher) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQByteArrayMatcher(ptr QByteArrayMatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QByteArrayMatcher_PTR().Pointer()
	}
	return nil
}

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

func newQByteArrayMatcherFromPointer(ptr unsafe.Pointer) *QByteArrayMatcher {
	var n = NewQByteArrayMatcherFromPointer(ptr)
	return n
}

func (ptr *QByteArrayMatcher) QByteArrayMatcher_PTR() *QByteArrayMatcher {
	return ptr
}

func NewQByteArrayMatcher() *QByteArrayMatcher {
	defer qt.Recovering("QByteArrayMatcher::QByteArrayMatcher")

	return newQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher())
}

func NewQByteArrayMatcher2(pattern string) *QByteArrayMatcher {
	defer qt.Recovering("QByteArrayMatcher::QByteArrayMatcher")

	return newQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher2(C.CString(pattern)))
}

func NewQByteArrayMatcher4(other QByteArrayMatcher_ITF) *QByteArrayMatcher {
	defer qt.Recovering("QByteArrayMatcher::QByteArrayMatcher")

	return newQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher4(PointerFromQByteArrayMatcher(other)))
}

func NewQByteArrayMatcher3(pattern string, length int) *QByteArrayMatcher {
	defer qt.Recovering("QByteArrayMatcher::QByteArrayMatcher")

	return newQByteArrayMatcherFromPointer(C.QByteArrayMatcher_NewQByteArrayMatcher3(C.CString(pattern), C.int(length)))
}

func (ptr *QByteArrayMatcher) IndexIn(ba string, from int) int {
	defer qt.Recovering("QByteArrayMatcher::indexIn")

	if ptr.Pointer() != nil {
		return int(C.QByteArrayMatcher_IndexIn(ptr.Pointer(), C.CString(ba), C.int(from)))
	}
	return 0
}

func (ptr *QByteArrayMatcher) IndexIn2(str string, len int, from int) int {
	defer qt.Recovering("QByteArrayMatcher::indexIn")

	if ptr.Pointer() != nil {
		return int(C.QByteArrayMatcher_IndexIn2(ptr.Pointer(), C.CString(str), C.int(len), C.int(from)))
	}
	return 0
}

func (ptr *QByteArrayMatcher) Pattern() string {
	defer qt.Recovering("QByteArrayMatcher::pattern")

	if ptr.Pointer() != nil {
		return C.GoString(C.QByteArrayMatcher_Pattern(ptr.Pointer()))
	}
	return ""
}

func (ptr *QByteArrayMatcher) SetPattern(pattern string) {
	defer qt.Recovering("QByteArrayMatcher::setPattern")

	if ptr.Pointer() != nil {
		C.QByteArrayMatcher_SetPattern(ptr.Pointer(), C.CString(pattern))
	}
}

func (ptr *QByteArrayMatcher) DestroyQByteArrayMatcher() {
	defer qt.Recovering("QByteArrayMatcher::~QByteArrayMatcher")

	if ptr.Pointer() != nil {
		C.QByteArrayMatcher_DestroyQByteArrayMatcher(ptr.Pointer())
	}
}

type QCache struct {
	ptr unsafe.Pointer
}

type QCache_ITF interface {
	QCache_PTR() *QCache
}

func (p *QCache) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QCache) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQCache(ptr QCache_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCache_PTR().Pointer()
	}
	return nil
}

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

func newQCacheFromPointer(ptr unsafe.Pointer) *QCache {
	var n = NewQCacheFromPointer(ptr)
	return n
}

func (ptr *QCache) QCache_PTR() *QCache {
	return ptr
}

type QChar struct {
	ptr unsafe.Pointer
}

type QChar_ITF interface {
	QChar_PTR() *QChar
}

func (p *QChar) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QChar) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQChar(ptr QChar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QChar_PTR().Pointer()
	}
	return nil
}

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

func newQCharFromPointer(ptr unsafe.Pointer) *QChar {
	var n = NewQCharFromPointer(ptr)
	return n
}

func (ptr *QChar) QChar_PTR() *QChar {
	return ptr
}

//QChar::Category
type QChar__Category int64

const (
	QChar__Mark_NonSpacing          = QChar__Category(0)
	QChar__Mark_SpacingCombining    = QChar__Category(1)
	QChar__Mark_Enclosing           = QChar__Category(2)
	QChar__Number_DecimalDigit      = QChar__Category(3)
	QChar__Number_Letter            = QChar__Category(4)
	QChar__Number_Other             = QChar__Category(5)
	QChar__Separator_Space          = QChar__Category(6)
	QChar__Separator_Line           = QChar__Category(7)
	QChar__Separator_Paragraph      = QChar__Category(8)
	QChar__Other_Control            = QChar__Category(9)
	QChar__Other_Format             = QChar__Category(10)
	QChar__Other_Surrogate          = QChar__Category(11)
	QChar__Other_PrivateUse         = QChar__Category(12)
	QChar__Other_NotAssigned        = QChar__Category(13)
	QChar__Letter_Uppercase         = QChar__Category(14)
	QChar__Letter_Lowercase         = QChar__Category(15)
	QChar__Letter_Titlecase         = QChar__Category(16)
	QChar__Letter_Modifier          = QChar__Category(17)
	QChar__Letter_Other             = QChar__Category(18)
	QChar__Punctuation_Connector    = QChar__Category(19)
	QChar__Punctuation_Dash         = QChar__Category(20)
	QChar__Punctuation_Open         = QChar__Category(21)
	QChar__Punctuation_Close        = QChar__Category(22)
	QChar__Punctuation_InitialQuote = QChar__Category(23)
	QChar__Punctuation_FinalQuote   = QChar__Category(24)
	QChar__Punctuation_Other        = QChar__Category(25)
	QChar__Symbol_Math              = QChar__Category(26)
	QChar__Symbol_Currency          = QChar__Category(27)
	QChar__Symbol_Modifier          = QChar__Category(28)
	QChar__Symbol_Other             = QChar__Category(29)
)

//QChar::Decomposition
type QChar__Decomposition int64

const (
	QChar__NoDecomposition = QChar__Decomposition(0)
	QChar__Canonical       = QChar__Decomposition(1)
	QChar__Font            = QChar__Decomposition(2)
	QChar__NoBreak         = QChar__Decomposition(3)
	QChar__Initial         = QChar__Decomposition(4)
	QChar__Medial          = QChar__Decomposition(5)
	QChar__Final           = QChar__Decomposition(6)
	QChar__Isolated        = QChar__Decomposition(7)
	QChar__Circle          = QChar__Decomposition(8)
	QChar__Super           = QChar__Decomposition(9)
	QChar__Sub             = QChar__Decomposition(10)
	QChar__Vertical        = QChar__Decomposition(11)
	QChar__Wide            = QChar__Decomposition(12)
	QChar__Narrow          = QChar__Decomposition(13)
	QChar__Small           = QChar__Decomposition(14)
	QChar__Square          = QChar__Decomposition(15)
	QChar__Compat          = QChar__Decomposition(16)
	QChar__Fraction        = QChar__Decomposition(17)
)

//QChar::Direction
type QChar__Direction int64

const (
	QChar__DirL   = QChar__Direction(0)
	QChar__DirR   = QChar__Direction(1)
	QChar__DirEN  = QChar__Direction(2)
	QChar__DirES  = QChar__Direction(3)
	QChar__DirET  = QChar__Direction(4)
	QChar__DirAN  = QChar__Direction(5)
	QChar__DirCS  = QChar__Direction(6)
	QChar__DirB   = QChar__Direction(7)
	QChar__DirS   = QChar__Direction(8)
	QChar__DirWS  = QChar__Direction(9)
	QChar__DirON  = QChar__Direction(10)
	QChar__DirLRE = QChar__Direction(11)
	QChar__DirLRO = QChar__Direction(12)
	QChar__DirAL  = QChar__Direction(13)
	QChar__DirRLE = QChar__Direction(14)
	QChar__DirRLO = QChar__Direction(15)
	QChar__DirPDF = QChar__Direction(16)
	QChar__DirNSM = QChar__Direction(17)
	QChar__DirBN  = QChar__Direction(18)
	QChar__DirLRI = QChar__Direction(19)
	QChar__DirRLI = QChar__Direction(20)
	QChar__DirFSI = QChar__Direction(21)
	QChar__DirPDI = QChar__Direction(22)
)

//QChar::JoiningType
type QChar__JoiningType int64

const (
	QChar__Joining_None        = QChar__JoiningType(0)
	QChar__Joining_Causing     = QChar__JoiningType(1)
	QChar__Joining_Dual        = QChar__JoiningType(2)
	QChar__Joining_Right       = QChar__JoiningType(3)
	QChar__Joining_Left        = QChar__JoiningType(4)
	QChar__Joining_Transparent = QChar__JoiningType(5)
)

//QChar::Script
type QChar__Script int64

const (
	QChar__Script_Unknown               = QChar__Script(0)
	QChar__Script_Inherited             = QChar__Script(1)
	QChar__Script_Common                = QChar__Script(2)
	QChar__Script_Latin                 = QChar__Script(3)
	QChar__Script_Greek                 = QChar__Script(4)
	QChar__Script_Cyrillic              = QChar__Script(5)
	QChar__Script_Armenian              = QChar__Script(6)
	QChar__Script_Hebrew                = QChar__Script(7)
	QChar__Script_Arabic                = QChar__Script(8)
	QChar__Script_Syriac                = QChar__Script(9)
	QChar__Script_Thaana                = QChar__Script(10)
	QChar__Script_Devanagari            = QChar__Script(11)
	QChar__Script_Bengali               = QChar__Script(12)
	QChar__Script_Gurmukhi              = QChar__Script(13)
	QChar__Script_Gujarati              = QChar__Script(14)
	QChar__Script_Oriya                 = QChar__Script(15)
	QChar__Script_Tamil                 = QChar__Script(16)
	QChar__Script_Telugu                = QChar__Script(17)
	QChar__Script_Kannada               = QChar__Script(18)
	QChar__Script_Malayalam             = QChar__Script(19)
	QChar__Script_Sinhala               = QChar__Script(20)
	QChar__Script_Thai                  = QChar__Script(21)
	QChar__Script_Lao                   = QChar__Script(22)
	QChar__Script_Tibetan               = QChar__Script(23)
	QChar__Script_Myanmar               = QChar__Script(24)
	QChar__Script_Georgian              = QChar__Script(25)
	QChar__Script_Hangul                = QChar__Script(26)
	QChar__Script_Ethiopic              = QChar__Script(27)
	QChar__Script_Cherokee              = QChar__Script(28)
	QChar__Script_CanadianAboriginal    = QChar__Script(29)
	QChar__Script_Ogham                 = QChar__Script(30)
	QChar__Script_Runic                 = QChar__Script(31)
	QChar__Script_Khmer                 = QChar__Script(32)
	QChar__Script_Mongolian             = QChar__Script(33)
	QChar__Script_Hiragana              = QChar__Script(34)
	QChar__Script_Katakana              = QChar__Script(35)
	QChar__Script_Bopomofo              = QChar__Script(36)
	QChar__Script_Han                   = QChar__Script(37)
	QChar__Script_Yi                    = QChar__Script(38)
	QChar__Script_OldItalic             = QChar__Script(39)
	QChar__Script_Gothic                = QChar__Script(40)
	QChar__Script_Deseret               = QChar__Script(41)
	QChar__Script_Tagalog               = QChar__Script(42)
	QChar__Script_Hanunoo               = QChar__Script(43)
	QChar__Script_Buhid                 = QChar__Script(44)
	QChar__Script_Tagbanwa              = QChar__Script(45)
	QChar__Script_Coptic                = QChar__Script(46)
	QChar__Script_Limbu                 = QChar__Script(47)
	QChar__Script_TaiLe                 = QChar__Script(48)
	QChar__Script_LinearB               = QChar__Script(49)
	QChar__Script_Ugaritic              = QChar__Script(50)
	QChar__Script_Shavian               = QChar__Script(51)
	QChar__Script_Osmanya               = QChar__Script(52)
	QChar__Script_Cypriot               = QChar__Script(53)
	QChar__Script_Braille               = QChar__Script(54)
	QChar__Script_Buginese              = QChar__Script(55)
	QChar__Script_NewTaiLue             = QChar__Script(56)
	QChar__Script_Glagolitic            = QChar__Script(57)
	QChar__Script_Tifinagh              = QChar__Script(58)
	QChar__Script_SylotiNagri           = QChar__Script(59)
	QChar__Script_OldPersian            = QChar__Script(60)
	QChar__Script_Kharoshthi            = QChar__Script(61)
	QChar__Script_Balinese              = QChar__Script(62)
	QChar__Script_Cuneiform             = QChar__Script(63)
	QChar__Script_Phoenician            = QChar__Script(64)
	QChar__Script_PhagsPa               = QChar__Script(65)
	QChar__Script_Nko                   = QChar__Script(66)
	QChar__Script_Sundanese             = QChar__Script(67)
	QChar__Script_Lepcha                = QChar__Script(68)
	QChar__Script_OlChiki               = QChar__Script(69)
	QChar__Script_Vai                   = QChar__Script(70)
	QChar__Script_Saurashtra            = QChar__Script(71)
	QChar__Script_KayahLi               = QChar__Script(72)
	QChar__Script_Rejang                = QChar__Script(73)
	QChar__Script_Lycian                = QChar__Script(74)
	QChar__Script_Carian                = QChar__Script(75)
	QChar__Script_Lydian                = QChar__Script(76)
	QChar__Script_Cham                  = QChar__Script(77)
	QChar__Script_TaiTham               = QChar__Script(78)
	QChar__Script_TaiViet               = QChar__Script(79)
	QChar__Script_Avestan               = QChar__Script(80)
	QChar__Script_EgyptianHieroglyphs   = QChar__Script(81)
	QChar__Script_Samaritan             = QChar__Script(82)
	QChar__Script_Lisu                  = QChar__Script(83)
	QChar__Script_Bamum                 = QChar__Script(84)
	QChar__Script_Javanese              = QChar__Script(85)
	QChar__Script_MeeteiMayek           = QChar__Script(86)
	QChar__Script_ImperialAramaic       = QChar__Script(87)
	QChar__Script_OldSouthArabian       = QChar__Script(88)
	QChar__Script_InscriptionalParthian = QChar__Script(89)
	QChar__Script_InscriptionalPahlavi  = QChar__Script(90)
	QChar__Script_OldTurkic             = QChar__Script(91)
	QChar__Script_Kaithi                = QChar__Script(92)
	QChar__Script_Batak                 = QChar__Script(93)
	QChar__Script_Brahmi                = QChar__Script(94)
	QChar__Script_Mandaic               = QChar__Script(95)
	QChar__Script_Chakma                = QChar__Script(96)
	QChar__Script_MeroiticCursive       = QChar__Script(97)
	QChar__Script_MeroiticHieroglyphs   = QChar__Script(98)
	QChar__Script_Miao                  = QChar__Script(99)
	QChar__Script_Sharada               = QChar__Script(100)
	QChar__Script_SoraSompeng           = QChar__Script(101)
	QChar__Script_Takri                 = QChar__Script(102)
	QChar__Script_CaucasianAlbanian     = QChar__Script(103)
	QChar__Script_BassaVah              = QChar__Script(104)
	QChar__Script_Duployan              = QChar__Script(105)
	QChar__Script_Elbasan               = QChar__Script(106)
	QChar__Script_Grantha               = QChar__Script(107)
	QChar__Script_PahawhHmong           = QChar__Script(108)
	QChar__Script_Khojki                = QChar__Script(109)
	QChar__Script_LinearA               = QChar__Script(110)
	QChar__Script_Mahajani              = QChar__Script(111)
	QChar__Script_Manichaean            = QChar__Script(112)
	QChar__Script_MendeKikakui          = QChar__Script(113)
	QChar__Script_Modi                  = QChar__Script(114)
	QChar__Script_Mro                   = QChar__Script(115)
	QChar__Script_OldNorthArabian       = QChar__Script(116)
	QChar__Script_Nabataean             = QChar__Script(117)
	QChar__Script_Palmyrene             = QChar__Script(118)
	QChar__Script_PauCinHau             = QChar__Script(119)
	QChar__Script_OldPermic             = QChar__Script(120)
	QChar__Script_PsalterPahlavi        = QChar__Script(121)
	QChar__Script_Siddham               = QChar__Script(122)
	QChar__Script_Khudawadi             = QChar__Script(123)
	QChar__Script_Tirhuta               = QChar__Script(124)
	QChar__Script_WarangCiti            = QChar__Script(125)
	QChar__ScriptCount                  = QChar__Script(126)
)

//QChar::SpecialCharacter
type QChar__SpecialCharacter int64

const (
	QChar__Null                       = QChar__SpecialCharacter(0x0000)
	QChar__Tabulation                 = QChar__SpecialCharacter(0x0009)
	QChar__LineFeed                   = QChar__SpecialCharacter(0x000a)
	QChar__CarriageReturn             = QChar__SpecialCharacter(0x000d)
	QChar__Space                      = QChar__SpecialCharacter(0x0020)
	QChar__Nbsp                       = QChar__SpecialCharacter(0x00a0)
	QChar__SoftHyphen                 = QChar__SpecialCharacter(0x00ad)
	QChar__ReplacementCharacter       = QChar__SpecialCharacter(0xfffd)
	QChar__ObjectReplacementCharacter = QChar__SpecialCharacter(0xfffc)
	QChar__ByteOrderMark              = QChar__SpecialCharacter(0xfeff)
	QChar__ByteOrderSwapped           = QChar__SpecialCharacter(0xfffe)
	QChar__ParagraphSeparator         = QChar__SpecialCharacter(0x2029)
	QChar__LineSeparator              = QChar__SpecialCharacter(0x2028)
	QChar__LastValidCodePoint         = QChar__SpecialCharacter(0x10ffff)
)

//QChar::UnicodeVersion
type QChar__UnicodeVersion int64

const (
	QChar__Unicode_Unassigned = QChar__UnicodeVersion(0)
	QChar__Unicode_1_1        = QChar__UnicodeVersion(1)
	QChar__Unicode_2_0        = QChar__UnicodeVersion(2)
	QChar__Unicode_2_1_2      = QChar__UnicodeVersion(3)
	QChar__Unicode_3_0        = QChar__UnicodeVersion(4)
	QChar__Unicode_3_1        = QChar__UnicodeVersion(5)
	QChar__Unicode_3_2        = QChar__UnicodeVersion(6)
	QChar__Unicode_4_0        = QChar__UnicodeVersion(7)
	QChar__Unicode_4_1        = QChar__UnicodeVersion(8)
	QChar__Unicode_5_0        = QChar__UnicodeVersion(9)
	QChar__Unicode_5_1        = QChar__UnicodeVersion(10)
	QChar__Unicode_5_2        = QChar__UnicodeVersion(11)
	QChar__Unicode_6_0        = QChar__UnicodeVersion(12)
	QChar__Unicode_6_1        = QChar__UnicodeVersion(13)
	QChar__Unicode_6_2        = QChar__UnicodeVersion(14)
	QChar__Unicode_6_3        = QChar__UnicodeVersion(15)
	QChar__Unicode_7_0        = QChar__UnicodeVersion(16)
)

func NewQChar() *QChar {
	defer qt.Recovering("QChar::QChar")

	return newQCharFromPointer(C.QChar_NewQChar())
}

func NewQChar8(ch QLatin1Char_ITF) *QChar {
	defer qt.Recovering("QChar::QChar")

	return newQCharFromPointer(C.QChar_NewQChar8(PointerFromQLatin1Char(ch)))
}

func NewQChar7(ch QChar__SpecialCharacter) *QChar {
	defer qt.Recovering("QChar::QChar")

	return newQCharFromPointer(C.QChar_NewQChar7(C.int(ch)))
}

func NewQChar9(ch string) *QChar {
	defer qt.Recovering("QChar::QChar")

	return newQCharFromPointer(C.QChar_NewQChar9(C.CString(ch)))
}

func NewQChar6(code int) *QChar {
	defer qt.Recovering("QChar::QChar")

	return newQCharFromPointer(C.QChar_NewQChar6(C.int(code)))
}

func (ptr *QChar) Category() QChar__Category {
	defer qt.Recovering("QChar::category")

	if ptr.Pointer() != nil {
		return QChar__Category(C.QChar_Category(ptr.Pointer()))
	}
	return 0
}

func QChar_CurrentUnicodeVersion() QChar__UnicodeVersion {
	defer qt.Recovering("QChar::currentUnicodeVersion")

	return QChar__UnicodeVersion(C.QChar_QChar_CurrentUnicodeVersion())
}

func (ptr *QChar) Decomposition() string {
	defer qt.Recovering("QChar::decomposition")

	if ptr.Pointer() != nil {
		return C.GoString(C.QChar_Decomposition(ptr.Pointer()))
	}
	return ""
}

func (ptr *QChar) DecompositionTag() QChar__Decomposition {
	defer qt.Recovering("QChar::decompositionTag")

	if ptr.Pointer() != nil {
		return QChar__Decomposition(C.QChar_DecompositionTag(ptr.Pointer()))
	}
	return 0
}

func (ptr *QChar) DigitValue() int {
	defer qt.Recovering("QChar::digitValue")

	if ptr.Pointer() != nil {
		return int(C.QChar_DigitValue(ptr.Pointer()))
	}
	return 0
}

func (ptr *QChar) Direction() QChar__Direction {
	defer qt.Recovering("QChar::direction")

	if ptr.Pointer() != nil {
		return QChar__Direction(C.QChar_Direction(ptr.Pointer()))
	}
	return 0
}

func (ptr *QChar) HasMirrored() bool {
	defer qt.Recovering("QChar::hasMirrored")

	if ptr.Pointer() != nil {
		return C.QChar_HasMirrored(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsDigit() bool {
	defer qt.Recovering("QChar::isDigit")

	if ptr.Pointer() != nil {
		return C.QChar_IsDigit(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsHighSurrogate() bool {
	defer qt.Recovering("QChar::isHighSurrogate")

	if ptr.Pointer() != nil {
		return C.QChar_IsHighSurrogate(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsLetter() bool {
	defer qt.Recovering("QChar::isLetter")

	if ptr.Pointer() != nil {
		return C.QChar_IsLetter(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsLetterOrNumber() bool {
	defer qt.Recovering("QChar::isLetterOrNumber")

	if ptr.Pointer() != nil {
		return C.QChar_IsLetterOrNumber(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsLower() bool {
	defer qt.Recovering("QChar::isLower")

	if ptr.Pointer() != nil {
		return C.QChar_IsLower(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsLowSurrogate() bool {
	defer qt.Recovering("QChar::isLowSurrogate")

	if ptr.Pointer() != nil {
		return C.QChar_IsLowSurrogate(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsMark() bool {
	defer qt.Recovering("QChar::isMark")

	if ptr.Pointer() != nil {
		return C.QChar_IsMark(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsNonCharacter() bool {
	defer qt.Recovering("QChar::isNonCharacter")

	if ptr.Pointer() != nil {
		return C.QChar_IsNonCharacter(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsNull() bool {
	defer qt.Recovering("QChar::isNull")

	if ptr.Pointer() != nil {
		return C.QChar_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsNumber() bool {
	defer qt.Recovering("QChar::isNumber")

	if ptr.Pointer() != nil {
		return C.QChar_IsNumber(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsPrint() bool {
	defer qt.Recovering("QChar::isPrint")

	if ptr.Pointer() != nil {
		return C.QChar_IsPrint(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsPunct() bool {
	defer qt.Recovering("QChar::isPunct")

	if ptr.Pointer() != nil {
		return C.QChar_IsPunct(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsSpace() bool {
	defer qt.Recovering("QChar::isSpace")

	if ptr.Pointer() != nil {
		return C.QChar_IsSpace(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsSurrogate() bool {
	defer qt.Recovering("QChar::isSurrogate")

	if ptr.Pointer() != nil {
		return C.QChar_IsSurrogate(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsSymbol() bool {
	defer qt.Recovering("QChar::isSymbol")

	if ptr.Pointer() != nil {
		return C.QChar_IsSymbol(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsTitleCase() bool {
	defer qt.Recovering("QChar::isTitleCase")

	if ptr.Pointer() != nil {
		return C.QChar_IsTitleCase(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) IsUpper() bool {
	defer qt.Recovering("QChar::isUpper")

	if ptr.Pointer() != nil {
		return C.QChar_IsUpper(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChar) JoiningType() QChar__JoiningType {
	defer qt.Recovering("QChar::joiningType")

	if ptr.Pointer() != nil {
		return QChar__JoiningType(C.QChar_JoiningType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QChar) Script() QChar__Script {
	defer qt.Recovering("QChar::script")

	if ptr.Pointer() != nil {
		return QChar__Script(C.QChar_Script(ptr.Pointer()))
	}
	return 0
}

func (ptr *QChar) UnicodeVersion() QChar__UnicodeVersion {
	defer qt.Recovering("QChar::unicodeVersion")

	if ptr.Pointer() != nil {
		return QChar__UnicodeVersion(C.QChar_UnicodeVersion(ptr.Pointer()))
	}
	return 0
}

type QChildEvent struct {
	QEvent
}

type QChildEvent_ITF interface {
	QEvent_ITF
	QChildEvent_PTR() *QChildEvent
}

func PointerFromQChildEvent(ptr QChildEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QChildEvent_PTR().Pointer()
	}
	return nil
}

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

func newQChildEventFromPointer(ptr unsafe.Pointer) *QChildEvent {
	var n = NewQChildEventFromPointer(ptr)
	return n
}

func (ptr *QChildEvent) QChildEvent_PTR() *QChildEvent {
	return ptr
}

func NewQChildEvent(ty QEvent__Type, child QObject_ITF) *QChildEvent {
	defer qt.Recovering("QChildEvent::QChildEvent")

	return newQChildEventFromPointer(C.QChildEvent_NewQChildEvent(C.int(ty), PointerFromQObject(child)))
}

func (ptr *QChildEvent) Added() bool {
	defer qt.Recovering("QChildEvent::added")

	if ptr.Pointer() != nil {
		return C.QChildEvent_Added(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChildEvent) Child() *QObject {
	defer qt.Recovering("QChildEvent::child")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QChildEvent_Child(ptr.Pointer()))
	}
	return nil
}

func (ptr *QChildEvent) Polished() bool {
	defer qt.Recovering("QChildEvent::polished")

	if ptr.Pointer() != nil {
		return C.QChildEvent_Polished(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QChildEvent) Removed() bool {
	defer qt.Recovering("QChildEvent::removed")

	if ptr.Pointer() != nil {
		return C.QChildEvent_Removed(ptr.Pointer()) != 0
	}
	return false
}

type QCollator struct {
	ptr unsafe.Pointer
}

type QCollator_ITF interface {
	QCollator_PTR() *QCollator
}

func (p *QCollator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QCollator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQCollator(ptr QCollator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCollator_PTR().Pointer()
	}
	return nil
}

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

func newQCollatorFromPointer(ptr unsafe.Pointer) *QCollator {
	var n = NewQCollatorFromPointer(ptr)
	return n
}

func (ptr *QCollator) QCollator_PTR() *QCollator {
	return ptr
}

func (ptr *QCollator) CaseSensitivity() Qt__CaseSensitivity {
	defer qt.Recovering("QCollator::caseSensitivity")

	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QCollator_CaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCollator) IgnorePunctuation() bool {
	defer qt.Recovering("QCollator::ignorePunctuation")

	if ptr.Pointer() != nil {
		return C.QCollator_IgnorePunctuation(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QCollator) NumericMode() bool {
	defer qt.Recovering("QCollator::numericMode")

	if ptr.Pointer() != nil {
		return C.QCollator_NumericMode(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QCollator) SetCaseSensitivity(sensitivity Qt__CaseSensitivity) {
	defer qt.Recovering("QCollator::setCaseSensitivity")

	if ptr.Pointer() != nil {
		C.QCollator_SetCaseSensitivity(ptr.Pointer(), C.int(sensitivity))
	}
}

func (ptr *QCollator) SetIgnorePunctuation(on bool) {
	defer qt.Recovering("QCollator::setIgnorePunctuation")

	if ptr.Pointer() != nil {
		C.QCollator_SetIgnorePunctuation(ptr.Pointer(), C.int(qt.GoBoolToInt(on)))
	}
}

func (ptr *QCollator) SetNumericMode(on bool) {
	defer qt.Recovering("QCollator::setNumericMode")

	if ptr.Pointer() != nil {
		C.QCollator_SetNumericMode(ptr.Pointer(), C.int(qt.GoBoolToInt(on)))
	}
}

func NewQCollator3(other QCollator_ITF) *QCollator {
	defer qt.Recovering("QCollator::QCollator")

	return newQCollatorFromPointer(C.QCollator_NewQCollator3(PointerFromQCollator(other)))
}

func NewQCollator2(other QCollator_ITF) *QCollator {
	defer qt.Recovering("QCollator::QCollator")

	return newQCollatorFromPointer(C.QCollator_NewQCollator2(PointerFromQCollator(other)))
}

func NewQCollator(locale QLocale_ITF) *QCollator {
	defer qt.Recovering("QCollator::QCollator")

	return newQCollatorFromPointer(C.QCollator_NewQCollator(PointerFromQLocale(locale)))
}

func (ptr *QCollator) Locale() *QLocale {
	defer qt.Recovering("QCollator::locale")

	if ptr.Pointer() != nil {
		return NewQLocaleFromPointer(C.QCollator_Locale(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCollator) SetLocale(locale QLocale_ITF) {
	defer qt.Recovering("QCollator::setLocale")

	if ptr.Pointer() != nil {
		C.QCollator_SetLocale(ptr.Pointer(), PointerFromQLocale(locale))
	}
}

func (ptr *QCollator) Swap(other QCollator_ITF) {
	defer qt.Recovering("QCollator::swap")

	if ptr.Pointer() != nil {
		C.QCollator_Swap(ptr.Pointer(), PointerFromQCollator(other))
	}
}

func (ptr *QCollator) DestroyQCollator() {
	defer qt.Recovering("QCollator::~QCollator")

	if ptr.Pointer() != nil {
		C.QCollator_DestroyQCollator(ptr.Pointer())
	}
}

func (ptr *QCollator) Compare3(s1 QChar_ITF, len1 int, s2 QChar_ITF, len2 int) int {
	defer qt.Recovering("QCollator::compare")

	if ptr.Pointer() != nil {
		return int(C.QCollator_Compare3(ptr.Pointer(), PointerFromQChar(s1), C.int(len1), PointerFromQChar(s2), C.int(len2)))
	}
	return 0
}

func (ptr *QCollator) Compare(s1 string, s2 string) int {
	defer qt.Recovering("QCollator::compare")

	if ptr.Pointer() != nil {
		return int(C.QCollator_Compare(ptr.Pointer(), C.CString(s1), C.CString(s2)))
	}
	return 0
}

func (ptr *QCollator) Compare2(s1 QStringRef_ITF, s2 QStringRef_ITF) int {
	defer qt.Recovering("QCollator::compare")

	if ptr.Pointer() != nil {
		return int(C.QCollator_Compare2(ptr.Pointer(), PointerFromQStringRef(s1), PointerFromQStringRef(s2)))
	}
	return 0
}

func (ptr *QCollator) SortKey(stri string) *QCollatorSortKey {
	defer qt.Recovering("QCollator::sortKey")

	if ptr.Pointer() != nil {
		return NewQCollatorSortKeyFromPointer(C.QCollator_SortKey(ptr.Pointer(), C.CString(stri)))
	}
	return nil
}

type QCollatorSortKey struct {
	ptr unsafe.Pointer
}

type QCollatorSortKey_ITF interface {
	QCollatorSortKey_PTR() *QCollatorSortKey
}

func (p *QCollatorSortKey) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QCollatorSortKey) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQCollatorSortKey(ptr QCollatorSortKey_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCollatorSortKey_PTR().Pointer()
	}
	return nil
}

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

func newQCollatorSortKeyFromPointer(ptr unsafe.Pointer) *QCollatorSortKey {
	var n = NewQCollatorSortKeyFromPointer(ptr)
	return n
}

func (ptr *QCollatorSortKey) QCollatorSortKey_PTR() *QCollatorSortKey {
	return ptr
}

func NewQCollatorSortKey(other QCollatorSortKey_ITF) *QCollatorSortKey {
	defer qt.Recovering("QCollatorSortKey::QCollatorSortKey")

	return newQCollatorSortKeyFromPointer(C.QCollatorSortKey_NewQCollatorSortKey(PointerFromQCollatorSortKey(other)))
}

func (ptr *QCollatorSortKey) Swap(other QCollatorSortKey_ITF) {
	defer qt.Recovering("QCollatorSortKey::swap")

	if ptr.Pointer() != nil {
		C.QCollatorSortKey_Swap(ptr.Pointer(), PointerFromQCollatorSortKey(other))
	}
}

func (ptr *QCollatorSortKey) DestroyQCollatorSortKey() {
	defer qt.Recovering("QCollatorSortKey::~QCollatorSortKey")

	if ptr.Pointer() != nil {
		C.QCollatorSortKey_DestroyQCollatorSortKey(ptr.Pointer())
	}
}

func (ptr *QCollatorSortKey) Compare(otherKey QCollatorSortKey_ITF) int {
	defer qt.Recovering("QCollatorSortKey::compare")

	if ptr.Pointer() != nil {
		return int(C.QCollatorSortKey_Compare(ptr.Pointer(), PointerFromQCollatorSortKey(otherKey)))
	}
	return 0
}

type QCommandLineOption struct {
	ptr unsafe.Pointer
}

type QCommandLineOption_ITF interface {
	QCommandLineOption_PTR() *QCommandLineOption
}

func (p *QCommandLineOption) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QCommandLineOption) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQCommandLineOption(ptr QCommandLineOption_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCommandLineOption_PTR().Pointer()
	}
	return nil
}

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

func newQCommandLineOptionFromPointer(ptr unsafe.Pointer) *QCommandLineOption {
	var n = NewQCommandLineOptionFromPointer(ptr)
	return n
}

func (ptr *QCommandLineOption) QCommandLineOption_PTR() *QCommandLineOption {
	return ptr
}

func NewQCommandLineOption5(other QCommandLineOption_ITF) *QCommandLineOption {
	defer qt.Recovering("QCommandLineOption::QCommandLineOption")

	return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption5(PointerFromQCommandLineOption(other)))
}

func NewQCommandLineOption(name string) *QCommandLineOption {
	defer qt.Recovering("QCommandLineOption::QCommandLineOption")

	return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption(C.CString(name)))
}

func NewQCommandLineOption3(name string, description string, valueName string, defaultValue string) *QCommandLineOption {
	defer qt.Recovering("QCommandLineOption::QCommandLineOption")

	return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption3(C.CString(name), C.CString(description), C.CString(valueName), C.CString(defaultValue)))
}

func NewQCommandLineOption2(names []string) *QCommandLineOption {
	defer qt.Recovering("QCommandLineOption::QCommandLineOption")

	return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption2(C.CString(strings.Join(names, "|"))))
}

func NewQCommandLineOption4(names []string, description string, valueName string, defaultValue string) *QCommandLineOption {
	defer qt.Recovering("QCommandLineOption::QCommandLineOption")

	return newQCommandLineOptionFromPointer(C.QCommandLineOption_NewQCommandLineOption4(C.CString(strings.Join(names, "|")), C.CString(description), C.CString(valueName), C.CString(defaultValue)))
}

func (ptr *QCommandLineOption) DefaultValues() []string {
	defer qt.Recovering("QCommandLineOption::defaultValues")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QCommandLineOption_DefaultValues(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QCommandLineOption) Description() string {
	defer qt.Recovering("QCommandLineOption::description")

	if ptr.Pointer() != nil {
		return C.GoString(C.QCommandLineOption_Description(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineOption) Names() []string {
	defer qt.Recovering("QCommandLineOption::names")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QCommandLineOption_Names(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QCommandLineOption) SetDefaultValue(defaultValue string) {
	defer qt.Recovering("QCommandLineOption::setDefaultValue")

	if ptr.Pointer() != nil {
		C.QCommandLineOption_SetDefaultValue(ptr.Pointer(), C.CString(defaultValue))
	}
}

func (ptr *QCommandLineOption) SetDefaultValues(defaultValues []string) {
	defer qt.Recovering("QCommandLineOption::setDefaultValues")

	if ptr.Pointer() != nil {
		C.QCommandLineOption_SetDefaultValues(ptr.Pointer(), C.CString(strings.Join(defaultValues, "|")))
	}
}

func (ptr *QCommandLineOption) SetDescription(description string) {
	defer qt.Recovering("QCommandLineOption::setDescription")

	if ptr.Pointer() != nil {
		C.QCommandLineOption_SetDescription(ptr.Pointer(), C.CString(description))
	}
}

func (ptr *QCommandLineOption) SetValueName(valueName string) {
	defer qt.Recovering("QCommandLineOption::setValueName")

	if ptr.Pointer() != nil {
		C.QCommandLineOption_SetValueName(ptr.Pointer(), C.CString(valueName))
	}
}

func (ptr *QCommandLineOption) Swap(other QCommandLineOption_ITF) {
	defer qt.Recovering("QCommandLineOption::swap")

	if ptr.Pointer() != nil {
		C.QCommandLineOption_Swap(ptr.Pointer(), PointerFromQCommandLineOption(other))
	}
}

func (ptr *QCommandLineOption) ValueName() string {
	defer qt.Recovering("QCommandLineOption::valueName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QCommandLineOption_ValueName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineOption) DestroyQCommandLineOption() {
	defer qt.Recovering("QCommandLineOption::~QCommandLineOption")

	if ptr.Pointer() != nil {
		C.QCommandLineOption_DestroyQCommandLineOption(ptr.Pointer())
	}
}

type QCommandLineParser struct {
	ptr unsafe.Pointer
}

type QCommandLineParser_ITF interface {
	QCommandLineParser_PTR() *QCommandLineParser
}

func (p *QCommandLineParser) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QCommandLineParser) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQCommandLineParser(ptr QCommandLineParser_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCommandLineParser_PTR().Pointer()
	}
	return nil
}

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

func newQCommandLineParserFromPointer(ptr unsafe.Pointer) *QCommandLineParser {
	var n = NewQCommandLineParserFromPointer(ptr)
	return n
}

func (ptr *QCommandLineParser) QCommandLineParser_PTR() *QCommandLineParser {
	return ptr
}

//QCommandLineParser::SingleDashWordOptionMode
type QCommandLineParser__SingleDashWordOptionMode int64

const (
	QCommandLineParser__ParseAsCompactedShortOptions = QCommandLineParser__SingleDashWordOptionMode(0)
	QCommandLineParser__ParseAsLongOptions           = QCommandLineParser__SingleDashWordOptionMode(1)
)

func NewQCommandLineParser() *QCommandLineParser {
	defer qt.Recovering("QCommandLineParser::QCommandLineParser")

	return newQCommandLineParserFromPointer(C.QCommandLineParser_NewQCommandLineParser())
}

func (ptr *QCommandLineParser) AddHelpOption() *QCommandLineOption {
	defer qt.Recovering("QCommandLineParser::addHelpOption")

	if ptr.Pointer() != nil {
		return NewQCommandLineOptionFromPointer(C.QCommandLineParser_AddHelpOption(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCommandLineParser) AddOption(option QCommandLineOption_ITF) bool {
	defer qt.Recovering("QCommandLineParser::addOption")

	if ptr.Pointer() != nil {
		return C.QCommandLineParser_AddOption(ptr.Pointer(), PointerFromQCommandLineOption(option)) != 0
	}
	return false
}

func (ptr *QCommandLineParser) AddPositionalArgument(name string, description string, syntax string) {
	defer qt.Recovering("QCommandLineParser::addPositionalArgument")

	if ptr.Pointer() != nil {
		C.QCommandLineParser_AddPositionalArgument(ptr.Pointer(), C.CString(name), C.CString(description), C.CString(syntax))
	}
}

func (ptr *QCommandLineParser) AddVersionOption() *QCommandLineOption {
	defer qt.Recovering("QCommandLineParser::addVersionOption")

	if ptr.Pointer() != nil {
		return NewQCommandLineOptionFromPointer(C.QCommandLineParser_AddVersionOption(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCommandLineParser) ApplicationDescription() string {
	defer qt.Recovering("QCommandLineParser::applicationDescription")

	if ptr.Pointer() != nil {
		return C.GoString(C.QCommandLineParser_ApplicationDescription(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineParser) ClearPositionalArguments() {
	defer qt.Recovering("QCommandLineParser::clearPositionalArguments")

	if ptr.Pointer() != nil {
		C.QCommandLineParser_ClearPositionalArguments(ptr.Pointer())
	}
}

func (ptr *QCommandLineParser) ErrorText() string {
	defer qt.Recovering("QCommandLineParser::errorText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QCommandLineParser_ErrorText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineParser) HelpText() string {
	defer qt.Recovering("QCommandLineParser::helpText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QCommandLineParser_HelpText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCommandLineParser) IsSet2(option QCommandLineOption_ITF) bool {
	defer qt.Recovering("QCommandLineParser::isSet")

	if ptr.Pointer() != nil {
		return C.QCommandLineParser_IsSet2(ptr.Pointer(), PointerFromQCommandLineOption(option)) != 0
	}
	return false
}

func (ptr *QCommandLineParser) IsSet(name string) bool {
	defer qt.Recovering("QCommandLineParser::isSet")

	if ptr.Pointer() != nil {
		return C.QCommandLineParser_IsSet(ptr.Pointer(), C.CString(name)) != 0
	}
	return false
}

func (ptr *QCommandLineParser) OptionNames() []string {
	defer qt.Recovering("QCommandLineParser::optionNames")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QCommandLineParser_OptionNames(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) Parse(arguments []string) bool {
	defer qt.Recovering("QCommandLineParser::parse")

	if ptr.Pointer() != nil {
		return C.QCommandLineParser_Parse(ptr.Pointer(), C.CString(strings.Join(arguments, "|"))) != 0
	}
	return false
}

func (ptr *QCommandLineParser) PositionalArguments() []string {
	defer qt.Recovering("QCommandLineParser::positionalArguments")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QCommandLineParser_PositionalArguments(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) Process2(app QCoreApplication_ITF) {
	defer qt.Recovering("QCommandLineParser::process")

	if ptr.Pointer() != nil {
		C.QCommandLineParser_Process2(ptr.Pointer(), PointerFromQCoreApplication(app))
	}
}

func (ptr *QCommandLineParser) Process(arguments []string) {
	defer qt.Recovering("QCommandLineParser::process")

	if ptr.Pointer() != nil {
		C.QCommandLineParser_Process(ptr.Pointer(), C.CString(strings.Join(arguments, "|")))
	}
}

func (ptr *QCommandLineParser) SetApplicationDescription(description string) {
	defer qt.Recovering("QCommandLineParser::setApplicationDescription")

	if ptr.Pointer() != nil {
		C.QCommandLineParser_SetApplicationDescription(ptr.Pointer(), C.CString(description))
	}
}

func (ptr *QCommandLineParser) SetSingleDashWordOptionMode(singleDashWordOptionMode QCommandLineParser__SingleDashWordOptionMode) {
	defer qt.Recovering("QCommandLineParser::setSingleDashWordOptionMode")

	if ptr.Pointer() != nil {
		C.QCommandLineParser_SetSingleDashWordOptionMode(ptr.Pointer(), C.int(singleDashWordOptionMode))
	}
}

func (ptr *QCommandLineParser) ShowHelp(exitCode int) {
	defer qt.Recovering("QCommandLineParser::showHelp")

	if ptr.Pointer() != nil {
		C.QCommandLineParser_ShowHelp(ptr.Pointer(), C.int(exitCode))
	}
}

func (ptr *QCommandLineParser) ShowVersion() {
	defer qt.Recovering("QCommandLineParser::showVersion")

	if ptr.Pointer() != nil {
		C.QCommandLineParser_ShowVersion(ptr.Pointer())
	}
}

func (ptr *QCommandLineParser) UnknownOptionNames() []string {
	defer qt.Recovering("QCommandLineParser::unknownOptionNames")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QCommandLineParser_UnknownOptionNames(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) Value2(option QCommandLineOption_ITF) string {
	defer qt.Recovering("QCommandLineParser::value")

	if ptr.Pointer() != nil {
		return C.GoString(C.QCommandLineParser_Value2(ptr.Pointer(), PointerFromQCommandLineOption(option)))
	}
	return ""
}

func (ptr *QCommandLineParser) Value(optionName string) string {
	defer qt.Recovering("QCommandLineParser::value")

	if ptr.Pointer() != nil {
		return C.GoString(C.QCommandLineParser_Value(ptr.Pointer(), C.CString(optionName)))
	}
	return ""
}

func (ptr *QCommandLineParser) Values2(option QCommandLineOption_ITF) []string {
	defer qt.Recovering("QCommandLineParser::values")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QCommandLineParser_Values2(ptr.Pointer(), PointerFromQCommandLineOption(option))), "|")
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) Values(optionName string) []string {
	defer qt.Recovering("QCommandLineParser::values")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QCommandLineParser_Values(ptr.Pointer(), C.CString(optionName))), "|")
	}
	return make([]string, 0)
}

func (ptr *QCommandLineParser) DestroyQCommandLineParser() {
	defer qt.Recovering("QCommandLineParser::~QCommandLineParser")

	if ptr.Pointer() != nil {
		C.QCommandLineParser_DestroyQCommandLineParser(ptr.Pointer())
	}
}

type QContiguousCache struct {
	ptr unsafe.Pointer
}

type QContiguousCache_ITF interface {
	QContiguousCache_PTR() *QContiguousCache
}

func (p *QContiguousCache) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QContiguousCache) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQContiguousCache(ptr QContiguousCache_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QContiguousCache_PTR().Pointer()
	}
	return nil
}

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

func newQContiguousCacheFromPointer(ptr unsafe.Pointer) *QContiguousCache {
	var n = NewQContiguousCacheFromPointer(ptr)
	return n
}

func (ptr *QContiguousCache) QContiguousCache_PTR() *QContiguousCache {
	return ptr
}

type QCoreApplication struct {
	QObject
}

type QCoreApplication_ITF interface {
	QObject_ITF
	QCoreApplication_PTR() *QCoreApplication
}

func PointerFromQCoreApplication(ptr QCoreApplication_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCoreApplication_PTR().Pointer()
	}
	return nil
}

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

func newQCoreApplicationFromPointer(ptr unsafe.Pointer) *QCoreApplication {
	var n = NewQCoreApplicationFromPointer(ptr)
	for len(n.ObjectName()) < len("QCoreApplication_") {
		n.SetObjectName("QCoreApplication_" + qt.Identifier())
	}
	return n
}

func (ptr *QCoreApplication) QCoreApplication_PTR() *QCoreApplication {
	return ptr
}

func QCoreApplication_ApplicationName() string {
	defer qt.Recovering("QCoreApplication::applicationName")

	return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationName())
}

func QCoreApplication_ApplicationVersion() string {
	defer qt.Recovering("QCoreApplication::applicationVersion")

	return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationVersion())
}

func QCoreApplication_OrganizationDomain() string {
	defer qt.Recovering("QCoreApplication::organizationDomain")

	return C.GoString(C.QCoreApplication_QCoreApplication_OrganizationDomain())
}

func QCoreApplication_OrganizationName() string {
	defer qt.Recovering("QCoreApplication::organizationName")

	return C.GoString(C.QCoreApplication_QCoreApplication_OrganizationName())
}

func QCoreApplication_SetApplicationName(application string) {
	defer qt.Recovering("QCoreApplication::setApplicationName")

	C.QCoreApplication_QCoreApplication_SetApplicationName(C.CString(application))
}

func QCoreApplication_SetApplicationVersion(version string) {
	defer qt.Recovering("QCoreApplication::setApplicationVersion")

	C.QCoreApplication_QCoreApplication_SetApplicationVersion(C.CString(version))
}

func QCoreApplication_SetOrganizationDomain(orgDomain string) {
	defer qt.Recovering("QCoreApplication::setOrganizationDomain")

	C.QCoreApplication_QCoreApplication_SetOrganizationDomain(C.CString(orgDomain))
}

func QCoreApplication_SetOrganizationName(orgName string) {
	defer qt.Recovering("QCoreApplication::setOrganizationName")

	C.QCoreApplication_QCoreApplication_SetOrganizationName(C.CString(orgName))
}

func NewQCoreApplication(argc int, argv []string) *QCoreApplication {
	defer qt.Recovering("QCoreApplication::QCoreApplication")

	return newQCoreApplicationFromPointer(C.QCoreApplication_NewQCoreApplication(C.int(argc), C.CString(strings.Join(argv, "|"))))
}

func (ptr *QCoreApplication) ConnectAboutToQuit(f func()) {
	defer qt.Recovering("connect QCoreApplication::aboutToQuit")

	if ptr.Pointer() != nil {
		C.QCoreApplication_ConnectAboutToQuit(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "aboutToQuit", f)
	}
}

func (ptr *QCoreApplication) DisconnectAboutToQuit() {
	defer qt.Recovering("disconnect QCoreApplication::aboutToQuit")

	if ptr.Pointer() != nil {
		C.QCoreApplication_DisconnectAboutToQuit(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "aboutToQuit")
	}
}

//export callbackQCoreApplicationAboutToQuit
func callbackQCoreApplicationAboutToQuit(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QCoreApplication::aboutToQuit")

	if signal := qt.GetSignal(C.GoString(ptrName), "aboutToQuit"); signal != nil {
		signal.(func())()
	}

}

func QCoreApplication_AddLibraryPath(path string) {
	defer qt.Recovering("QCoreApplication::addLibraryPath")

	C.QCoreApplication_QCoreApplication_AddLibraryPath(C.CString(path))
}

func QCoreApplication_ApplicationDirPath() string {
	defer qt.Recovering("QCoreApplication::applicationDirPath")

	return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationDirPath())
}

func QCoreApplication_ApplicationFilePath() string {
	defer qt.Recovering("QCoreApplication::applicationFilePath")

	return C.GoString(C.QCoreApplication_QCoreApplication_ApplicationFilePath())
}

func QCoreApplication_ApplicationPid() int64 {
	defer qt.Recovering("QCoreApplication::applicationPid")

	return int64(C.QCoreApplication_QCoreApplication_ApplicationPid())
}

func QCoreApplication_Arguments() []string {
	defer qt.Recovering("QCoreApplication::arguments")

	return strings.Split(C.GoString(C.QCoreApplication_QCoreApplication_Arguments()), "|")
}

func QCoreApplication_ClosingDown() bool {
	defer qt.Recovering("QCoreApplication::closingDown")

	return C.QCoreApplication_QCoreApplication_ClosingDown() != 0
}

func (ptr *QCoreApplication) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QCoreApplication::event")

	if ptr.Pointer() != nil {
		return C.QCoreApplication_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func QCoreApplication_EventDispatcher() *QAbstractEventDispatcher {
	defer qt.Recovering("QCoreApplication::eventDispatcher")

	return NewQAbstractEventDispatcherFromPointer(C.QCoreApplication_QCoreApplication_EventDispatcher())
}

func QCoreApplication_Exec() int {
	defer qt.Recovering("QCoreApplication::exec")

	return int(C.QCoreApplication_QCoreApplication_Exec())
}

func QCoreApplication_Exit(returnCode int) {
	defer qt.Recovering("QCoreApplication::exit")

	C.QCoreApplication_QCoreApplication_Exit(C.int(returnCode))
}

func QCoreApplication_Flush() {
	defer qt.Recovering("QCoreApplication::flush")

	C.QCoreApplication_QCoreApplication_Flush()
}

func (ptr *QCoreApplication) InstallNativeEventFilter(filterObj QAbstractNativeEventFilter_ITF) {
	defer qt.Recovering("QCoreApplication::installNativeEventFilter")

	if ptr.Pointer() != nil {
		C.QCoreApplication_InstallNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filterObj))
	}
}

func QCoreApplication_InstallTranslator(translationFile QTranslator_ITF) bool {
	defer qt.Recovering("QCoreApplication::installTranslator")

	return C.QCoreApplication_QCoreApplication_InstallTranslator(PointerFromQTranslator(translationFile)) != 0
}

func QCoreApplication_Instance() *QCoreApplication {
	defer qt.Recovering("QCoreApplication::instance")

	return NewQCoreApplicationFromPointer(C.QCoreApplication_QCoreApplication_Instance())
}

func QCoreApplication_IsQuitLockEnabled() bool {
	defer qt.Recovering("QCoreApplication::isQuitLockEnabled")

	return C.QCoreApplication_QCoreApplication_IsQuitLockEnabled() != 0
}

func QCoreApplication_IsSetuidAllowed() bool {
	defer qt.Recovering("QCoreApplication::isSetuidAllowed")

	return C.QCoreApplication_QCoreApplication_IsSetuidAllowed() != 0
}

func QCoreApplication_LibraryPaths() []string {
	defer qt.Recovering("QCoreApplication::libraryPaths")

	return strings.Split(C.GoString(C.QCoreApplication_QCoreApplication_LibraryPaths()), "|")
}

func (ptr *QCoreApplication) Notify(receiver QObject_ITF, event QEvent_ITF) bool {
	defer qt.Recovering("QCoreApplication::notify")

	if ptr.Pointer() != nil {
		return C.QCoreApplication_Notify(ptr.Pointer(), PointerFromQObject(receiver), PointerFromQEvent(event)) != 0
	}
	return false
}

func QCoreApplication_PostEvent(receiver QObject_ITF, event QEvent_ITF, priority int) {
	defer qt.Recovering("QCoreApplication::postEvent")

	C.QCoreApplication_QCoreApplication_PostEvent(PointerFromQObject(receiver), PointerFromQEvent(event), C.int(priority))
}

func QCoreApplication_ProcessEvents(flags QEventLoop__ProcessEventsFlag) {
	defer qt.Recovering("QCoreApplication::processEvents")

	C.QCoreApplication_QCoreApplication_ProcessEvents(C.int(flags))
}

func QCoreApplication_ProcessEvents2(flags QEventLoop__ProcessEventsFlag, maxtime int) {
	defer qt.Recovering("QCoreApplication::processEvents")

	C.QCoreApplication_QCoreApplication_ProcessEvents2(C.int(flags), C.int(maxtime))
}

func QCoreApplication_Quit() {
	defer qt.Recovering("QCoreApplication::quit")

	C.QCoreApplication_QCoreApplication_Quit()
}

func QCoreApplication_RemoveLibraryPath(path string) {
	defer qt.Recovering("QCoreApplication::removeLibraryPath")

	C.QCoreApplication_QCoreApplication_RemoveLibraryPath(C.CString(path))
}

func (ptr *QCoreApplication) RemoveNativeEventFilter(filterObject QAbstractNativeEventFilter_ITF) {
	defer qt.Recovering("QCoreApplication::removeNativeEventFilter")

	if ptr.Pointer() != nil {
		C.QCoreApplication_RemoveNativeEventFilter(ptr.Pointer(), PointerFromQAbstractNativeEventFilter(filterObject))
	}
}

func QCoreApplication_RemovePostedEvents(receiver QObject_ITF, eventType int) {
	defer qt.Recovering("QCoreApplication::removePostedEvents")

	C.QCoreApplication_QCoreApplication_RemovePostedEvents(PointerFromQObject(receiver), C.int(eventType))
}

func QCoreApplication_RemoveTranslator(translationFile QTranslator_ITF) bool {
	defer qt.Recovering("QCoreApplication::removeTranslator")

	return C.QCoreApplication_QCoreApplication_RemoveTranslator(PointerFromQTranslator(translationFile)) != 0
}

func QCoreApplication_SendEvent(receiver QObject_ITF, event QEvent_ITF) bool {
	defer qt.Recovering("QCoreApplication::sendEvent")

	return C.QCoreApplication_QCoreApplication_SendEvent(PointerFromQObject(receiver), PointerFromQEvent(event)) != 0
}

func QCoreApplication_SendPostedEvents(receiver QObject_ITF, event_type int) {
	defer qt.Recovering("QCoreApplication::sendPostedEvents")

	C.QCoreApplication_QCoreApplication_SendPostedEvents(PointerFromQObject(receiver), C.int(event_type))
}

func QCoreApplication_SetAttribute(attribute Qt__ApplicationAttribute, on bool) {
	defer qt.Recovering("QCoreApplication::setAttribute")

	C.QCoreApplication_QCoreApplication_SetAttribute(C.int(attribute), C.int(qt.GoBoolToInt(on)))
}

func QCoreApplication_SetEventDispatcher(eventDispatcher QAbstractEventDispatcher_ITF) {
	defer qt.Recovering("QCoreApplication::setEventDispatcher")

	C.QCoreApplication_QCoreApplication_SetEventDispatcher(PointerFromQAbstractEventDispatcher(eventDispatcher))
}

func QCoreApplication_SetLibraryPaths(paths []string) {
	defer qt.Recovering("QCoreApplication::setLibraryPaths")

	C.QCoreApplication_QCoreApplication_SetLibraryPaths(C.CString(strings.Join(paths, "|")))
}

func QCoreApplication_SetQuitLockEnabled(enabled bool) {
	defer qt.Recovering("QCoreApplication::setQuitLockEnabled")

	C.QCoreApplication_QCoreApplication_SetQuitLockEnabled(C.int(qt.GoBoolToInt(enabled)))
}

func QCoreApplication_SetSetuidAllowed(allow bool) {
	defer qt.Recovering("QCoreApplication::setSetuidAllowed")

	C.QCoreApplication_QCoreApplication_SetSetuidAllowed(C.int(qt.GoBoolToInt(allow)))
}

func QCoreApplication_StartingUp() bool {
	defer qt.Recovering("QCoreApplication::startingUp")

	return C.QCoreApplication_QCoreApplication_StartingUp() != 0
}

func QCoreApplication_TestAttribute(attribute Qt__ApplicationAttribute) bool {
	defer qt.Recovering("QCoreApplication::testAttribute")

	return C.QCoreApplication_QCoreApplication_TestAttribute(C.int(attribute)) != 0
}

func QCoreApplication_Translate(context string, sourceText string, disambiguation string, n int) string {
	defer qt.Recovering("QCoreApplication::translate")

	return C.GoString(C.QCoreApplication_QCoreApplication_Translate(C.CString(context), C.CString(sourceText), C.CString(disambiguation), C.int(n)))
}

func (ptr *QCoreApplication) DestroyQCoreApplication() {
	defer qt.Recovering("QCoreApplication::~QCoreApplication")

	if ptr.Pointer() != nil {
		C.QCoreApplication_DestroyQCoreApplication(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCoreApplication) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QCoreApplication::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QCoreApplication) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QCoreApplication::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQCoreApplicationTimerEvent
func callbackQCoreApplicationTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QCoreApplication::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQCoreApplicationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QCoreApplication) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QCoreApplication::timerEvent")

	if ptr.Pointer() != nil {
		C.QCoreApplication_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QCoreApplication) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QCoreApplication::timerEvent")

	if ptr.Pointer() != nil {
		C.QCoreApplication_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QCoreApplication) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QCoreApplication::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QCoreApplication) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QCoreApplication::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQCoreApplicationChildEvent
func callbackQCoreApplicationChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QCoreApplication::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQCoreApplicationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QCoreApplication) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QCoreApplication::childEvent")

	if ptr.Pointer() != nil {
		C.QCoreApplication_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QCoreApplication) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QCoreApplication::childEvent")

	if ptr.Pointer() != nil {
		C.QCoreApplication_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QCoreApplication) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QCoreApplication::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QCoreApplication) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QCoreApplication::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQCoreApplicationCustomEvent
func callbackQCoreApplicationCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QCoreApplication::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQCoreApplicationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QCoreApplication) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QCoreApplication::customEvent")

	if ptr.Pointer() != nil {
		C.QCoreApplication_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QCoreApplication) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QCoreApplication::customEvent")

	if ptr.Pointer() != nil {
		C.QCoreApplication_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QCryptographicHash struct {
	ptr unsafe.Pointer
}

type QCryptographicHash_ITF interface {
	QCryptographicHash_PTR() *QCryptographicHash
}

func (p *QCryptographicHash) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QCryptographicHash) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQCryptographicHash(ptr QCryptographicHash_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCryptographicHash_PTR().Pointer()
	}
	return nil
}

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

func newQCryptographicHashFromPointer(ptr unsafe.Pointer) *QCryptographicHash {
	var n = NewQCryptographicHashFromPointer(ptr)
	return n
}

func (ptr *QCryptographicHash) QCryptographicHash_PTR() *QCryptographicHash {
	return ptr
}

//QCryptographicHash::Algorithm
type QCryptographicHash__Algorithm int64

const (
	QCryptographicHash__Md4      = QCryptographicHash__Algorithm(0)
	QCryptographicHash__Md5      = QCryptographicHash__Algorithm(1)
	QCryptographicHash__Sha1     = QCryptographicHash__Algorithm(2)
	QCryptographicHash__Sha224   = QCryptographicHash__Algorithm(3)
	QCryptographicHash__Sha256   = QCryptographicHash__Algorithm(4)
	QCryptographicHash__Sha384   = QCryptographicHash__Algorithm(5)
	QCryptographicHash__Sha512   = QCryptographicHash__Algorithm(6)
	QCryptographicHash__Sha3_224 = QCryptographicHash__Algorithm(7)
	QCryptographicHash__Sha3_256 = QCryptographicHash__Algorithm(8)
	QCryptographicHash__Sha3_384 = QCryptographicHash__Algorithm(9)
	QCryptographicHash__Sha3_512 = QCryptographicHash__Algorithm(10)
)

func NewQCryptographicHash(method QCryptographicHash__Algorithm) *QCryptographicHash {
	defer qt.Recovering("QCryptographicHash::QCryptographicHash")

	return newQCryptographicHashFromPointer(C.QCryptographicHash_NewQCryptographicHash(C.int(method)))
}

func (ptr *QCryptographicHash) AddData2(device QIODevice_ITF) bool {
	defer qt.Recovering("QCryptographicHash::addData")

	if ptr.Pointer() != nil {
		return C.QCryptographicHash_AddData2(ptr.Pointer(), PointerFromQIODevice(device)) != 0
	}
	return false
}

func (ptr *QCryptographicHash) AddData3(data string) {
	defer qt.Recovering("QCryptographicHash::addData")

	if ptr.Pointer() != nil {
		C.QCryptographicHash_AddData3(ptr.Pointer(), C.CString(data))
	}
}

func (ptr *QCryptographicHash) AddData(data string, length int) {
	defer qt.Recovering("QCryptographicHash::addData")

	if ptr.Pointer() != nil {
		C.QCryptographicHash_AddData(ptr.Pointer(), C.CString(data), C.int(length))
	}
}

func QCryptographicHash_Hash(data string, method QCryptographicHash__Algorithm) string {
	defer qt.Recovering("QCryptographicHash::hash")

	return C.GoString(C.QCryptographicHash_QCryptographicHash_Hash(C.CString(data), C.int(method)))
}

func (ptr *QCryptographicHash) Reset() {
	defer qt.Recovering("QCryptographicHash::reset")

	if ptr.Pointer() != nil {
		C.QCryptographicHash_Reset(ptr.Pointer())
	}
}

func (ptr *QCryptographicHash) Result() string {
	defer qt.Recovering("QCryptographicHash::result")

	if ptr.Pointer() != nil {
		return C.GoString(C.QCryptographicHash_Result(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCryptographicHash) DestroyQCryptographicHash() {
	defer qt.Recovering("QCryptographicHash::~QCryptographicHash")

	if ptr.Pointer() != nil {
		C.QCryptographicHash_DestroyQCryptographicHash(ptr.Pointer())
	}
}

type QDataStream struct {
	ptr unsafe.Pointer
}

type QDataStream_ITF interface {
	QDataStream_PTR() *QDataStream
}

func (p *QDataStream) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QDataStream) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQDataStream(ptr QDataStream_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDataStream_PTR().Pointer()
	}
	return nil
}

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

func newQDataStreamFromPointer(ptr unsafe.Pointer) *QDataStream {
	var n = NewQDataStreamFromPointer(ptr)
	return n
}

func (ptr *QDataStream) QDataStream_PTR() *QDataStream {
	return ptr
}

//QDataStream::ByteOrder
type QDataStream__ByteOrder int64

const (
	QDataStream__BigEndian    = QDataStream__ByteOrder(QSysInfo__BigEndian)
	QDataStream__LittleEndian = QDataStream__ByteOrder(QSysInfo__LittleEndian)
)

//QDataStream::FloatingPointPrecision
type QDataStream__FloatingPointPrecision int64

const (
	QDataStream__SinglePrecision = QDataStream__FloatingPointPrecision(0)
	QDataStream__DoublePrecision = QDataStream__FloatingPointPrecision(1)
)

//QDataStream::Status
type QDataStream__Status int64

const (
	QDataStream__Ok              = QDataStream__Status(0)
	QDataStream__ReadPastEnd     = QDataStream__Status(1)
	QDataStream__ReadCorruptData = QDataStream__Status(2)
	QDataStream__WriteFailed     = QDataStream__Status(3)
)

//QDataStream::Version
type QDataStream__Version int64

const (
	QDataStream__Qt_1_0                    = QDataStream__Version(1)
	QDataStream__Qt_2_0                    = QDataStream__Version(2)
	QDataStream__Qt_2_1                    = QDataStream__Version(3)
	QDataStream__Qt_3_0                    = QDataStream__Version(4)
	QDataStream__Qt_3_1                    = QDataStream__Version(5)
	QDataStream__Qt_3_3                    = QDataStream__Version(6)
	QDataStream__Qt_4_0                    = QDataStream__Version(7)
	QDataStream__Qt_4_1                    = QDataStream__Version(QDataStream__Qt_4_0)
	QDataStream__Qt_4_2                    = QDataStream__Version(8)
	QDataStream__Qt_4_3                    = QDataStream__Version(9)
	QDataStream__Qt_4_4                    = QDataStream__Version(10)
	QDataStream__Qt_4_5                    = QDataStream__Version(11)
	QDataStream__Qt_4_6                    = QDataStream__Version(12)
	QDataStream__Qt_4_7                    = QDataStream__Version(QDataStream__Qt_4_6)
	QDataStream__Qt_4_8                    = QDataStream__Version(QDataStream__Qt_4_7)
	QDataStream__Qt_4_9                    = QDataStream__Version(QDataStream__Qt_4_8)
	QDataStream__Qt_5_0                    = QDataStream__Version(13)
	QDataStream__Qt_5_1                    = QDataStream__Version(14)
	QDataStream__Qt_5_2                    = QDataStream__Version(15)
	QDataStream__Qt_5_3                    = QDataStream__Version(QDataStream__Qt_5_2)
	QDataStream__Qt_5_4                    = QDataStream__Version(16)
	QDataStream__Qt_5_5                    = QDataStream__Version(QDataStream__Qt_5_4)
	QDataStream__Qt_DefaultCompiledVersion = QDataStream__Version(QDataStream__Qt_5_5)
)

func NewQDataStream3(a string, mode QIODevice__OpenModeFlag) *QDataStream {
	defer qt.Recovering("QDataStream::QDataStream")

	return newQDataStreamFromPointer(C.QDataStream_NewQDataStream3(C.CString(a), C.int(mode)))
}

func (ptr *QDataStream) AtEnd() bool {
	defer qt.Recovering("QDataStream::atEnd")

	if ptr.Pointer() != nil {
		return C.QDataStream_AtEnd(ptr.Pointer()) != 0
	}
	return false
}

func NewQDataStream() *QDataStream {
	defer qt.Recovering("QDataStream::QDataStream")

	return newQDataStreamFromPointer(C.QDataStream_NewQDataStream())
}

func NewQDataStream2(d QIODevice_ITF) *QDataStream {
	defer qt.Recovering("QDataStream::QDataStream")

	return newQDataStreamFromPointer(C.QDataStream_NewQDataStream2(PointerFromQIODevice(d)))
}

func NewQDataStream4(a string) *QDataStream {
	defer qt.Recovering("QDataStream::QDataStream")

	return newQDataStreamFromPointer(C.QDataStream_NewQDataStream4(C.CString(a)))
}

func (ptr *QDataStream) ByteOrder() QDataStream__ByteOrder {
	defer qt.Recovering("QDataStream::byteOrder")

	if ptr.Pointer() != nil {
		return QDataStream__ByteOrder(C.QDataStream_ByteOrder(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDataStream) Device() *QIODevice {
	defer qt.Recovering("QDataStream::device")

	if ptr.Pointer() != nil {
		return NewQIODeviceFromPointer(C.QDataStream_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDataStream) FloatingPointPrecision() QDataStream__FloatingPointPrecision {
	defer qt.Recovering("QDataStream::floatingPointPrecision")

	if ptr.Pointer() != nil {
		return QDataStream__FloatingPointPrecision(C.QDataStream_FloatingPointPrecision(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDataStream) ReadRawData(s string, len int) int {
	defer qt.Recovering("QDataStream::readRawData")

	if ptr.Pointer() != nil {
		return int(C.QDataStream_ReadRawData(ptr.Pointer(), C.CString(s), C.int(len)))
	}
	return 0
}

func (ptr *QDataStream) ResetStatus() {
	defer qt.Recovering("QDataStream::resetStatus")

	if ptr.Pointer() != nil {
		C.QDataStream_ResetStatus(ptr.Pointer())
	}
}

func (ptr *QDataStream) SetByteOrder(bo QDataStream__ByteOrder) {
	defer qt.Recovering("QDataStream::setByteOrder")

	if ptr.Pointer() != nil {
		C.QDataStream_SetByteOrder(ptr.Pointer(), C.int(bo))
	}
}

func (ptr *QDataStream) SetDevice(d QIODevice_ITF) {
	defer qt.Recovering("QDataStream::setDevice")

	if ptr.Pointer() != nil {
		C.QDataStream_SetDevice(ptr.Pointer(), PointerFromQIODevice(d))
	}
}

func (ptr *QDataStream) SetFloatingPointPrecision(precision QDataStream__FloatingPointPrecision) {
	defer qt.Recovering("QDataStream::setFloatingPointPrecision")

	if ptr.Pointer() != nil {
		C.QDataStream_SetFloatingPointPrecision(ptr.Pointer(), C.int(precision))
	}
}

func (ptr *QDataStream) SetStatus(status QDataStream__Status) {
	defer qt.Recovering("QDataStream::setStatus")

	if ptr.Pointer() != nil {
		C.QDataStream_SetStatus(ptr.Pointer(), C.int(status))
	}
}

func (ptr *QDataStream) SetVersion(v int) {
	defer qt.Recovering("QDataStream::setVersion")

	if ptr.Pointer() != nil {
		C.QDataStream_SetVersion(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QDataStream) SkipRawData(len int) int {
	defer qt.Recovering("QDataStream::skipRawData")

	if ptr.Pointer() != nil {
		return int(C.QDataStream_SkipRawData(ptr.Pointer(), C.int(len)))
	}
	return 0
}

func (ptr *QDataStream) Status() QDataStream__Status {
	defer qt.Recovering("QDataStream::status")

	if ptr.Pointer() != nil {
		return QDataStream__Status(C.QDataStream_Status(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDataStream) Version() int {
	defer qt.Recovering("QDataStream::version")

	if ptr.Pointer() != nil {
		return int(C.QDataStream_Version(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDataStream) WriteRawData(s string, len int) int {
	defer qt.Recovering("QDataStream::writeRawData")

	if ptr.Pointer() != nil {
		return int(C.QDataStream_WriteRawData(ptr.Pointer(), C.CString(s), C.int(len)))
	}
	return 0
}

func (ptr *QDataStream) DestroyQDataStream() {
	defer qt.Recovering("QDataStream::~QDataStream")

	if ptr.Pointer() != nil {
		C.QDataStream_DestroyQDataStream(ptr.Pointer())
	}
}

type QDate struct {
	ptr unsafe.Pointer
}

type QDate_ITF interface {
	QDate_PTR() *QDate
}

func (p *QDate) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QDate) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQDate(ptr QDate_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDate_PTR().Pointer()
	}
	return nil
}

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

func newQDateFromPointer(ptr unsafe.Pointer) *QDate {
	var n = NewQDateFromPointer(ptr)
	return n
}

func (ptr *QDate) QDate_PTR() *QDate {
	return ptr
}

//QDate::MonthNameType
type QDate__MonthNameType int64

const (
	QDate__DateFormat       = QDate__MonthNameType(0)
	QDate__StandaloneFormat = QDate__MonthNameType(1)
)

func QDate_IsLeapYear(year int) bool {
	defer qt.Recovering("QDate::isLeapYear")

	return C.QDate_QDate_IsLeapYear(C.int(year)) != 0
}

func (ptr *QDate) ToString2(format Qt__DateFormat) string {
	defer qt.Recovering("QDate::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDate_ToString2(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func NewQDate() *QDate {
	defer qt.Recovering("QDate::QDate")

	return newQDateFromPointer(C.QDate_NewQDate())
}

func NewQDate3(y int, m int, d int) *QDate {
	defer qt.Recovering("QDate::QDate")

	return newQDateFromPointer(C.QDate_NewQDate3(C.int(y), C.int(m), C.int(d)))
}

func (ptr *QDate) Day() int {
	defer qt.Recovering("QDate::day")

	if ptr.Pointer() != nil {
		return int(C.QDate_Day(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDate) DayOfWeek() int {
	defer qt.Recovering("QDate::dayOfWeek")

	if ptr.Pointer() != nil {
		return int(C.QDate_DayOfWeek(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDate) DayOfYear() int {
	defer qt.Recovering("QDate::dayOfYear")

	if ptr.Pointer() != nil {
		return int(C.QDate_DayOfYear(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDate) DaysInMonth() int {
	defer qt.Recovering("QDate::daysInMonth")

	if ptr.Pointer() != nil {
		return int(C.QDate_DaysInMonth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDate) DaysInYear() int {
	defer qt.Recovering("QDate::daysInYear")

	if ptr.Pointer() != nil {
		return int(C.QDate_DaysInYear(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDate) DaysTo(d QDate_ITF) int64 {
	defer qt.Recovering("QDate::daysTo")

	if ptr.Pointer() != nil {
		return int64(C.QDate_DaysTo(ptr.Pointer(), PointerFromQDate(d)))
	}
	return 0
}

func (ptr *QDate) GetDate(year int, month int, day int) {
	defer qt.Recovering("QDate::getDate")

	if ptr.Pointer() != nil {
		C.QDate_GetDate(ptr.Pointer(), C.int(year), C.int(month), C.int(day))
	}
}

func (ptr *QDate) IsNull() bool {
	defer qt.Recovering("QDate::isNull")

	if ptr.Pointer() != nil {
		return C.QDate_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func QDate_IsValid2(year int, month int, day int) bool {
	defer qt.Recovering("QDate::isValid")

	return C.QDate_QDate_IsValid2(C.int(year), C.int(month), C.int(day)) != 0
}

func (ptr *QDate) IsValid() bool {
	defer qt.Recovering("QDate::isValid")

	if ptr.Pointer() != nil {
		return C.QDate_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func QDate_LongDayName(weekday int, ty QDate__MonthNameType) string {
	defer qt.Recovering("QDate::longDayName")

	return C.GoString(C.QDate_QDate_LongDayName(C.int(weekday), C.int(ty)))
}

func QDate_LongMonthName(month int, ty QDate__MonthNameType) string {
	defer qt.Recovering("QDate::longMonthName")

	return C.GoString(C.QDate_QDate_LongMonthName(C.int(month), C.int(ty)))
}

func (ptr *QDate) Month() int {
	defer qt.Recovering("QDate::month")

	if ptr.Pointer() != nil {
		return int(C.QDate_Month(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDate) SetDate(year int, month int, day int) bool {
	defer qt.Recovering("QDate::setDate")

	if ptr.Pointer() != nil {
		return C.QDate_SetDate(ptr.Pointer(), C.int(year), C.int(month), C.int(day)) != 0
	}
	return false
}

func QDate_ShortDayName(weekday int, ty QDate__MonthNameType) string {
	defer qt.Recovering("QDate::shortDayName")

	return C.GoString(C.QDate_QDate_ShortDayName(C.int(weekday), C.int(ty)))
}

func QDate_ShortMonthName(month int, ty QDate__MonthNameType) string {
	defer qt.Recovering("QDate::shortMonthName")

	return C.GoString(C.QDate_QDate_ShortMonthName(C.int(month), C.int(ty)))
}

func (ptr *QDate) ToJulianDay() int64 {
	defer qt.Recovering("QDate::toJulianDay")

	if ptr.Pointer() != nil {
		return int64(C.QDate_ToJulianDay(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDate) ToString(format string) string {
	defer qt.Recovering("QDate::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDate_ToString(ptr.Pointer(), C.CString(format)))
	}
	return ""
}

func (ptr *QDate) WeekNumber(yearNumber int) int {
	defer qt.Recovering("QDate::weekNumber")

	if ptr.Pointer() != nil {
		return int(C.QDate_WeekNumber(ptr.Pointer(), C.int(yearNumber)))
	}
	return 0
}

func (ptr *QDate) Year() int {
	defer qt.Recovering("QDate::year")

	if ptr.Pointer() != nil {
		return int(C.QDate_Year(ptr.Pointer()))
	}
	return 0
}

type QDateTime struct {
	ptr unsafe.Pointer
}

type QDateTime_ITF interface {
	QDateTime_PTR() *QDateTime
}

func (p *QDateTime) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QDateTime) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQDateTime(ptr QDateTime_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDateTime_PTR().Pointer()
	}
	return nil
}

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

func newQDateTimeFromPointer(ptr unsafe.Pointer) *QDateTime {
	var n = NewQDateTimeFromPointer(ptr)
	return n
}

func (ptr *QDateTime) QDateTime_PTR() *QDateTime {
	return ptr
}

func QDateTime_CurrentDateTime() *QDateTime {
	defer qt.Recovering("QDateTime::currentDateTime")

	return NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTime())
}

func QDateTime_CurrentDateTimeUtc() *QDateTime {
	defer qt.Recovering("QDateTime::currentDateTimeUtc")

	return NewQDateTimeFromPointer(C.QDateTime_QDateTime_CurrentDateTimeUtc())
}

func QDateTime_CurrentMSecsSinceEpoch() int64 {
	defer qt.Recovering("QDateTime::currentMSecsSinceEpoch")

	return int64(C.QDateTime_QDateTime_CurrentMSecsSinceEpoch())
}

func QDateTime_FromString(stri string, format Qt__DateFormat) *QDateTime {
	defer qt.Recovering("QDateTime::fromString")

	return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString(C.CString(stri), C.int(format)))
}

func QDateTime_FromString2(stri string, format string) *QDateTime {
	defer qt.Recovering("QDateTime::fromString")

	return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromString2(C.CString(stri), C.CString(format)))
}

func (ptr *QDateTime) ToOffsetFromUtc(offsetSeconds int) *QDateTime {
	defer qt.Recovering("QDateTime::toOffsetFromUtc")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_ToOffsetFromUtc(ptr.Pointer(), C.int(offsetSeconds)))
	}
	return nil
}

func (ptr *QDateTime) ToString2(format Qt__DateFormat) string {
	defer qt.Recovering("QDateTime::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDateTime_ToString2(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func (ptr *QDateTime) ToTimeSpec(spec Qt__TimeSpec) *QDateTime {
	defer qt.Recovering("QDateTime::toTimeSpec")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_ToTimeSpec(ptr.Pointer(), C.int(spec)))
	}
	return nil
}

func NewQDateTime() *QDateTime {
	defer qt.Recovering("QDateTime::QDateTime")

	return newQDateTimeFromPointer(C.QDateTime_NewQDateTime())
}

func NewQDateTime2(date QDate_ITF) *QDateTime {
	defer qt.Recovering("QDateTime::QDateTime")

	return newQDateTimeFromPointer(C.QDateTime_NewQDateTime2(PointerFromQDate(date)))
}

func NewQDateTime3(date QDate_ITF, time QTime_ITF, spec Qt__TimeSpec) *QDateTime {
	defer qt.Recovering("QDateTime::QDateTime")

	return newQDateTimeFromPointer(C.QDateTime_NewQDateTime3(PointerFromQDate(date), PointerFromQTime(time), C.int(spec)))
}

func NewQDateTime4(date QDate_ITF, time QTime_ITF, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
	defer qt.Recovering("QDateTime::QDateTime")

	return newQDateTimeFromPointer(C.QDateTime_NewQDateTime4(PointerFromQDate(date), PointerFromQTime(time), C.int(spec), C.int(offsetSeconds)))
}

func NewQDateTime5(date QDate_ITF, time QTime_ITF, timeZone QTimeZone_ITF) *QDateTime {
	defer qt.Recovering("QDateTime::QDateTime")

	return newQDateTimeFromPointer(C.QDateTime_NewQDateTime5(PointerFromQDate(date), PointerFromQTime(time), PointerFromQTimeZone(timeZone)))
}

func NewQDateTime6(other QDateTime_ITF) *QDateTime {
	defer qt.Recovering("QDateTime::QDateTime")

	return newQDateTimeFromPointer(C.QDateTime_NewQDateTime6(PointerFromQDateTime(other)))
}

func (ptr *QDateTime) AddDays(ndays int64) *QDateTime {
	defer qt.Recovering("QDateTime::addDays")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_AddDays(ptr.Pointer(), C.longlong(ndays)))
	}
	return nil
}

func (ptr *QDateTime) AddMSecs(msecs int64) *QDateTime {
	defer qt.Recovering("QDateTime::addMSecs")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_AddMSecs(ptr.Pointer(), C.longlong(msecs)))
	}
	return nil
}

func (ptr *QDateTime) AddMonths(nmonths int) *QDateTime {
	defer qt.Recovering("QDateTime::addMonths")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_AddMonths(ptr.Pointer(), C.int(nmonths)))
	}
	return nil
}

func (ptr *QDateTime) AddSecs(s int64) *QDateTime {
	defer qt.Recovering("QDateTime::addSecs")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_AddSecs(ptr.Pointer(), C.longlong(s)))
	}
	return nil
}

func (ptr *QDateTime) AddYears(nyears int) *QDateTime {
	defer qt.Recovering("QDateTime::addYears")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_AddYears(ptr.Pointer(), C.int(nyears)))
	}
	return nil
}

func (ptr *QDateTime) DaysTo(other QDateTime_ITF) int64 {
	defer qt.Recovering("QDateTime::daysTo")

	if ptr.Pointer() != nil {
		return int64(C.QDateTime_DaysTo(ptr.Pointer(), PointerFromQDateTime(other)))
	}
	return 0
}

func QDateTime_FromMSecsSinceEpoch(msecs int64) *QDateTime {
	defer qt.Recovering("QDateTime::fromMSecsSinceEpoch")

	return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch(C.longlong(msecs)))
}

func QDateTime_FromMSecsSinceEpoch2(msecs int64, spec Qt__TimeSpec, offsetSeconds int) *QDateTime {
	defer qt.Recovering("QDateTime::fromMSecsSinceEpoch")

	return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch2(C.longlong(msecs), C.int(spec), C.int(offsetSeconds)))
}

func QDateTime_FromMSecsSinceEpoch3(msecs int64, timeZone QTimeZone_ITF) *QDateTime {
	defer qt.Recovering("QDateTime::fromMSecsSinceEpoch")

	return NewQDateTimeFromPointer(C.QDateTime_QDateTime_FromMSecsSinceEpoch3(C.longlong(msecs), PointerFromQTimeZone(timeZone)))
}

func (ptr *QDateTime) IsDaylightTime() bool {
	defer qt.Recovering("QDateTime::isDaylightTime")

	if ptr.Pointer() != nil {
		return C.QDateTime_IsDaylightTime(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QDateTime) IsNull() bool {
	defer qt.Recovering("QDateTime::isNull")

	if ptr.Pointer() != nil {
		return C.QDateTime_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QDateTime) IsValid() bool {
	defer qt.Recovering("QDateTime::isValid")

	if ptr.Pointer() != nil {
		return C.QDateTime_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QDateTime) MsecsTo(other QDateTime_ITF) int64 {
	defer qt.Recovering("QDateTime::msecsTo")

	if ptr.Pointer() != nil {
		return int64(C.QDateTime_MsecsTo(ptr.Pointer(), PointerFromQDateTime(other)))
	}
	return 0
}

func (ptr *QDateTime) OffsetFromUtc() int {
	defer qt.Recovering("QDateTime::offsetFromUtc")

	if ptr.Pointer() != nil {
		return int(C.QDateTime_OffsetFromUtc(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDateTime) SecsTo(other QDateTime_ITF) int64 {
	defer qt.Recovering("QDateTime::secsTo")

	if ptr.Pointer() != nil {
		return int64(C.QDateTime_SecsTo(ptr.Pointer(), PointerFromQDateTime(other)))
	}
	return 0
}

func (ptr *QDateTime) SetDate(date QDate_ITF) {
	defer qt.Recovering("QDateTime::setDate")

	if ptr.Pointer() != nil {
		C.QDateTime_SetDate(ptr.Pointer(), PointerFromQDate(date))
	}
}

func (ptr *QDateTime) SetMSecsSinceEpoch(msecs int64) {
	defer qt.Recovering("QDateTime::setMSecsSinceEpoch")

	if ptr.Pointer() != nil {
		C.QDateTime_SetMSecsSinceEpoch(ptr.Pointer(), C.longlong(msecs))
	}
}

func (ptr *QDateTime) SetOffsetFromUtc(offsetSeconds int) {
	defer qt.Recovering("QDateTime::setOffsetFromUtc")

	if ptr.Pointer() != nil {
		C.QDateTime_SetOffsetFromUtc(ptr.Pointer(), C.int(offsetSeconds))
	}
}

func (ptr *QDateTime) SetTime(time QTime_ITF) {
	defer qt.Recovering("QDateTime::setTime")

	if ptr.Pointer() != nil {
		C.QDateTime_SetTime(ptr.Pointer(), PointerFromQTime(time))
	}
}

func (ptr *QDateTime) SetTimeSpec(spec Qt__TimeSpec) {
	defer qt.Recovering("QDateTime::setTimeSpec")

	if ptr.Pointer() != nil {
		C.QDateTime_SetTimeSpec(ptr.Pointer(), C.int(spec))
	}
}

func (ptr *QDateTime) SetTimeZone(toZone QTimeZone_ITF) {
	defer qt.Recovering("QDateTime::setTimeZone")

	if ptr.Pointer() != nil {
		C.QDateTime_SetTimeZone(ptr.Pointer(), PointerFromQTimeZone(toZone))
	}
}

func (ptr *QDateTime) Swap(other QDateTime_ITF) {
	defer qt.Recovering("QDateTime::swap")

	if ptr.Pointer() != nil {
		C.QDateTime_Swap(ptr.Pointer(), PointerFromQDateTime(other))
	}
}

func (ptr *QDateTime) TimeSpec() Qt__TimeSpec {
	defer qt.Recovering("QDateTime::timeSpec")

	if ptr.Pointer() != nil {
		return Qt__TimeSpec(C.QDateTime_TimeSpec(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDateTime) TimeZone() *QTimeZone {
	defer qt.Recovering("QDateTime::timeZone")

	if ptr.Pointer() != nil {
		return NewQTimeZoneFromPointer(C.QDateTime_TimeZone(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDateTime) TimeZoneAbbreviation() string {
	defer qt.Recovering("QDateTime::timeZoneAbbreviation")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDateTime_TimeZoneAbbreviation(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDateTime) ToLocalTime() *QDateTime {
	defer qt.Recovering("QDateTime::toLocalTime")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_ToLocalTime(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDateTime) ToMSecsSinceEpoch() int64 {
	defer qt.Recovering("QDateTime::toMSecsSinceEpoch")

	if ptr.Pointer() != nil {
		return int64(C.QDateTime_ToMSecsSinceEpoch(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDateTime) ToString(format string) string {
	defer qt.Recovering("QDateTime::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDateTime_ToString(ptr.Pointer(), C.CString(format)))
	}
	return ""
}

func (ptr *QDateTime) ToTimeZone(timeZone QTimeZone_ITF) *QDateTime {
	defer qt.Recovering("QDateTime::toTimeZone")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_ToTimeZone(ptr.Pointer(), PointerFromQTimeZone(timeZone)))
	}
	return nil
}

func (ptr *QDateTime) ToUTC() *QDateTime {
	defer qt.Recovering("QDateTime::toUTC")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QDateTime_ToUTC(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDateTime) DestroyQDateTime() {
	defer qt.Recovering("QDateTime::~QDateTime")

	if ptr.Pointer() != nil {
		C.QDateTime_DestroyQDateTime(ptr.Pointer())
	}
}

type QDebug struct {
	ptr unsafe.Pointer
}

type QDebug_ITF interface {
	QDebug_PTR() *QDebug
}

func (p *QDebug) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QDebug) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQDebug(ptr QDebug_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDebug_PTR().Pointer()
	}
	return nil
}

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

func newQDebugFromPointer(ptr unsafe.Pointer) *QDebug {
	var n = NewQDebugFromPointer(ptr)
	return n
}

func (ptr *QDebug) QDebug_PTR() *QDebug {
	return ptr
}

type QDebugStateSaver struct {
	ptr unsafe.Pointer
}

type QDebugStateSaver_ITF interface {
	QDebugStateSaver_PTR() *QDebugStateSaver
}

func (p *QDebugStateSaver) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QDebugStateSaver) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQDebugStateSaver(ptr QDebugStateSaver_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDebugStateSaver_PTR().Pointer()
	}
	return nil
}

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

func newQDebugStateSaverFromPointer(ptr unsafe.Pointer) *QDebugStateSaver {
	var n = NewQDebugStateSaverFromPointer(ptr)
	return n
}

func (ptr *QDebugStateSaver) QDebugStateSaver_PTR() *QDebugStateSaver {
	return ptr
}

func NewQDebugStateSaver(dbg QDebug_ITF) *QDebugStateSaver {
	defer qt.Recovering("QDebugStateSaver::QDebugStateSaver")

	return newQDebugStateSaverFromPointer(C.QDebugStateSaver_NewQDebugStateSaver(PointerFromQDebug(dbg)))
}

func (ptr *QDebugStateSaver) DestroyQDebugStateSaver() {
	defer qt.Recovering("QDebugStateSaver::~QDebugStateSaver")

	if ptr.Pointer() != nil {
		C.QDebugStateSaver_DestroyQDebugStateSaver(ptr.Pointer())
	}
}

type QDir struct {
	ptr unsafe.Pointer
}

type QDir_ITF interface {
	QDir_PTR() *QDir
}

func (p *QDir) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QDir) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQDir(ptr QDir_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDir_PTR().Pointer()
	}
	return nil
}

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

func newQDirFromPointer(ptr unsafe.Pointer) *QDir {
	var n = NewQDirFromPointer(ptr)
	return n
}

func (ptr *QDir) QDir_PTR() *QDir {
	return ptr
}

//QDir::Filter
type QDir__Filter int64

const (
	QDir__Dirs           = QDir__Filter(0x001)
	QDir__Files          = QDir__Filter(0x002)
	QDir__Drives         = QDir__Filter(0x004)
	QDir__NoSymLinks     = QDir__Filter(0x008)
	QDir__AllEntries     = QDir__Filter(QDir__Dirs | QDir__Files | QDir__Drives)
	QDir__TypeMask       = QDir__Filter(0x00f)
	QDir__Readable       = QDir__Filter(0x010)
	QDir__Writable       = QDir__Filter(0x020)
	QDir__Executable     = QDir__Filter(0x040)
	QDir__PermissionMask = QDir__Filter(0x070)
	QDir__Modified       = QDir__Filter(0x080)
	QDir__Hidden         = QDir__Filter(0x100)
	QDir__System         = QDir__Filter(0x200)
	QDir__AccessMask     = QDir__Filter(0x3F0)
	QDir__AllDirs        = QDir__Filter(0x400)
	QDir__CaseSensitive  = QDir__Filter(0x800)
	QDir__NoDot          = QDir__Filter(0x2000)
	QDir__NoDotDot       = QDir__Filter(0x4000)
	QDir__NoDotAndDotDot = QDir__Filter(QDir__NoDot | QDir__NoDotDot)
	QDir__NoFilter       = QDir__Filter(-1)
)

//QDir::SortFlag
type QDir__SortFlag int64

const (
	QDir__Name        = QDir__SortFlag(0x00)
	QDir__Time        = QDir__SortFlag(0x01)
	QDir__Size        = QDir__SortFlag(0x02)
	QDir__Unsorted    = QDir__SortFlag(0x03)
	QDir__SortByMask  = QDir__SortFlag(0x03)
	QDir__DirsFirst   = QDir__SortFlag(0x04)
	QDir__Reversed    = QDir__SortFlag(0x08)
	QDir__IgnoreCase  = QDir__SortFlag(0x10)
	QDir__DirsLast    = QDir__SortFlag(0x20)
	QDir__LocaleAware = QDir__SortFlag(0x40)
	QDir__Type        = QDir__SortFlag(0x80)
	QDir__NoSort      = QDir__SortFlag(-1)
)

func NewQDir(dir QDir_ITF) *QDir {
	defer qt.Recovering("QDir::QDir")

	return newQDirFromPointer(C.QDir_NewQDir(PointerFromQDir(dir)))
}

func NewQDir2(path string) *QDir {
	defer qt.Recovering("QDir::QDir")

	return newQDirFromPointer(C.QDir_NewQDir2(C.CString(path)))
}

func NewQDir3(path string, nameFilter string, sort QDir__SortFlag, filters QDir__Filter) *QDir {
	defer qt.Recovering("QDir::QDir")

	return newQDirFromPointer(C.QDir_NewQDir3(C.CString(path), C.CString(nameFilter), C.int(sort), C.int(filters)))
}

func (ptr *QDir) AbsoluteFilePath(fileName string) string {
	defer qt.Recovering("QDir::absoluteFilePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDir_AbsoluteFilePath(ptr.Pointer(), C.CString(fileName)))
	}
	return ""
}

func (ptr *QDir) AbsolutePath() string {
	defer qt.Recovering("QDir::absolutePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDir_AbsolutePath(ptr.Pointer()))
	}
	return ""
}

func QDir_AddSearchPath(prefix string, path string) {
	defer qt.Recovering("QDir::addSearchPath")

	C.QDir_QDir_AddSearchPath(C.CString(prefix), C.CString(path))
}

func (ptr *QDir) CanonicalPath() string {
	defer qt.Recovering("QDir::canonicalPath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDir_CanonicalPath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDir) Cd(dirName string) bool {
	defer qt.Recovering("QDir::cd")

	if ptr.Pointer() != nil {
		return C.QDir_Cd(ptr.Pointer(), C.CString(dirName)) != 0
	}
	return false
}

func (ptr *QDir) CdUp() bool {
	defer qt.Recovering("QDir::cdUp")

	if ptr.Pointer() != nil {
		return C.QDir_CdUp(ptr.Pointer()) != 0
	}
	return false
}

func QDir_CleanPath(path string) string {
	defer qt.Recovering("QDir::cleanPath")

	return C.GoString(C.QDir_QDir_CleanPath(C.CString(path)))
}

func QDir_Current() *QDir {
	defer qt.Recovering("QDir::current")

	return NewQDirFromPointer(C.QDir_QDir_Current())
}

func QDir_CurrentPath() string {
	defer qt.Recovering("QDir::currentPath")

	return C.GoString(C.QDir_QDir_CurrentPath())
}

func (ptr *QDir) DirName() string {
	defer qt.Recovering("QDir::dirName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDir_DirName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDir) EntryList2(filters QDir__Filter, sort QDir__SortFlag) []string {
	defer qt.Recovering("QDir::entryList")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QDir_EntryList2(ptr.Pointer(), C.int(filters), C.int(sort))), "|")
	}
	return make([]string, 0)
}

func (ptr *QDir) EntryList(nameFilters []string, filters QDir__Filter, sort QDir__SortFlag) []string {
	defer qt.Recovering("QDir::entryList")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QDir_EntryList(ptr.Pointer(), C.CString(strings.Join(nameFilters, "|")), C.int(filters), C.int(sort))), "|")
	}
	return make([]string, 0)
}

func (ptr *QDir) Exists2() bool {
	defer qt.Recovering("QDir::exists")

	if ptr.Pointer() != nil {
		return C.QDir_Exists2(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QDir) Exists(name string) bool {
	defer qt.Recovering("QDir::exists")

	if ptr.Pointer() != nil {
		return C.QDir_Exists(ptr.Pointer(), C.CString(name)) != 0
	}
	return false
}

func (ptr *QDir) FilePath(fileName string) string {
	defer qt.Recovering("QDir::filePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDir_FilePath(ptr.Pointer(), C.CString(fileName)))
	}
	return ""
}

func (ptr *QDir) Filter() QDir__Filter {
	defer qt.Recovering("QDir::filter")

	if ptr.Pointer() != nil {
		return QDir__Filter(C.QDir_Filter(ptr.Pointer()))
	}
	return 0
}

func QDir_FromNativeSeparators(pathName string) string {
	defer qt.Recovering("QDir::fromNativeSeparators")

	return C.GoString(C.QDir_QDir_FromNativeSeparators(C.CString(pathName)))
}

func QDir_Home() *QDir {
	defer qt.Recovering("QDir::home")

	return NewQDirFromPointer(C.QDir_QDir_Home())
}

func QDir_HomePath() string {
	defer qt.Recovering("QDir::homePath")

	return C.GoString(C.QDir_QDir_HomePath())
}

func (ptr *QDir) IsAbsolute() bool {
	defer qt.Recovering("QDir::isAbsolute")

	if ptr.Pointer() != nil {
		return C.QDir_IsAbsolute(ptr.Pointer()) != 0
	}
	return false
}

func QDir_IsAbsolutePath(path string) bool {
	defer qt.Recovering("QDir::isAbsolutePath")

	return C.QDir_QDir_IsAbsolutePath(C.CString(path)) != 0
}

func (ptr *QDir) IsReadable() bool {
	defer qt.Recovering("QDir::isReadable")

	if ptr.Pointer() != nil {
		return C.QDir_IsReadable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QDir) IsRelative() bool {
	defer qt.Recovering("QDir::isRelative")

	if ptr.Pointer() != nil {
		return C.QDir_IsRelative(ptr.Pointer()) != 0
	}
	return false
}

func QDir_IsRelativePath(path string) bool {
	defer qt.Recovering("QDir::isRelativePath")

	return C.QDir_QDir_IsRelativePath(C.CString(path)) != 0
}

func (ptr *QDir) IsRoot() bool {
	defer qt.Recovering("QDir::isRoot")

	if ptr.Pointer() != nil {
		return C.QDir_IsRoot(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QDir) MakeAbsolute() bool {
	defer qt.Recovering("QDir::makeAbsolute")

	if ptr.Pointer() != nil {
		return C.QDir_MakeAbsolute(ptr.Pointer()) != 0
	}
	return false
}

func QDir_Match(filter string, fileName string) bool {
	defer qt.Recovering("QDir::match")

	return C.QDir_QDir_Match(C.CString(filter), C.CString(fileName)) != 0
}

func QDir_Match2(filters []string, fileName string) bool {
	defer qt.Recovering("QDir::match")

	return C.QDir_QDir_Match2(C.CString(strings.Join(filters, "|")), C.CString(fileName)) != 0
}

func (ptr *QDir) Mkdir(dirName string) bool {
	defer qt.Recovering("QDir::mkdir")

	if ptr.Pointer() != nil {
		return C.QDir_Mkdir(ptr.Pointer(), C.CString(dirName)) != 0
	}
	return false
}

func (ptr *QDir) Mkpath(dirPath string) bool {
	defer qt.Recovering("QDir::mkpath")

	if ptr.Pointer() != nil {
		return C.QDir_Mkpath(ptr.Pointer(), C.CString(dirPath)) != 0
	}
	return false
}

func (ptr *QDir) NameFilters() []string {
	defer qt.Recovering("QDir::nameFilters")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QDir_NameFilters(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QDir) Path() string {
	defer qt.Recovering("QDir::path")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDir_Path(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDir) Refresh() {
	defer qt.Recovering("QDir::refresh")

	if ptr.Pointer() != nil {
		C.QDir_Refresh(ptr.Pointer())
	}
}

func (ptr *QDir) RelativeFilePath(fileName string) string {
	defer qt.Recovering("QDir::relativeFilePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDir_RelativeFilePath(ptr.Pointer(), C.CString(fileName)))
	}
	return ""
}

func (ptr *QDir) RemoveRecursively() bool {
	defer qt.Recovering("QDir::removeRecursively")

	if ptr.Pointer() != nil {
		return C.QDir_RemoveRecursively(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QDir) Rename(oldName string, newName string) bool {
	defer qt.Recovering("QDir::rename")

	if ptr.Pointer() != nil {
		return C.QDir_Rename(ptr.Pointer(), C.CString(oldName), C.CString(newName)) != 0
	}
	return false
}

func (ptr *QDir) Rmdir(dirName string) bool {
	defer qt.Recovering("QDir::rmdir")

	if ptr.Pointer() != nil {
		return C.QDir_Rmdir(ptr.Pointer(), C.CString(dirName)) != 0
	}
	return false
}

func (ptr *QDir) Rmpath(dirPath string) bool {
	defer qt.Recovering("QDir::rmpath")

	if ptr.Pointer() != nil {
		return C.QDir_Rmpath(ptr.Pointer(), C.CString(dirPath)) != 0
	}
	return false
}

func QDir_Root() *QDir {
	defer qt.Recovering("QDir::root")

	return NewQDirFromPointer(C.QDir_QDir_Root())
}

func QDir_RootPath() string {
	defer qt.Recovering("QDir::rootPath")

	return C.GoString(C.QDir_QDir_RootPath())
}

func QDir_SearchPaths(prefix string) []string {
	defer qt.Recovering("QDir::searchPaths")

	return strings.Split(C.GoString(C.QDir_QDir_SearchPaths(C.CString(prefix))), "|")
}

func QDir_SetCurrent(path string) bool {
	defer qt.Recovering("QDir::setCurrent")

	return C.QDir_QDir_SetCurrent(C.CString(path)) != 0
}

func (ptr *QDir) SetFilter(filters QDir__Filter) {
	defer qt.Recovering("QDir::setFilter")

	if ptr.Pointer() != nil {
		C.QDir_SetFilter(ptr.Pointer(), C.int(filters))
	}
}

func (ptr *QDir) SetNameFilters(nameFilters []string) {
	defer qt.Recovering("QDir::setNameFilters")

	if ptr.Pointer() != nil {
		C.QDir_SetNameFilters(ptr.Pointer(), C.CString(strings.Join(nameFilters, "|")))
	}
}

func (ptr *QDir) SetPath(path string) {
	defer qt.Recovering("QDir::setPath")

	if ptr.Pointer() != nil {
		C.QDir_SetPath(ptr.Pointer(), C.CString(path))
	}
}

func QDir_SetSearchPaths(prefix string, searchPaths []string) {
	defer qt.Recovering("QDir::setSearchPaths")

	C.QDir_QDir_SetSearchPaths(C.CString(prefix), C.CString(strings.Join(searchPaths, "|")))
}

func (ptr *QDir) SetSorting(sort QDir__SortFlag) {
	defer qt.Recovering("QDir::setSorting")

	if ptr.Pointer() != nil {
		C.QDir_SetSorting(ptr.Pointer(), C.int(sort))
	}
}

func (ptr *QDir) Sorting() QDir__SortFlag {
	defer qt.Recovering("QDir::sorting")

	if ptr.Pointer() != nil {
		return QDir__SortFlag(C.QDir_Sorting(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDir) Swap(other QDir_ITF) {
	defer qt.Recovering("QDir::swap")

	if ptr.Pointer() != nil {
		C.QDir_Swap(ptr.Pointer(), PointerFromQDir(other))
	}
}

func QDir_Temp() *QDir {
	defer qt.Recovering("QDir::temp")

	return NewQDirFromPointer(C.QDir_QDir_Temp())
}

func QDir_TempPath() string {
	defer qt.Recovering("QDir::tempPath")

	return C.GoString(C.QDir_QDir_TempPath())
}

func QDir_ToNativeSeparators(pathName string) string {
	defer qt.Recovering("QDir::toNativeSeparators")

	return C.GoString(C.QDir_QDir_ToNativeSeparators(C.CString(pathName)))
}

func (ptr *QDir) DestroyQDir() {
	defer qt.Recovering("QDir::~QDir")

	if ptr.Pointer() != nil {
		C.QDir_DestroyQDir(ptr.Pointer())
	}
}

type QDirIterator struct {
	ptr unsafe.Pointer
}

type QDirIterator_ITF interface {
	QDirIterator_PTR() *QDirIterator
}

func (p *QDirIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QDirIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQDirIterator(ptr QDirIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDirIterator_PTR().Pointer()
	}
	return nil
}

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

func newQDirIteratorFromPointer(ptr unsafe.Pointer) *QDirIterator {
	var n = NewQDirIteratorFromPointer(ptr)
	return n
}

func (ptr *QDirIterator) QDirIterator_PTR() *QDirIterator {
	return ptr
}

//QDirIterator::IteratorFlag
type QDirIterator__IteratorFlag int64

const (
	QDirIterator__NoIteratorFlags = QDirIterator__IteratorFlag(0x0)
	QDirIterator__FollowSymlinks  = QDirIterator__IteratorFlag(0x1)
	QDirIterator__Subdirectories  = QDirIterator__IteratorFlag(0x2)
)

type QDynamicPropertyChangeEvent struct {
	QEvent
}

type QDynamicPropertyChangeEvent_ITF interface {
	QEvent_ITF
	QDynamicPropertyChangeEvent_PTR() *QDynamicPropertyChangeEvent
}

func PointerFromQDynamicPropertyChangeEvent(ptr QDynamicPropertyChangeEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDynamicPropertyChangeEvent_PTR().Pointer()
	}
	return nil
}

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

func newQDynamicPropertyChangeEventFromPointer(ptr unsafe.Pointer) *QDynamicPropertyChangeEvent {
	var n = NewQDynamicPropertyChangeEventFromPointer(ptr)
	return n
}

func (ptr *QDynamicPropertyChangeEvent) QDynamicPropertyChangeEvent_PTR() *QDynamicPropertyChangeEvent {
	return ptr
}

func NewQDynamicPropertyChangeEvent(name string) *QDynamicPropertyChangeEvent {
	defer qt.Recovering("QDynamicPropertyChangeEvent::QDynamicPropertyChangeEvent")

	return newQDynamicPropertyChangeEventFromPointer(C.QDynamicPropertyChangeEvent_NewQDynamicPropertyChangeEvent(C.CString(name)))
}

func (ptr *QDynamicPropertyChangeEvent) PropertyName() string {
	defer qt.Recovering("QDynamicPropertyChangeEvent::propertyName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QDynamicPropertyChangeEvent_PropertyName(ptr.Pointer()))
	}
	return ""
}

type QEasingCurve struct {
	ptr unsafe.Pointer
}

type QEasingCurve_ITF interface {
	QEasingCurve_PTR() *QEasingCurve
}

func (p *QEasingCurve) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QEasingCurve) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQEasingCurve(ptr QEasingCurve_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEasingCurve_PTR().Pointer()
	}
	return nil
}

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

func newQEasingCurveFromPointer(ptr unsafe.Pointer) *QEasingCurve {
	var n = NewQEasingCurveFromPointer(ptr)
	return n
}

func (ptr *QEasingCurve) QEasingCurve_PTR() *QEasingCurve {
	return ptr
}

//QEasingCurve::Type
type QEasingCurve__Type int64

const (
	QEasingCurve__Linear       = QEasingCurve__Type(0)
	QEasingCurve__InQuad       = QEasingCurve__Type(1)
	QEasingCurve__OutQuad      = QEasingCurve__Type(2)
	QEasingCurve__InOutQuad    = QEasingCurve__Type(3)
	QEasingCurve__OutInQuad    = QEasingCurve__Type(4)
	QEasingCurve__InCubic      = QEasingCurve__Type(5)
	QEasingCurve__OutCubic     = QEasingCurve__Type(6)
	QEasingCurve__InOutCubic   = QEasingCurve__Type(7)
	QEasingCurve__OutInCubic   = QEasingCurve__Type(8)
	QEasingCurve__InQuart      = QEasingCurve__Type(9)
	QEasingCurve__OutQuart     = QEasingCurve__Type(10)
	QEasingCurve__InOutQuart   = QEasingCurve__Type(11)
	QEasingCurve__OutInQuart   = QEasingCurve__Type(12)
	QEasingCurve__InQuint      = QEasingCurve__Type(13)
	QEasingCurve__OutQuint     = QEasingCurve__Type(14)
	QEasingCurve__InOutQuint   = QEasingCurve__Type(15)
	QEasingCurve__OutInQuint   = QEasingCurve__Type(16)
	QEasingCurve__InSine       = QEasingCurve__Type(17)
	QEasingCurve__OutSine      = QEasingCurve__Type(18)
	QEasingCurve__InOutSine    = QEasingCurve__Type(19)
	QEasingCurve__OutInSine    = QEasingCurve__Type(20)
	QEasingCurve__InExpo       = QEasingCurve__Type(21)
	QEasingCurve__OutExpo      = QEasingCurve__Type(22)
	QEasingCurve__InOutExpo    = QEasingCurve__Type(23)
	QEasingCurve__OutInExpo    = QEasingCurve__Type(24)
	QEasingCurve__InCirc       = QEasingCurve__Type(25)
	QEasingCurve__OutCirc      = QEasingCurve__Type(26)
	QEasingCurve__InOutCirc    = QEasingCurve__Type(27)
	QEasingCurve__OutInCirc    = QEasingCurve__Type(28)
	QEasingCurve__InElastic    = QEasingCurve__Type(29)
	QEasingCurve__OutElastic   = QEasingCurve__Type(30)
	QEasingCurve__InOutElastic = QEasingCurve__Type(31)
	QEasingCurve__OutInElastic = QEasingCurve__Type(32)
	QEasingCurve__InBack       = QEasingCurve__Type(33)
	QEasingCurve__OutBack      = QEasingCurve__Type(34)
	QEasingCurve__InOutBack    = QEasingCurve__Type(35)
	QEasingCurve__OutInBack    = QEasingCurve__Type(36)
	QEasingCurve__InBounce     = QEasingCurve__Type(37)
	QEasingCurve__OutBounce    = QEasingCurve__Type(38)
	QEasingCurve__InOutBounce  = QEasingCurve__Type(39)
	QEasingCurve__OutInBounce  = QEasingCurve__Type(40)
	QEasingCurve__InCurve      = QEasingCurve__Type(41)
	QEasingCurve__OutCurve     = QEasingCurve__Type(42)
	QEasingCurve__SineCurve    = QEasingCurve__Type(43)
	QEasingCurve__CosineCurve  = QEasingCurve__Type(44)
	QEasingCurve__BezierSpline = QEasingCurve__Type(45)
	QEasingCurve__TCBSpline    = QEasingCurve__Type(46)
	QEasingCurve__Custom       = QEasingCurve__Type(47)
	QEasingCurve__NCurveTypes  = QEasingCurve__Type(48)
)

func NewQEasingCurve3(other QEasingCurve_ITF) *QEasingCurve {
	defer qt.Recovering("QEasingCurve::QEasingCurve")

	return newQEasingCurveFromPointer(C.QEasingCurve_NewQEasingCurve3(PointerFromQEasingCurve(other)))
}

func NewQEasingCurve(ty QEasingCurve__Type) *QEasingCurve {
	defer qt.Recovering("QEasingCurve::QEasingCurve")

	return newQEasingCurveFromPointer(C.QEasingCurve_NewQEasingCurve(C.int(ty)))
}

func NewQEasingCurve2(other QEasingCurve_ITF) *QEasingCurve {
	defer qt.Recovering("QEasingCurve::QEasingCurve")

	return newQEasingCurveFromPointer(C.QEasingCurve_NewQEasingCurve2(PointerFromQEasingCurve(other)))
}

func (ptr *QEasingCurve) AddCubicBezierSegment(c1 QPointF_ITF, c2 QPointF_ITF, endPoint QPointF_ITF) {
	defer qt.Recovering("QEasingCurve::addCubicBezierSegment")

	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) {
	defer qt.Recovering("QEasingCurve::addTCBSegment")

	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 {
	defer qt.Recovering("QEasingCurve::amplitude")

	if ptr.Pointer() != nil {
		return float64(C.QEasingCurve_Amplitude(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEasingCurve) Overshoot() float64 {
	defer qt.Recovering("QEasingCurve::overshoot")

	if ptr.Pointer() != nil {
		return float64(C.QEasingCurve_Overshoot(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEasingCurve) Period() float64 {
	defer qt.Recovering("QEasingCurve::period")

	if ptr.Pointer() != nil {
		return float64(C.QEasingCurve_Period(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEasingCurve) SetAmplitude(amplitude float64) {
	defer qt.Recovering("QEasingCurve::setAmplitude")

	if ptr.Pointer() != nil {
		C.QEasingCurve_SetAmplitude(ptr.Pointer(), C.double(amplitude))
	}
}

func (ptr *QEasingCurve) SetOvershoot(overshoot float64) {
	defer qt.Recovering("QEasingCurve::setOvershoot")

	if ptr.Pointer() != nil {
		C.QEasingCurve_SetOvershoot(ptr.Pointer(), C.double(overshoot))
	}
}

func (ptr *QEasingCurve) SetPeriod(period float64) {
	defer qt.Recovering("QEasingCurve::setPeriod")

	if ptr.Pointer() != nil {
		C.QEasingCurve_SetPeriod(ptr.Pointer(), C.double(period))
	}
}

func (ptr *QEasingCurve) SetType(ty QEasingCurve__Type) {
	defer qt.Recovering("QEasingCurve::setType")

	if ptr.Pointer() != nil {
		C.QEasingCurve_SetType(ptr.Pointer(), C.int(ty))
	}
}

func (ptr *QEasingCurve) Swap(other QEasingCurve_ITF) {
	defer qt.Recovering("QEasingCurve::swap")

	if ptr.Pointer() != nil {
		C.QEasingCurve_Swap(ptr.Pointer(), PointerFromQEasingCurve(other))
	}
}

func (ptr *QEasingCurve) Type() QEasingCurve__Type {
	defer qt.Recovering("QEasingCurve::type")

	if ptr.Pointer() != nil {
		return QEasingCurve__Type(C.QEasingCurve_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEasingCurve) ValueForProgress(progress float64) float64 {
	defer qt.Recovering("QEasingCurve::valueForProgress")

	if ptr.Pointer() != nil {
		return float64(C.QEasingCurve_ValueForProgress(ptr.Pointer(), C.double(progress)))
	}
	return 0
}

func (ptr *QEasingCurve) DestroyQEasingCurve() {
	defer qt.Recovering("QEasingCurve::~QEasingCurve")

	if ptr.Pointer() != nil {
		C.QEasingCurve_DestroyQEasingCurve(ptr.Pointer())
	}
}

type QElapsedTimer struct {
	ptr unsafe.Pointer
}

type QElapsedTimer_ITF interface {
	QElapsedTimer_PTR() *QElapsedTimer
}

func (p *QElapsedTimer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QElapsedTimer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQElapsedTimer(ptr QElapsedTimer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QElapsedTimer_PTR().Pointer()
	}
	return nil
}

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

func newQElapsedTimerFromPointer(ptr unsafe.Pointer) *QElapsedTimer {
	var n = NewQElapsedTimerFromPointer(ptr)
	return n
}

func (ptr *QElapsedTimer) QElapsedTimer_PTR() *QElapsedTimer {
	return ptr
}

//QElapsedTimer::ClockType
type QElapsedTimer__ClockType int64

const (
	QElapsedTimer__SystemTime         = QElapsedTimer__ClockType(0)
	QElapsedTimer__MonotonicClock     = QElapsedTimer__ClockType(1)
	QElapsedTimer__TickCounter        = QElapsedTimer__ClockType(2)
	QElapsedTimer__MachAbsoluteTime   = QElapsedTimer__ClockType(3)
	QElapsedTimer__PerformanceCounter = QElapsedTimer__ClockType(4)
)

func NewQElapsedTimer() *QElapsedTimer {
	defer qt.Recovering("QElapsedTimer::QElapsedTimer")

	return newQElapsedTimerFromPointer(C.QElapsedTimer_NewQElapsedTimer())
}

func (ptr *QElapsedTimer) HasExpired(timeout int64) bool {
	defer qt.Recovering("QElapsedTimer::hasExpired")

	if ptr.Pointer() != nil {
		return C.QElapsedTimer_HasExpired(ptr.Pointer(), C.longlong(timeout)) != 0
	}
	return false
}

func (ptr *QElapsedTimer) Invalidate() {
	defer qt.Recovering("QElapsedTimer::invalidate")

	if ptr.Pointer() != nil {
		C.QElapsedTimer_Invalidate(ptr.Pointer())
	}
}

func (ptr *QElapsedTimer) IsValid() bool {
	defer qt.Recovering("QElapsedTimer::isValid")

	if ptr.Pointer() != nil {
		return C.QElapsedTimer_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func QElapsedTimer_ClockType() QElapsedTimer__ClockType {
	defer qt.Recovering("QElapsedTimer::clockType")

	return QElapsedTimer__ClockType(C.QElapsedTimer_QElapsedTimer_ClockType())
}

func (ptr *QElapsedTimer) Elapsed() int64 {
	defer qt.Recovering("QElapsedTimer::elapsed")

	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_Elapsed(ptr.Pointer()))
	}
	return 0
}

func QElapsedTimer_IsMonotonic() bool {
	defer qt.Recovering("QElapsedTimer::isMonotonic")

	return C.QElapsedTimer_QElapsedTimer_IsMonotonic() != 0
}

func (ptr *QElapsedTimer) MsecsSinceReference() int64 {
	defer qt.Recovering("QElapsedTimer::msecsSinceReference")

	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_MsecsSinceReference(ptr.Pointer()))
	}
	return 0
}

func (ptr *QElapsedTimer) MsecsTo(other QElapsedTimer_ITF) int64 {
	defer qt.Recovering("QElapsedTimer::msecsTo")

	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_MsecsTo(ptr.Pointer(), PointerFromQElapsedTimer(other)))
	}
	return 0
}

func (ptr *QElapsedTimer) NsecsElapsed() int64 {
	defer qt.Recovering("QElapsedTimer::nsecsElapsed")

	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_NsecsElapsed(ptr.Pointer()))
	}
	return 0
}

func (ptr *QElapsedTimer) Restart() int64 {
	defer qt.Recovering("QElapsedTimer::restart")

	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_Restart(ptr.Pointer()))
	}
	return 0
}

func (ptr *QElapsedTimer) SecsTo(other QElapsedTimer_ITF) int64 {
	defer qt.Recovering("QElapsedTimer::secsTo")

	if ptr.Pointer() != nil {
		return int64(C.QElapsedTimer_SecsTo(ptr.Pointer(), PointerFromQElapsedTimer(other)))
	}
	return 0
}

func (ptr *QElapsedTimer) Start() {
	defer qt.Recovering("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 (p *QEnableSharedFromThis) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QEnableSharedFromThis) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQEnableSharedFromThis(ptr QEnableSharedFromThis_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEnableSharedFromThis_PTR().Pointer()
	}
	return nil
}

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

func newQEnableSharedFromThisFromPointer(ptr unsafe.Pointer) *QEnableSharedFromThis {
	var n = NewQEnableSharedFromThisFromPointer(ptr)
	return n
}

func (ptr *QEnableSharedFromThis) QEnableSharedFromThis_PTR() *QEnableSharedFromThis {
	return ptr
}

type QEvent struct {
	ptr unsafe.Pointer
}

type QEvent_ITF interface {
	QEvent_PTR() *QEvent
}

func (p *QEvent) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QEvent) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQEvent(ptr QEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEvent_PTR().Pointer()
	}
	return nil
}

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

func newQEventFromPointer(ptr unsafe.Pointer) *QEvent {
	var n = NewQEventFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QEvent_") {
		n.SetObjectNameAbs("QEvent_" + qt.Identifier())
	}
	return n
}

func (ptr *QEvent) QEvent_PTR() *QEvent {
	return ptr
}

//QEvent::Type
type QEvent__Type int64

const (
	QEvent__None                             = QEvent__Type(0)
	QEvent__Timer                            = QEvent__Type(1)
	QEvent__MouseButtonPress                 = QEvent__Type(2)
	QEvent__MouseButtonRelease               = QEvent__Type(3)
	QEvent__MouseButtonDblClick              = QEvent__Type(4)
	QEvent__MouseMove                        = QEvent__Type(5)
	QEvent__KeyPress                         = QEvent__Type(6)
	QEvent__KeyRelease                       = QEvent__Type(7)
	QEvent__FocusIn                          = QEvent__Type(8)
	QEvent__FocusOut                         = QEvent__Type(9)
	QEvent__FocusAboutToChange               = QEvent__Type(23)
	QEvent__Enter                            = QEvent__Type(10)
	QEvent__Leave                            = QEvent__Type(11)
	QEvent__Paint                            = QEvent__Type(12)
	QEvent__Move                             = QEvent__Type(13)
	QEvent__Resize                           = QEvent__Type(14)
	QEvent__Create                           = QEvent__Type(15)
	QEvent__Destroy                          = QEvent__Type(16)
	QEvent__Show                             = QEvent__Type(17)
	QEvent__Hide                             = QEvent__Type(18)
	QEvent__Close                            = QEvent__Type(19)
	QEvent__Quit                             = QEvent__Type(20)
	QEvent__ParentChange                     = QEvent__Type(21)
	QEvent__ParentAboutToChange              = QEvent__Type(131)
	QEvent__ThreadChange                     = QEvent__Type(22)
	QEvent__WindowActivate                   = QEvent__Type(24)
	QEvent__WindowDeactivate                 = QEvent__Type(25)
	QEvent__ShowToParent                     = QEvent__Type(26)
	QEvent__HideToParent                     = QEvent__Type(27)
	QEvent__Wheel                            = QEvent__Type(31)
	QEvent__WindowTitleChange                = QEvent__Type(33)
	QEvent__WindowIconChange                 = QEvent__Type(34)
	QEvent__ApplicationWindowIconChange      = QEvent__Type(35)
	QEvent__ApplicationFontChange            = QEvent__Type(36)
	QEvent__ApplicationLayoutDirectionChange = QEvent__Type(37)
	QEvent__ApplicationPaletteChange         = QEvent__Type(38)
	QEvent__PaletteChange                    = QEvent__Type(39)
	QEvent__Clipboard                        = QEvent__Type(40)
	QEvent__Speech                           = QEvent__Type(42)
	QEvent__MetaCall                         = QEvent__Type(43)
	QEvent__SockAct                          = QEvent__Type(50)
	QEvent__WinEventAct                      = QEvent__Type(132)
	QEvent__DeferredDelete                   = QEvent__Type(52)
	QEvent__DragEnter                        = QEvent__Type(60)
	QEvent__DragMove                         = QEvent__Type(61)
	QEvent__DragLeave                        = QEvent__Type(62)
	QEvent__Drop                             = QEvent__Type(63)
	QEvent__DragResponse                     = QEvent__Type(64)
	QEvent__ChildAdded                       = QEvent__Type(68)
	QEvent__ChildPolished                    = QEvent__Type(69)
	QEvent__ChildRemoved                     = QEvent__Type(71)
	QEvent__ShowWindowRequest                = QEvent__Type(73)
	QEvent__PolishRequest                    = QEvent__Type(74)
	QEvent__Polish                           = QEvent__Type(75)
	QEvent__LayoutRequest                    = QEvent__Type(76)
	QEvent__UpdateRequest                    = QEvent__Type(77)
	QEvent__UpdateLater                      = QEvent__Type(78)
	QEvent__EmbeddingControl                 = QEvent__Type(79)
	QEvent__ActivateControl                  = QEvent__Type(80)
	QEvent__DeactivateControl                = QEvent__Type(81)
	QEvent__ContextMenu                      = QEvent__Type(82)
	QEvent__InputMethod                      = QEvent__Type(83)
	QEvent__TabletMove                       = QEvent__Type(87)
	QEvent__LocaleChange                     = QEvent__Type(88)
	QEvent__LanguageChange                   = QEvent__Type(89)
	QEvent__LayoutDirectionChange            = QEvent__Type(90)
	QEvent__Style                            = QEvent__Type(91)
	QEvent__TabletPress                      = QEvent__Type(92)
	QEvent__TabletRelease                    = QEvent__Type(93)
	QEvent__OkRequest                        = QEvent__Type(94)
	QEvent__HelpRequest                      = QEvent__Type(95)
	QEvent__IconDrag                         = QEvent__Type(96)
	QEvent__FontChange                       = QEvent__Type(97)
	QEvent__EnabledChange                    = QEvent__Type(98)
	QEvent__ActivationChange                 = QEvent__Type(99)
	QEvent__StyleChange                      = QEvent__Type(100)
	QEvent__IconTextChange                   = QEvent__Type(101)
	QEvent__ModifiedChange                   = QEvent__Type(102)
	QEvent__MouseTrackingChange              = QEvent__Type(109)
	QEvent__WindowBlocked                    = QEvent__Type(103)
	QEvent__WindowUnblocked                  = QEvent__Type(104)
	QEvent__WindowStateChange                = QEvent__Type(105)
	QEvent__ReadOnlyChange                   = QEvent__Type(106)
	QEvent__ToolTip                          = QEvent__Type(110)
	QEvent__WhatsThis                        = QEvent__Type(111)
	QEvent__StatusTip                        = QEvent__Type(112)
	QEvent__ActionChanged                    = QEvent__Type(113)
	QEvent__ActionAdded                      = QEvent__Type(114)
	QEvent__ActionRemoved                    = QEvent__Type(115)
	QEvent__FileOpen                         = QEvent__Type(116)
	QEvent__Shortcut                         = QEvent__Type(117)
	QEvent__ShortcutOverride                 = QEvent__Type(51)
	QEvent__WhatsThisClicked                 = QEvent__Type(118)
	QEvent__ToolBarChange                    = QEvent__Type(120)
	QEvent__ApplicationActivate              = QEvent__Type(121)
	QEvent__ApplicationActivated             = QEvent__Type(QEvent__ApplicationActivate)
	QEvent__ApplicationDeactivate            = QEvent__Type(122)
	QEvent__ApplicationDeactivated           = QEvent__Type(QEvent__ApplicationDeactivate)
	QEvent__QueryWhatsThis                   = QEvent__Type(123)
	QEvent__EnterWhatsThisMode               = QEvent__Type(124)
	QEvent__LeaveWhatsThisMode               = QEvent__Type(125)
	QEvent__ZOrderChange                     = QEvent__Type(126)
	QEvent__HoverEnter                       = QEvent__Type(127)
	QEvent__HoverLeave                       = QEvent__Type(128)
	QEvent__HoverMove                        = QEvent__Type(129)
	QEvent__EnterEditFocus                   = QEvent__Type(150)
	QEvent__LeaveEditFocus                   = QEvent__Type(151)
	QEvent__AcceptDropsChange                = QEvent__Type(152)
	QEvent__ZeroTimerEvent                   = QEvent__Type(154)
	QEvent__GraphicsSceneMouseMove           = QEvent__Type(155)
	QEvent__GraphicsSceneMousePress          = QEvent__Type(156)
	QEvent__GraphicsSceneMouseRelease        = QEvent__Type(157)
	QEvent__GraphicsSceneMouseDoubleClick    = QEvent__Type(158)
	QEvent__GraphicsSceneContextMenu         = QEvent__Type(159)
	QEvent__GraphicsSceneHoverEnter          = QEvent__Type(160)
	QEvent__GraphicsSceneHoverMove           = QEvent__Type(161)
	QEvent__GraphicsSceneHoverLeave          = QEvent__Type(162)
	QEvent__GraphicsSceneHelp                = QEvent__Type(163)
	QEvent__GraphicsSceneDragEnter           = QEvent__Type(164)
	QEvent__GraphicsSceneDragMove            = QEvent__Type(165)
	QEvent__GraphicsSceneDragLeave           = QEvent__Type(166)
	QEvent__GraphicsSceneDrop                = QEvent__Type(167)
	QEvent__GraphicsSceneWheel               = QEvent__Type(168)
	QEvent__KeyboardLayoutChange             = QEvent__Type(169)
	QEvent__DynamicPropertyChange            = QEvent__Type(170)
	QEvent__TabletEnterProximity             = QEvent__Type(171)
	QEvent__TabletLeaveProximity             = QEvent__Type(172)
	QEvent__NonClientAreaMouseMove           = QEvent__Type(173)
	QEvent__NonClientAreaMouseButtonPress    = QEvent__Type(174)
	QEvent__NonClientAreaMouseButtonRelease  = QEvent__Type(175)
	QEvent__NonClientAreaMouseButtonDblClick = QEvent__Type(176)
	QEvent__MacSizeChange                    = QEvent__Type(177)
	QEvent__ContentsRectChange               = QEvent__Type(178)
	QEvent__MacGLWindowChange                = QEvent__Type(179)
	QEvent__FutureCallOut                    = QEvent__Type(180)
	QEvent__GraphicsSceneResize              = QEvent__Type(181)
	QEvent__GraphicsSceneMove                = QEvent__Type(182)
	QEvent__CursorChange                     = QEvent__Type(183)
	QEvent__ToolTipChange                    = QEvent__Type(184)
	QEvent__NetworkReplyUpdated              = QEvent__Type(185)
	QEvent__GrabMouse                        = QEvent__Type(186)
	QEvent__UngrabMouse                      = QEvent__Type(187)
	QEvent__GrabKeyboard                     = QEvent__Type(188)
	QEvent__UngrabKeyboard                   = QEvent__Type(189)
	QEvent__MacGLClearDrawable               = QEvent__Type(191)
	QEvent__StateMachineSignal               = QEvent__Type(192)
	QEvent__StateMachineWrapped              = QEvent__Type(193)
	QEvent__TouchBegin                       = QEvent__Type(194)
	QEvent__TouchUpdate                      = QEvent__Type(195)
	QEvent__TouchEnd                         = QEvent__Type(196)
	QEvent__NativeGesture                    = QEvent__Type(197)
	QEvent__RequestSoftwareInputPanel        = QEvent__Type(199)
	QEvent__CloseSoftwareInputPanel          = QEvent__Type(200)
	QEvent__WinIdChange                      = QEvent__Type(203)
	QEvent__Gesture                          = QEvent__Type(198)
	QEvent__GestureOverride                  = QEvent__Type(202)
	QEvent__ScrollPrepare                    = QEvent__Type(204)
	QEvent__Scroll                           = QEvent__Type(205)
	QEvent__Expose                           = QEvent__Type(206)
	QEvent__InputMethodQuery                 = QEvent__Type(207)
	QEvent__OrientationChange                = QEvent__Type(208)
	QEvent__TouchCancel                      = QEvent__Type(209)
	QEvent__ThemeChange                      = QEvent__Type(210)
	QEvent__SockClose                        = QEvent__Type(211)
	QEvent__PlatformPanel                    = QEvent__Type(212)
	QEvent__StyleAnimationUpdate             = QEvent__Type(213)
	QEvent__ApplicationStateChange           = QEvent__Type(214)
	QEvent__WindowChangeInternal             = QEvent__Type(215)
	QEvent__ScreenChangeInternal             = QEvent__Type(216)
	QEvent__PlatformSurface                  = QEvent__Type(217)
	QEvent__User                             = QEvent__Type(1000)
	QEvent__MaxUser                          = QEvent__Type(65535)
)

func NewQEvent(ty QEvent__Type) *QEvent {
	defer qt.Recovering("QEvent::QEvent")

	return newQEventFromPointer(C.QEvent_NewQEvent(C.int(ty)))
}

func (ptr *QEvent) Accept() {
	defer qt.Recovering("QEvent::accept")

	if ptr.Pointer() != nil {
		C.QEvent_Accept(ptr.Pointer())
	}
}

func (ptr *QEvent) Ignore() {
	defer qt.Recovering("QEvent::ignore")

	if ptr.Pointer() != nil {
		C.QEvent_Ignore(ptr.Pointer())
	}
}

func (ptr *QEvent) IsAccepted() bool {
	defer qt.Recovering("QEvent::isAccepted")

	if ptr.Pointer() != nil {
		return C.QEvent_IsAccepted(ptr.Pointer()) != 0
	}
	return false
}

func QEvent_RegisterEventType(hint int) int {
	defer qt.Recovering("QEvent::registerEventType")

	return int(C.QEvent_QEvent_RegisterEventType(C.int(hint)))
}

func (ptr *QEvent) SetAccepted(accepted bool) {
	defer qt.Recovering("QEvent::setAccepted")

	if ptr.Pointer() != nil {
		C.QEvent_SetAccepted(ptr.Pointer(), C.int(qt.GoBoolToInt(accepted)))
	}
}

func (ptr *QEvent) Spontaneous() bool {
	defer qt.Recovering("QEvent::spontaneous")

	if ptr.Pointer() != nil {
		return C.QEvent_Spontaneous(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QEvent) Type() QEvent__Type {
	defer qt.Recovering("QEvent::type")

	if ptr.Pointer() != nil {
		return QEvent__Type(C.QEvent_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEvent) DestroyQEvent() {
	defer qt.Recovering("QEvent::~QEvent")

	if ptr.Pointer() != nil {
		C.QEvent_DestroyQEvent(ptr.Pointer())
	}
}

func (ptr *QEvent) ObjectNameAbs() string {
	defer qt.Recovering("QEvent::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QEvent_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QEvent) SetObjectNameAbs(name string) {
	defer qt.Recovering("QEvent::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QEvent_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QEventLoop struct {
	QObject
}

type QEventLoop_ITF interface {
	QObject_ITF
	QEventLoop_PTR() *QEventLoop
}

func PointerFromQEventLoop(ptr QEventLoop_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEventLoop_PTR().Pointer()
	}
	return nil
}

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

func newQEventLoopFromPointer(ptr unsafe.Pointer) *QEventLoop {
	var n = NewQEventLoopFromPointer(ptr)
	for len(n.ObjectName()) < len("QEventLoop_") {
		n.SetObjectName("QEventLoop_" + qt.Identifier())
	}
	return n
}

func (ptr *QEventLoop) QEventLoop_PTR() *QEventLoop {
	return ptr
}

//QEventLoop::ProcessEventsFlag
type QEventLoop__ProcessEventsFlag int64

const (
	QEventLoop__AllEvents              = QEventLoop__ProcessEventsFlag(0x00)
	QEventLoop__ExcludeUserInputEvents = QEventLoop__ProcessEventsFlag(0x01)
	QEventLoop__ExcludeSocketNotifiers = QEventLoop__ProcessEventsFlag(0x02)
	QEventLoop__WaitForMoreEvents      = QEventLoop__ProcessEventsFlag(0x04)
	QEventLoop__X11ExcludeTimers       = QEventLoop__ProcessEventsFlag(0x08)
	QEventLoop__EventLoopExec          = QEventLoop__ProcessEventsFlag(0x20)
	QEventLoop__DialogExec             = QEventLoop__ProcessEventsFlag(0x40)
)

func NewQEventLoop(parent QObject_ITF) *QEventLoop {
	defer qt.Recovering("QEventLoop::QEventLoop")

	return newQEventLoopFromPointer(C.QEventLoop_NewQEventLoop(PointerFromQObject(parent)))
}

func (ptr *QEventLoop) Event(event QEvent_ITF) bool {
	defer qt.Recovering("QEventLoop::event")

	if ptr.Pointer() != nil {
		return C.QEventLoop_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QEventLoop) Exec(flags QEventLoop__ProcessEventsFlag) int {
	defer qt.Recovering("QEventLoop::exec")

	if ptr.Pointer() != nil {
		return int(C.QEventLoop_Exec(ptr.Pointer(), C.int(flags)))
	}
	return 0
}

func (ptr *QEventLoop) Exit(returnCode int) {
	defer qt.Recovering("QEventLoop::exit")

	if ptr.Pointer() != nil {
		C.QEventLoop_Exit(ptr.Pointer(), C.int(returnCode))
	}
}

func (ptr *QEventLoop) IsRunning() bool {
	defer qt.Recovering("QEventLoop::isRunning")

	if ptr.Pointer() != nil {
		return C.QEventLoop_IsRunning(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QEventLoop) ProcessEvents(flags QEventLoop__ProcessEventsFlag) bool {
	defer qt.Recovering("QEventLoop::processEvents")

	if ptr.Pointer() != nil {
		return C.QEventLoop_ProcessEvents(ptr.Pointer(), C.int(flags)) != 0
	}
	return false
}

func (ptr *QEventLoop) ProcessEvents2(flags QEventLoop__ProcessEventsFlag, maxTime int) {
	defer qt.Recovering("QEventLoop::processEvents")

	if ptr.Pointer() != nil {
		C.QEventLoop_ProcessEvents2(ptr.Pointer(), C.int(flags), C.int(maxTime))
	}
}

func (ptr *QEventLoop) Quit() {
	defer qt.Recovering("QEventLoop::quit")

	if ptr.Pointer() != nil {
		C.QEventLoop_Quit(ptr.Pointer())
	}
}

func (ptr *QEventLoop) WakeUp() {
	defer qt.Recovering("QEventLoop::wakeUp")

	if ptr.Pointer() != nil {
		C.QEventLoop_WakeUp(ptr.Pointer())
	}
}

func (ptr *QEventLoop) DestroyQEventLoop() {
	defer qt.Recovering("QEventLoop::~QEventLoop")

	if ptr.Pointer() != nil {
		C.QEventLoop_DestroyQEventLoop(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QEventLoop) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QEventLoop::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QEventLoop) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QEventLoop::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQEventLoopTimerEvent
func callbackQEventLoopTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QEventLoop::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQEventLoopFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QEventLoop) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QEventLoop::timerEvent")

	if ptr.Pointer() != nil {
		C.QEventLoop_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QEventLoop) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QEventLoop::timerEvent")

	if ptr.Pointer() != nil {
		C.QEventLoop_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QEventLoop) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QEventLoop::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QEventLoop) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QEventLoop::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQEventLoopChildEvent
func callbackQEventLoopChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QEventLoop::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQEventLoopFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QEventLoop) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QEventLoop::childEvent")

	if ptr.Pointer() != nil {
		C.QEventLoop_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QEventLoop) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QEventLoop::childEvent")

	if ptr.Pointer() != nil {
		C.QEventLoop_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QEventLoop) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QEventLoop::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QEventLoop) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QEventLoop::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQEventLoopCustomEvent
func callbackQEventLoopCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QEventLoop::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQEventLoopFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QEventLoop) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QEventLoop::customEvent")

	if ptr.Pointer() != nil {
		C.QEventLoop_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QEventLoop) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QEventLoop::customEvent")

	if ptr.Pointer() != nil {
		C.QEventLoop_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QEventLoopLocker struct {
	ptr unsafe.Pointer
}

type QEventLoopLocker_ITF interface {
	QEventLoopLocker_PTR() *QEventLoopLocker
}

func (p *QEventLoopLocker) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QEventLoopLocker) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQEventLoopLocker(ptr QEventLoopLocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEventLoopLocker_PTR().Pointer()
	}
	return nil
}

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

func newQEventLoopLockerFromPointer(ptr unsafe.Pointer) *QEventLoopLocker {
	var n = NewQEventLoopLockerFromPointer(ptr)
	return n
}

func (ptr *QEventLoopLocker) QEventLoopLocker_PTR() *QEventLoopLocker {
	return ptr
}

func NewQEventLoopLocker() *QEventLoopLocker {
	defer qt.Recovering("QEventLoopLocker::QEventLoopLocker")

	return newQEventLoopLockerFromPointer(C.QEventLoopLocker_NewQEventLoopLocker())
}

func NewQEventLoopLocker2(loop QEventLoop_ITF) *QEventLoopLocker {
	defer qt.Recovering("QEventLoopLocker::QEventLoopLocker")

	return newQEventLoopLockerFromPointer(C.QEventLoopLocker_NewQEventLoopLocker2(PointerFromQEventLoop(loop)))
}

func NewQEventLoopLocker3(thread QThread_ITF) *QEventLoopLocker {
	defer qt.Recovering("QEventLoopLocker::QEventLoopLocker")

	return newQEventLoopLockerFromPointer(C.QEventLoopLocker_NewQEventLoopLocker3(PointerFromQThread(thread)))
}

func (ptr *QEventLoopLocker) DestroyQEventLoopLocker() {
	defer qt.Recovering("QEventLoopLocker::~QEventLoopLocker")

	if ptr.Pointer() != nil {
		C.QEventLoopLocker_DestroyQEventLoopLocker(ptr.Pointer())
	}
}

type QEventTransition struct {
	QAbstractTransition
}

type QEventTransition_ITF interface {
	QAbstractTransition_ITF
	QEventTransition_PTR() *QEventTransition
}

func PointerFromQEventTransition(ptr QEventTransition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEventTransition_PTR().Pointer()
	}
	return nil
}

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

func newQEventTransitionFromPointer(ptr unsafe.Pointer) *QEventTransition {
	var n = NewQEventTransitionFromPointer(ptr)
	for len(n.ObjectName()) < len("QEventTransition_") {
		n.SetObjectName("QEventTransition_" + qt.Identifier())
	}
	return n
}

func (ptr *QEventTransition) QEventTransition_PTR() *QEventTransition {
	return ptr
}

func NewQEventTransition2(object QObject_ITF, ty QEvent__Type, sourceState QState_ITF) *QEventTransition {
	defer qt.Recovering("QEventTransition::QEventTransition")

	return newQEventTransitionFromPointer(C.QEventTransition_NewQEventTransition2(PointerFromQObject(object), C.int(ty), PointerFromQState(sourceState)))
}

func NewQEventTransition(sourceState QState_ITF) *QEventTransition {
	defer qt.Recovering("QEventTransition::QEventTransition")

	return newQEventTransitionFromPointer(C.QEventTransition_NewQEventTransition(PointerFromQState(sourceState)))
}

func (ptr *QEventTransition) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QEventTransition::event")

	if ptr.Pointer() != nil {
		return C.QEventTransition_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QEventTransition) EventSource() *QObject {
	defer qt.Recovering("QEventTransition::eventSource")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QEventTransition_EventSource(ptr.Pointer()))
	}
	return nil
}

func (ptr *QEventTransition) EventTest(event QEvent_ITF) bool {
	defer qt.Recovering("QEventTransition::eventTest")

	if ptr.Pointer() != nil {
		return C.QEventTransition_EventTest(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QEventTransition) EventType() QEvent__Type {
	defer qt.Recovering("QEventTransition::eventType")

	if ptr.Pointer() != nil {
		return QEvent__Type(C.QEventTransition_EventType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QEventTransition) ConnectOnTransition(f func(event *QEvent)) {
	defer qt.Recovering("connect QEventTransition::onTransition")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onTransition", f)
	}
}

func (ptr *QEventTransition) DisconnectOnTransition() {
	defer qt.Recovering("disconnect QEventTransition::onTransition")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onTransition")
	}
}

//export callbackQEventTransitionOnTransition
func callbackQEventTransitionOnTransition(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QEventTransition::onTransition")

	if signal := qt.GetSignal(C.GoString(ptrName), "onTransition"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQEventTransitionFromPointer(ptr).OnTransitionDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QEventTransition) OnTransition(event QEvent_ITF) {
	defer qt.Recovering("QEventTransition::onTransition")

	if ptr.Pointer() != nil {
		C.QEventTransition_OnTransition(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QEventTransition) OnTransitionDefault(event QEvent_ITF) {
	defer qt.Recovering("QEventTransition::onTransition")

	if ptr.Pointer() != nil {
		C.QEventTransition_OnTransitionDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QEventTransition) SetEventSource(object QObject_ITF) {
	defer qt.Recovering("QEventTransition::setEventSource")

	if ptr.Pointer() != nil {
		C.QEventTransition_SetEventSource(ptr.Pointer(), PointerFromQObject(object))
	}
}

func (ptr *QEventTransition) SetEventType(ty QEvent__Type) {
	defer qt.Recovering("QEventTransition::setEventType")

	if ptr.Pointer() != nil {
		C.QEventTransition_SetEventType(ptr.Pointer(), C.int(ty))
	}
}

func (ptr *QEventTransition) DestroyQEventTransition() {
	defer qt.Recovering("QEventTransition::~QEventTransition")

	if ptr.Pointer() != nil {
		C.QEventTransition_DestroyQEventTransition(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QEventTransition) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QEventTransition::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QEventTransition) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QEventTransition::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQEventTransitionTimerEvent
func callbackQEventTransitionTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QEventTransition::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQEventTransitionFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QEventTransition) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QEventTransition::timerEvent")

	if ptr.Pointer() != nil {
		C.QEventTransition_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QEventTransition) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QEventTransition::timerEvent")

	if ptr.Pointer() != nil {
		C.QEventTransition_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QEventTransition) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QEventTransition::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QEventTransition) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QEventTransition::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQEventTransitionChildEvent
func callbackQEventTransitionChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QEventTransition::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQEventTransitionFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QEventTransition) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QEventTransition::childEvent")

	if ptr.Pointer() != nil {
		C.QEventTransition_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QEventTransition) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QEventTransition::childEvent")

	if ptr.Pointer() != nil {
		C.QEventTransition_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QEventTransition) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QEventTransition::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QEventTransition) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QEventTransition::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQEventTransitionCustomEvent
func callbackQEventTransitionCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QEventTransition::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQEventTransitionFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QEventTransition) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QEventTransition::customEvent")

	if ptr.Pointer() != nil {
		C.QEventTransition_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QEventTransition) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QEventTransition::customEvent")

	if ptr.Pointer() != nil {
		C.QEventTransition_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QException struct {
	ptr unsafe.Pointer
}

type QException_ITF interface {
	QException_PTR() *QException
}

func (p *QException) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QException) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQException(ptr QException_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QException_PTR().Pointer()
	}
	return nil
}

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

func newQExceptionFromPointer(ptr unsafe.Pointer) *QException {
	var n = NewQExceptionFromPointer(ptr)
	return n
}

func (ptr *QException) QException_PTR() *QException {
	return ptr
}

type QExplicitlySharedDataPointer struct {
	ptr unsafe.Pointer
}

type QExplicitlySharedDataPointer_ITF interface {
	QExplicitlySharedDataPointer_PTR() *QExplicitlySharedDataPointer
}

func (p *QExplicitlySharedDataPointer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QExplicitlySharedDataPointer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQExplicitlySharedDataPointer(ptr QExplicitlySharedDataPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QExplicitlySharedDataPointer_PTR().Pointer()
	}
	return nil
}

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

func newQExplicitlySharedDataPointerFromPointer(ptr unsafe.Pointer) *QExplicitlySharedDataPointer {
	var n = NewQExplicitlySharedDataPointerFromPointer(ptr)
	return n
}

func (ptr *QExplicitlySharedDataPointer) QExplicitlySharedDataPointer_PTR() *QExplicitlySharedDataPointer {
	return ptr
}

type QFile struct {
	QFileDevice
}

type QFile_ITF interface {
	QFileDevice_ITF
	QFile_PTR() *QFile
}

func PointerFromQFile(ptr QFile_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFile_PTR().Pointer()
	}
	return nil
}

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

func newQFileFromPointer(ptr unsafe.Pointer) *QFile {
	var n = NewQFileFromPointer(ptr)
	for len(n.ObjectName()) < len("QFile_") {
		n.SetObjectName("QFile_" + qt.Identifier())
	}
	return n
}

func (ptr *QFile) QFile_PTR() *QFile {
	return ptr
}

func NewQFile3(parent QObject_ITF) *QFile {
	defer qt.Recovering("QFile::QFile")

	return newQFileFromPointer(C.QFile_NewQFile3(PointerFromQObject(parent)))
}

func NewQFile(name string) *QFile {
	defer qt.Recovering("QFile::QFile")

	return newQFileFromPointer(C.QFile_NewQFile(C.CString(name)))
}

func NewQFile4(name string, parent QObject_ITF) *QFile {
	defer qt.Recovering("QFile::QFile")

	return newQFileFromPointer(C.QFile_NewQFile4(C.CString(name), PointerFromQObject(parent)))
}

func QFile_Copy2(fileName string, newName string) bool {
	defer qt.Recovering("QFile::copy")

	return C.QFile_QFile_Copy2(C.CString(fileName), C.CString(newName)) != 0
}

func (ptr *QFile) Copy(newName string) bool {
	defer qt.Recovering("QFile::copy")

	if ptr.Pointer() != nil {
		return C.QFile_Copy(ptr.Pointer(), C.CString(newName)) != 0
	}
	return false
}

func QFile_DecodeName(localFileName string) string {
	defer qt.Recovering("QFile::decodeName")

	return C.GoString(C.QFile_QFile_DecodeName(C.CString(localFileName)))
}

func QFile_DecodeName2(localFileName string) string {
	defer qt.Recovering("QFile::decodeName")

	return C.GoString(C.QFile_QFile_DecodeName2(C.CString(localFileName)))
}

func QFile_EncodeName(fileName string) string {
	defer qt.Recovering("QFile::encodeName")

	return C.GoString(C.QFile_QFile_EncodeName(C.CString(fileName)))
}

func QFile_Exists(fileName string) bool {
	defer qt.Recovering("QFile::exists")

	return C.QFile_QFile_Exists(C.CString(fileName)) != 0
}

func (ptr *QFile) Exists2() bool {
	defer qt.Recovering("QFile::exists")

	if ptr.Pointer() != nil {
		return C.QFile_Exists2(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFile) FileName() string {
	defer qt.Recovering("QFile::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFile_FileName(ptr.Pointer()))
	}
	return ""
}

func QFile_Link2(fileName string, linkName string) bool {
	defer qt.Recovering("QFile::link")

	return C.QFile_QFile_Link2(C.CString(fileName), C.CString(linkName)) != 0
}

func (ptr *QFile) Link(linkName string) bool {
	defer qt.Recovering("QFile::link")

	if ptr.Pointer() != nil {
		return C.QFile_Link(ptr.Pointer(), C.CString(linkName)) != 0
	}
	return false
}

func (ptr *QFile) Open(mode QIODevice__OpenModeFlag) bool {
	defer qt.Recovering("QFile::open")

	if ptr.Pointer() != nil {
		return C.QFile_Open(ptr.Pointer(), C.int(mode)) != 0
	}
	return false
}

func (ptr *QFile) Open3(fd int, mode QIODevice__OpenModeFlag, handleFlags QFileDevice__FileHandleFlag) bool {
	defer qt.Recovering("QFile::open")

	if ptr.Pointer() != nil {
		return C.QFile_Open3(ptr.Pointer(), C.int(fd), C.int(mode), C.int(handleFlags)) != 0
	}
	return false
}

func QFile_Permissions2(fileName string) QFileDevice__Permission {
	defer qt.Recovering("QFile::permissions")

	return QFileDevice__Permission(C.QFile_QFile_Permissions2(C.CString(fileName)))
}

func (ptr *QFile) Permissions() QFileDevice__Permission {
	defer qt.Recovering("QFile::permissions")

	if ptr.Pointer() != nil {
		return QFileDevice__Permission(C.QFile_Permissions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFile) Rename(newName string) bool {
	defer qt.Recovering("QFile::rename")

	if ptr.Pointer() != nil {
		return C.QFile_Rename(ptr.Pointer(), C.CString(newName)) != 0
	}
	return false
}

func QFile_Rename2(oldName string, newName string) bool {
	defer qt.Recovering("QFile::rename")

	return C.QFile_QFile_Rename2(C.CString(oldName), C.CString(newName)) != 0
}

func QFile_Resize2(fileName string, sz int64) bool {
	defer qt.Recovering("QFile::resize")

	return C.QFile_QFile_Resize2(C.CString(fileName), C.longlong(sz)) != 0
}

func (ptr *QFile) Resize(sz int64) bool {
	defer qt.Recovering("QFile::resize")

	if ptr.Pointer() != nil {
		return C.QFile_Resize(ptr.Pointer(), C.longlong(sz)) != 0
	}
	return false
}

func (ptr *QFile) SetFileName(name string) {
	defer qt.Recovering("QFile::setFileName")

	if ptr.Pointer() != nil {
		C.QFile_SetFileName(ptr.Pointer(), C.CString(name))
	}
}

func (ptr *QFile) SetPermissions(permissions QFileDevice__Permission) bool {
	defer qt.Recovering("QFile::setPermissions")

	if ptr.Pointer() != nil {
		return C.QFile_SetPermissions(ptr.Pointer(), C.int(permissions)) != 0
	}
	return false
}

func QFile_SetPermissions2(fileName string, permissions QFileDevice__Permission) bool {
	defer qt.Recovering("QFile::setPermissions")

	return C.QFile_QFile_SetPermissions2(C.CString(fileName), C.int(permissions)) != 0
}

func (ptr *QFile) Size() int64 {
	defer qt.Recovering("QFile::size")

	if ptr.Pointer() != nil {
		return int64(C.QFile_Size(ptr.Pointer()))
	}
	return 0
}

func QFile_SymLinkTarget(fileName string) string {
	defer qt.Recovering("QFile::symLinkTarget")

	return C.GoString(C.QFile_QFile_SymLinkTarget(C.CString(fileName)))
}

func (ptr *QFile) SymLinkTarget2() string {
	defer qt.Recovering("QFile::symLinkTarget")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFile_SymLinkTarget2(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFile) DestroyQFile() {
	defer qt.Recovering("QFile::~QFile")

	if ptr.Pointer() != nil {
		C.QFile_DestroyQFile(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QFile) ConnectClose(f func()) {
	defer qt.Recovering("connect QFile::close")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "close", f)
	}
}

func (ptr *QFile) DisconnectClose() {
	defer qt.Recovering("disconnect QFile::close")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "close")
	}
}

//export callbackQFileClose
func callbackQFileClose(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QFile::close")

	if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
		signal.(func())()
	} else {
		NewQFileFromPointer(ptr).CloseDefault()
	}
}

func (ptr *QFile) Close() {
	defer qt.Recovering("QFile::close")

	if ptr.Pointer() != nil {
		C.QFile_Close(ptr.Pointer())
	}
}

func (ptr *QFile) CloseDefault() {
	defer qt.Recovering("QFile::close")

	if ptr.Pointer() != nil {
		C.QFile_CloseDefault(ptr.Pointer())
	}
}

func (ptr *QFile) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QFile::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QFile) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QFile::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQFileTimerEvent
func callbackQFileTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFile::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQFileFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QFile) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QFile::timerEvent")

	if ptr.Pointer() != nil {
		C.QFile_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFile) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QFile::timerEvent")

	if ptr.Pointer() != nil {
		C.QFile_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFile) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QFile::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QFile) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QFile::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQFileChildEvent
func callbackQFileChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFile::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQFileFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QFile) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QFile::childEvent")

	if ptr.Pointer() != nil {
		C.QFile_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFile) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QFile::childEvent")

	if ptr.Pointer() != nil {
		C.QFile_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFile) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QFile::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QFile) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QFile::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQFileCustomEvent
func callbackQFileCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFile::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQFileFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QFile) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QFile::customEvent")

	if ptr.Pointer() != nil {
		C.QFile_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFile) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QFile::customEvent")

	if ptr.Pointer() != nil {
		C.QFile_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QFileDevice struct {
	QIODevice
}

type QFileDevice_ITF interface {
	QIODevice_ITF
	QFileDevice_PTR() *QFileDevice
}

func PointerFromQFileDevice(ptr QFileDevice_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileDevice_PTR().Pointer()
	}
	return nil
}

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

func newQFileDeviceFromPointer(ptr unsafe.Pointer) *QFileDevice {
	var n = NewQFileDeviceFromPointer(ptr)
	for len(n.ObjectName()) < len("QFileDevice_") {
		n.SetObjectName("QFileDevice_" + qt.Identifier())
	}
	return n
}

func (ptr *QFileDevice) QFileDevice_PTR() *QFileDevice {
	return ptr
}

//QFileDevice::FileError
type QFileDevice__FileError int64

const (
	QFileDevice__NoError          = QFileDevice__FileError(0)
	QFileDevice__ReadError        = QFileDevice__FileError(1)
	QFileDevice__WriteError       = QFileDevice__FileError(2)
	QFileDevice__FatalError       = QFileDevice__FileError(3)
	QFileDevice__ResourceError    = QFileDevice__FileError(4)
	QFileDevice__OpenError        = QFileDevice__FileError(5)
	QFileDevice__AbortError       = QFileDevice__FileError(6)
	QFileDevice__TimeOutError     = QFileDevice__FileError(7)
	QFileDevice__UnspecifiedError = QFileDevice__FileError(8)
	QFileDevice__RemoveError      = QFileDevice__FileError(9)
	QFileDevice__RenameError      = QFileDevice__FileError(10)
	QFileDevice__PositionError    = QFileDevice__FileError(11)
	QFileDevice__ResizeError      = QFileDevice__FileError(12)
	QFileDevice__PermissionsError = QFileDevice__FileError(13)
	QFileDevice__CopyError        = QFileDevice__FileError(14)
)

//QFileDevice::FileHandleFlag
type QFileDevice__FileHandleFlag int64

const (
	QFileDevice__AutoCloseHandle = QFileDevice__FileHandleFlag(0x0001)
	QFileDevice__DontCloseHandle = QFileDevice__FileHandleFlag(0)
)

//QFileDevice::MemoryMapFlags
type QFileDevice__MemoryMapFlags int64

const (
	QFileDevice__NoOptions        = QFileDevice__MemoryMapFlags(0)
	QFileDevice__MapPrivateOption = QFileDevice__MemoryMapFlags(0x0001)
)

//QFileDevice::Permission
type QFileDevice__Permission int64

const (
	QFileDevice__ReadOwner  = QFileDevice__Permission(0x4000)
	QFileDevice__WriteOwner = QFileDevice__Permission(0x2000)
	QFileDevice__ExeOwner   = QFileDevice__Permission(0x1000)
	QFileDevice__ReadUser   = QFileDevice__Permission(0x0400)
	QFileDevice__WriteUser  = QFileDevice__Permission(0x0200)
	QFileDevice__ExeUser    = QFileDevice__Permission(0x0100)
	QFileDevice__ReadGroup  = QFileDevice__Permission(0x0040)
	QFileDevice__WriteGroup = QFileDevice__Permission(0x0020)
	QFileDevice__ExeGroup   = QFileDevice__Permission(0x0010)
	QFileDevice__ReadOther  = QFileDevice__Permission(0x0004)
	QFileDevice__WriteOther = QFileDevice__Permission(0x0002)
	QFileDevice__ExeOther   = QFileDevice__Permission(0x0001)
)

func (ptr *QFileDevice) Seek(pos int64) bool {
	defer qt.Recovering("QFileDevice::seek")

	if ptr.Pointer() != nil {
		return C.QFileDevice_Seek(ptr.Pointer(), C.longlong(pos)) != 0
	}
	return false
}

func (ptr *QFileDevice) AtEnd() bool {
	defer qt.Recovering("QFileDevice::atEnd")

	if ptr.Pointer() != nil {
		return C.QFileDevice_AtEnd(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileDevice) ConnectClose(f func()) {
	defer qt.Recovering("connect QFileDevice::close")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "close", f)
	}
}

func (ptr *QFileDevice) DisconnectClose() {
	defer qt.Recovering("disconnect QFileDevice::close")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "close")
	}
}

//export callbackQFileDeviceClose
func callbackQFileDeviceClose(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QFileDevice::close")

	if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
		signal.(func())()
	} else {
		NewQFileDeviceFromPointer(ptr).CloseDefault()
	}
}

func (ptr *QFileDevice) Close() {
	defer qt.Recovering("QFileDevice::close")

	if ptr.Pointer() != nil {
		C.QFileDevice_Close(ptr.Pointer())
	}
}

func (ptr *QFileDevice) CloseDefault() {
	defer qt.Recovering("QFileDevice::close")

	if ptr.Pointer() != nil {
		C.QFileDevice_CloseDefault(ptr.Pointer())
	}
}

func (ptr *QFileDevice) Error() QFileDevice__FileError {
	defer qt.Recovering("QFileDevice::error")

	if ptr.Pointer() != nil {
		return QFileDevice__FileError(C.QFileDevice_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDevice) FileName() string {
	defer qt.Recovering("QFileDevice::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileDevice_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileDevice) Flush() bool {
	defer qt.Recovering("QFileDevice::flush")

	if ptr.Pointer() != nil {
		return C.QFileDevice_Flush(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileDevice) Handle() int {
	defer qt.Recovering("QFileDevice::handle")

	if ptr.Pointer() != nil {
		return int(C.QFileDevice_Handle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDevice) IsSequential() bool {
	defer qt.Recovering("QFileDevice::isSequential")

	if ptr.Pointer() != nil {
		return C.QFileDevice_IsSequential(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileDevice) Permissions() QFileDevice__Permission {
	defer qt.Recovering("QFileDevice::permissions")

	if ptr.Pointer() != nil {
		return QFileDevice__Permission(C.QFileDevice_Permissions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDevice) Pos() int64 {
	defer qt.Recovering("QFileDevice::pos")

	if ptr.Pointer() != nil {
		return int64(C.QFileDevice_Pos(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDevice) ReadData(data string, len int64) int64 {
	defer qt.Recovering("QFileDevice::readData")

	if ptr.Pointer() != nil {
		return int64(C.QFileDevice_ReadData(ptr.Pointer(), C.CString(data), C.longlong(len)))
	}
	return 0
}

func (ptr *QFileDevice) ReadLineData(data string, maxlen int64) int64 {
	defer qt.Recovering("QFileDevice::readLineData")

	if ptr.Pointer() != nil {
		return int64(C.QFileDevice_ReadLineData(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
	}
	return 0
}

func (ptr *QFileDevice) Resize(sz int64) bool {
	defer qt.Recovering("QFileDevice::resize")

	if ptr.Pointer() != nil {
		return C.QFileDevice_Resize(ptr.Pointer(), C.longlong(sz)) != 0
	}
	return false
}

func (ptr *QFileDevice) SetPermissions(permissions QFileDevice__Permission) bool {
	defer qt.Recovering("QFileDevice::setPermissions")

	if ptr.Pointer() != nil {
		return C.QFileDevice_SetPermissions(ptr.Pointer(), C.int(permissions)) != 0
	}
	return false
}

func (ptr *QFileDevice) Size() int64 {
	defer qt.Recovering("QFileDevice::size")

	if ptr.Pointer() != nil {
		return int64(C.QFileDevice_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDevice) UnsetError() {
	defer qt.Recovering("QFileDevice::unsetError")

	if ptr.Pointer() != nil {
		C.QFileDevice_UnsetError(ptr.Pointer())
	}
}

func (ptr *QFileDevice) WriteData(data string, len int64) int64 {
	defer qt.Recovering("QFileDevice::writeData")

	if ptr.Pointer() != nil {
		return int64(C.QFileDevice_WriteData(ptr.Pointer(), C.CString(data), C.longlong(len)))
	}
	return 0
}

func (ptr *QFileDevice) DestroyQFileDevice() {
	defer qt.Recovering("QFileDevice::~QFileDevice")

	if ptr.Pointer() != nil {
		C.QFileDevice_DestroyQFileDevice(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QFileDevice) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QFileDevice::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QFileDevice) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QFileDevice::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQFileDeviceTimerEvent
func callbackQFileDeviceTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFileDevice::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQFileDeviceFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QFileDevice) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QFileDevice::timerEvent")

	if ptr.Pointer() != nil {
		C.QFileDevice_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFileDevice) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QFileDevice::timerEvent")

	if ptr.Pointer() != nil {
		C.QFileDevice_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFileDevice) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QFileDevice::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QFileDevice) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QFileDevice::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQFileDeviceChildEvent
func callbackQFileDeviceChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFileDevice::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQFileDeviceFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QFileDevice) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QFileDevice::childEvent")

	if ptr.Pointer() != nil {
		C.QFileDevice_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFileDevice) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QFileDevice::childEvent")

	if ptr.Pointer() != nil {
		C.QFileDevice_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFileDevice) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QFileDevice::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QFileDevice) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QFileDevice::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQFileDeviceCustomEvent
func callbackQFileDeviceCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFileDevice::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQFileDeviceFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QFileDevice) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QFileDevice::customEvent")

	if ptr.Pointer() != nil {
		C.QFileDevice_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFileDevice) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QFileDevice::customEvent")

	if ptr.Pointer() != nil {
		C.QFileDevice_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QFileInfo struct {
	ptr unsafe.Pointer
}

type QFileInfo_ITF interface {
	QFileInfo_PTR() *QFileInfo
}

func (p *QFileInfo) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QFileInfo) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQFileInfo(ptr QFileInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileInfo_PTR().Pointer()
	}
	return nil
}

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

func newQFileInfoFromPointer(ptr unsafe.Pointer) *QFileInfo {
	var n = NewQFileInfoFromPointer(ptr)
	return n
}

func (ptr *QFileInfo) QFileInfo_PTR() *QFileInfo {
	return ptr
}

func NewQFileInfo() *QFileInfo {
	defer qt.Recovering("QFileInfo::QFileInfo")

	return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo())
}

func NewQFileInfo5(dir QDir_ITF, file string) *QFileInfo {
	defer qt.Recovering("QFileInfo::QFileInfo")

	return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo5(PointerFromQDir(dir), C.CString(file)))
}

func NewQFileInfo4(file QFile_ITF) *QFileInfo {
	defer qt.Recovering("QFileInfo::QFileInfo")

	return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo4(PointerFromQFile(file)))
}

func NewQFileInfo6(fileinfo QFileInfo_ITF) *QFileInfo {
	defer qt.Recovering("QFileInfo::QFileInfo")

	return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo6(PointerFromQFileInfo(fileinfo)))
}

func NewQFileInfo3(file string) *QFileInfo {
	defer qt.Recovering("QFileInfo::QFileInfo")

	return newQFileInfoFromPointer(C.QFileInfo_NewQFileInfo3(C.CString(file)))
}

func (ptr *QFileInfo) AbsoluteDir() *QDir {
	defer qt.Recovering("QFileInfo::absoluteDir")

	if ptr.Pointer() != nil {
		return NewQDirFromPointer(C.QFileInfo_AbsoluteDir(ptr.Pointer()))
	}
	return nil
}

func (ptr *QFileInfo) AbsoluteFilePath() string {
	defer qt.Recovering("QFileInfo::absoluteFilePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_AbsoluteFilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) AbsolutePath() string {
	defer qt.Recovering("QFileInfo::absolutePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_AbsolutePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) BaseName() string {
	defer qt.Recovering("QFileInfo::baseName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_BaseName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) BundleName() string {
	defer qt.Recovering("QFileInfo::bundleName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_BundleName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Caching() bool {
	defer qt.Recovering("QFileInfo::caching")

	if ptr.Pointer() != nil {
		return C.QFileInfo_Caching(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) CanonicalFilePath() string {
	defer qt.Recovering("QFileInfo::canonicalFilePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_CanonicalFilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) CanonicalPath() string {
	defer qt.Recovering("QFileInfo::canonicalPath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_CanonicalPath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) CompleteBaseName() string {
	defer qt.Recovering("QFileInfo::completeBaseName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_CompleteBaseName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) CompleteSuffix() string {
	defer qt.Recovering("QFileInfo::completeSuffix")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_CompleteSuffix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Created() *QDateTime {
	defer qt.Recovering("QFileInfo::created")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QFileInfo_Created(ptr.Pointer()))
	}
	return nil
}

func (ptr *QFileInfo) Dir() *QDir {
	defer qt.Recovering("QFileInfo::dir")

	if ptr.Pointer() != nil {
		return NewQDirFromPointer(C.QFileInfo_Dir(ptr.Pointer()))
	}
	return nil
}

func QFileInfo_Exists2(file string) bool {
	defer qt.Recovering("QFileInfo::exists")

	return C.QFileInfo_QFileInfo_Exists2(C.CString(file)) != 0
}

func (ptr *QFileInfo) Exists() bool {
	defer qt.Recovering("QFileInfo::exists")

	if ptr.Pointer() != nil {
		return C.QFileInfo_Exists(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) FileName() string {
	defer qt.Recovering("QFileInfo::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) FilePath() string {
	defer qt.Recovering("QFileInfo::filePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_FilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Group() string {
	defer qt.Recovering("QFileInfo::group")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_Group(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) IsAbsolute() bool {
	defer qt.Recovering("QFileInfo::isAbsolute")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsAbsolute(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsBundle() bool {
	defer qt.Recovering("QFileInfo::isBundle")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsBundle(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsDir() bool {
	defer qt.Recovering("QFileInfo::isDir")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsDir(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsExecutable() bool {
	defer qt.Recovering("QFileInfo::isExecutable")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsExecutable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsFile() bool {
	defer qt.Recovering("QFileInfo::isFile")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsFile(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsHidden() bool {
	defer qt.Recovering("QFileInfo::isHidden")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsHidden(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsNativePath() bool {
	defer qt.Recovering("QFileInfo::isNativePath")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsNativePath(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsReadable() bool {
	defer qt.Recovering("QFileInfo::isReadable")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsReadable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsRelative() bool {
	defer qt.Recovering("QFileInfo::isRelative")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsRelative(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsRoot() bool {
	defer qt.Recovering("QFileInfo::isRoot")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsRoot(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsSymLink() bool {
	defer qt.Recovering("QFileInfo::isSymLink")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsSymLink(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) IsWritable() bool {
	defer qt.Recovering("QFileInfo::isWritable")

	if ptr.Pointer() != nil {
		return C.QFileInfo_IsWritable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) LastModified() *QDateTime {
	defer qt.Recovering("QFileInfo::lastModified")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QFileInfo_LastModified(ptr.Pointer()))
	}
	return nil
}

func (ptr *QFileInfo) LastRead() *QDateTime {
	defer qt.Recovering("QFileInfo::lastRead")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QFileInfo_LastRead(ptr.Pointer()))
	}
	return nil
}

func (ptr *QFileInfo) MakeAbsolute() bool {
	defer qt.Recovering("QFileInfo::makeAbsolute")

	if ptr.Pointer() != nil {
		return C.QFileInfo_MakeAbsolute(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QFileInfo) Owner() string {
	defer qt.Recovering("QFileInfo::owner")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_Owner(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Path() string {
	defer qt.Recovering("QFileInfo::path")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_Path(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Refresh() {
	defer qt.Recovering("QFileInfo::refresh")

	if ptr.Pointer() != nil {
		C.QFileInfo_Refresh(ptr.Pointer())
	}
}

func (ptr *QFileInfo) SetCaching(enable bool) {
	defer qt.Recovering("QFileInfo::setCaching")

	if ptr.Pointer() != nil {
		C.QFileInfo_SetCaching(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QFileInfo) SetFile3(dir QDir_ITF, file string) {
	defer qt.Recovering("QFileInfo::setFile")

	if ptr.Pointer() != nil {
		C.QFileInfo_SetFile3(ptr.Pointer(), PointerFromQDir(dir), C.CString(file))
	}
}

func (ptr *QFileInfo) SetFile2(file QFile_ITF) {
	defer qt.Recovering("QFileInfo::setFile")

	if ptr.Pointer() != nil {
		C.QFileInfo_SetFile2(ptr.Pointer(), PointerFromQFile(file))
	}
}

func (ptr *QFileInfo) SetFile(file string) {
	defer qt.Recovering("QFileInfo::setFile")

	if ptr.Pointer() != nil {
		C.QFileInfo_SetFile(ptr.Pointer(), C.CString(file))
	}
}

func (ptr *QFileInfo) Size() int64 {
	defer qt.Recovering("QFileInfo::size")

	if ptr.Pointer() != nil {
		return int64(C.QFileInfo_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileInfo) Suffix() string {
	defer qt.Recovering("QFileInfo::suffix")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_Suffix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) Swap(other QFileInfo_ITF) {
	defer qt.Recovering("QFileInfo::swap")

	if ptr.Pointer() != nil {
		C.QFileInfo_Swap(ptr.Pointer(), PointerFromQFileInfo(other))
	}
}

func (ptr *QFileInfo) SymLinkTarget() string {
	defer qt.Recovering("QFileInfo::symLinkTarget")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileInfo_SymLinkTarget(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileInfo) DestroyQFileInfo() {
	defer qt.Recovering("QFileInfo::~QFileInfo")

	if ptr.Pointer() != nil {
		C.QFileInfo_DestroyQFileInfo(ptr.Pointer())
	}
}

type QFileSelector struct {
	QObject
}

type QFileSelector_ITF interface {
	QObject_ITF
	QFileSelector_PTR() *QFileSelector
}

func PointerFromQFileSelector(ptr QFileSelector_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileSelector_PTR().Pointer()
	}
	return nil
}

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

func newQFileSelectorFromPointer(ptr unsafe.Pointer) *QFileSelector {
	var n = NewQFileSelectorFromPointer(ptr)
	for len(n.ObjectName()) < len("QFileSelector_") {
		n.SetObjectName("QFileSelector_" + qt.Identifier())
	}
	return n
}

func (ptr *QFileSelector) QFileSelector_PTR() *QFileSelector {
	return ptr
}

func NewQFileSelector(parent QObject_ITF) *QFileSelector {
	defer qt.Recovering("QFileSelector::QFileSelector")

	return newQFileSelectorFromPointer(C.QFileSelector_NewQFileSelector(PointerFromQObject(parent)))
}

func (ptr *QFileSelector) AllSelectors() []string {
	defer qt.Recovering("QFileSelector::allSelectors")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QFileSelector_AllSelectors(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileSelector) ExtraSelectors() []string {
	defer qt.Recovering("QFileSelector::extraSelectors")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QFileSelector_ExtraSelectors(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileSelector) Select(filePath string) string {
	defer qt.Recovering("QFileSelector::select")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFileSelector_Select(ptr.Pointer(), C.CString(filePath)))
	}
	return ""
}

func (ptr *QFileSelector) Select2(filePath QUrl_ITF) *QUrl {
	defer qt.Recovering("QFileSelector::select")

	if ptr.Pointer() != nil {
		return NewQUrlFromPointer(C.QFileSelector_Select2(ptr.Pointer(), PointerFromQUrl(filePath)))
	}
	return nil
}

func (ptr *QFileSelector) SetExtraSelectors(list []string) {
	defer qt.Recovering("QFileSelector::setExtraSelectors")

	if ptr.Pointer() != nil {
		C.QFileSelector_SetExtraSelectors(ptr.Pointer(), C.CString(strings.Join(list, "|")))
	}
}

func (ptr *QFileSelector) DestroyQFileSelector() {
	defer qt.Recovering("QFileSelector::~QFileSelector")

	if ptr.Pointer() != nil {
		C.QFileSelector_DestroyQFileSelector(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QFileSelector) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QFileSelector::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QFileSelector) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QFileSelector::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQFileSelectorTimerEvent
func callbackQFileSelectorTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFileSelector::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQFileSelectorFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QFileSelector) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QFileSelector::timerEvent")

	if ptr.Pointer() != nil {
		C.QFileSelector_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFileSelector) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QFileSelector::timerEvent")

	if ptr.Pointer() != nil {
		C.QFileSelector_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFileSelector) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QFileSelector::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QFileSelector) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QFileSelector::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQFileSelectorChildEvent
func callbackQFileSelectorChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFileSelector::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQFileSelectorFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QFileSelector) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QFileSelector::childEvent")

	if ptr.Pointer() != nil {
		C.QFileSelector_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFileSelector) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QFileSelector::childEvent")

	if ptr.Pointer() != nil {
		C.QFileSelector_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFileSelector) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QFileSelector::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QFileSelector) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QFileSelector::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQFileSelectorCustomEvent
func callbackQFileSelectorCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFileSelector::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQFileSelectorFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QFileSelector) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QFileSelector::customEvent")

	if ptr.Pointer() != nil {
		C.QFileSelector_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFileSelector) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QFileSelector::customEvent")

	if ptr.Pointer() != nil {
		C.QFileSelector_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QFileSystemWatcher struct {
	QObject
}

type QFileSystemWatcher_ITF interface {
	QObject_ITF
	QFileSystemWatcher_PTR() *QFileSystemWatcher
}

func PointerFromQFileSystemWatcher(ptr QFileSystemWatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileSystemWatcher_PTR().Pointer()
	}
	return nil
}

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

func newQFileSystemWatcherFromPointer(ptr unsafe.Pointer) *QFileSystemWatcher {
	var n = NewQFileSystemWatcherFromPointer(ptr)
	for len(n.ObjectName()) < len("QFileSystemWatcher_") {
		n.SetObjectName("QFileSystemWatcher_" + qt.Identifier())
	}
	return n
}

func (ptr *QFileSystemWatcher) QFileSystemWatcher_PTR() *QFileSystemWatcher {
	return ptr
}

func (ptr *QFileSystemWatcher) Directories() []string {
	defer qt.Recovering("QFileSystemWatcher::directories")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QFileSystemWatcher_Directories(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileSystemWatcher) Files() []string {
	defer qt.Recovering("QFileSystemWatcher::files")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QFileSystemWatcher_Files(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func NewQFileSystemWatcher(parent QObject_ITF) *QFileSystemWatcher {
	defer qt.Recovering("QFileSystemWatcher::QFileSystemWatcher")

	return newQFileSystemWatcherFromPointer(C.QFileSystemWatcher_NewQFileSystemWatcher(PointerFromQObject(parent)))
}

func NewQFileSystemWatcher2(paths []string, parent QObject_ITF) *QFileSystemWatcher {
	defer qt.Recovering("QFileSystemWatcher::QFileSystemWatcher")

	return newQFileSystemWatcherFromPointer(C.QFileSystemWatcher_NewQFileSystemWatcher2(C.CString(strings.Join(paths, "|")), PointerFromQObject(parent)))
}

func (ptr *QFileSystemWatcher) AddPath(path string) bool {
	defer qt.Recovering("QFileSystemWatcher::addPath")

	if ptr.Pointer() != nil {
		return C.QFileSystemWatcher_AddPath(ptr.Pointer(), C.CString(path)) != 0
	}
	return false
}

func (ptr *QFileSystemWatcher) AddPaths(paths []string) []string {
	defer qt.Recovering("QFileSystemWatcher::addPaths")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QFileSystemWatcher_AddPaths(ptr.Pointer(), C.CString(strings.Join(paths, "|")))), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileSystemWatcher) ConnectDirectoryChanged(f func(path string)) {
	defer qt.Recovering("connect QFileSystemWatcher::directoryChanged")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_ConnectDirectoryChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "directoryChanged", f)
	}
}

func (ptr *QFileSystemWatcher) DisconnectDirectoryChanged() {
	defer qt.Recovering("disconnect QFileSystemWatcher::directoryChanged")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_DisconnectDirectoryChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "directoryChanged")
	}
}

//export callbackQFileSystemWatcherDirectoryChanged
func callbackQFileSystemWatcherDirectoryChanged(ptr unsafe.Pointer, ptrName *C.char, path *C.char) {
	defer qt.Recovering("callback QFileSystemWatcher::directoryChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "directoryChanged"); signal != nil {
		signal.(func(string))(C.GoString(path))
	}

}

func (ptr *QFileSystemWatcher) ConnectFileChanged(f func(path string)) {
	defer qt.Recovering("connect QFileSystemWatcher::fileChanged")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_ConnectFileChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "fileChanged", f)
	}
}

func (ptr *QFileSystemWatcher) DisconnectFileChanged() {
	defer qt.Recovering("disconnect QFileSystemWatcher::fileChanged")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_DisconnectFileChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "fileChanged")
	}
}

//export callbackQFileSystemWatcherFileChanged
func callbackQFileSystemWatcherFileChanged(ptr unsafe.Pointer, ptrName *C.char, path *C.char) {
	defer qt.Recovering("callback QFileSystemWatcher::fileChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "fileChanged"); signal != nil {
		signal.(func(string))(C.GoString(path))
	}

}

func (ptr *QFileSystemWatcher) RemovePath(path string) bool {
	defer qt.Recovering("QFileSystemWatcher::removePath")

	if ptr.Pointer() != nil {
		return C.QFileSystemWatcher_RemovePath(ptr.Pointer(), C.CString(path)) != 0
	}
	return false
}

func (ptr *QFileSystemWatcher) RemovePaths(paths []string) []string {
	defer qt.Recovering("QFileSystemWatcher::removePaths")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QFileSystemWatcher_RemovePaths(ptr.Pointer(), C.CString(strings.Join(paths, "|")))), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileSystemWatcher) DestroyQFileSystemWatcher() {
	defer qt.Recovering("QFileSystemWatcher::~QFileSystemWatcher")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_DestroyQFileSystemWatcher(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QFileSystemWatcher) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QFileSystemWatcher::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QFileSystemWatcher) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QFileSystemWatcher::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQFileSystemWatcherTimerEvent
func callbackQFileSystemWatcherTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFileSystemWatcher::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQFileSystemWatcherFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QFileSystemWatcher) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QFileSystemWatcher::timerEvent")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFileSystemWatcher) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QFileSystemWatcher::timerEvent")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFileSystemWatcher) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QFileSystemWatcher::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QFileSystemWatcher) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QFileSystemWatcher::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQFileSystemWatcherChildEvent
func callbackQFileSystemWatcherChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFileSystemWatcher::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQFileSystemWatcherFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QFileSystemWatcher) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QFileSystemWatcher::childEvent")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFileSystemWatcher) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QFileSystemWatcher::childEvent")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFileSystemWatcher) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QFileSystemWatcher::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QFileSystemWatcher) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QFileSystemWatcher::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQFileSystemWatcherCustomEvent
func callbackQFileSystemWatcherCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFileSystemWatcher::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQFileSystemWatcherFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QFileSystemWatcher) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QFileSystemWatcher::customEvent")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFileSystemWatcher) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QFileSystemWatcher::customEvent")

	if ptr.Pointer() != nil {
		C.QFileSystemWatcher_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QFinalState struct {
	QAbstractState
}

type QFinalState_ITF interface {
	QAbstractState_ITF
	QFinalState_PTR() *QFinalState
}

func PointerFromQFinalState(ptr QFinalState_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFinalState_PTR().Pointer()
	}
	return nil
}

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

func newQFinalStateFromPointer(ptr unsafe.Pointer) *QFinalState {
	var n = NewQFinalStateFromPointer(ptr)
	for len(n.ObjectName()) < len("QFinalState_") {
		n.SetObjectName("QFinalState_" + qt.Identifier())
	}
	return n
}

func (ptr *QFinalState) QFinalState_PTR() *QFinalState {
	return ptr
}

func NewQFinalState(parent QState_ITF) *QFinalState {
	defer qt.Recovering("QFinalState::QFinalState")

	return newQFinalStateFromPointer(C.QFinalState_NewQFinalState(PointerFromQState(parent)))
}

func (ptr *QFinalState) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QFinalState::event")

	if ptr.Pointer() != nil {
		return C.QFinalState_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QFinalState) ConnectOnEntry(f func(event *QEvent)) {
	defer qt.Recovering("connect QFinalState::onEntry")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onEntry", f)
	}
}

func (ptr *QFinalState) DisconnectOnEntry() {
	defer qt.Recovering("disconnect QFinalState::onEntry")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onEntry")
	}
}

//export callbackQFinalStateOnEntry
func callbackQFinalStateOnEntry(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFinalState::onEntry")

	if signal := qt.GetSignal(C.GoString(ptrName), "onEntry"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQFinalStateFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QFinalState) OnEntry(event QEvent_ITF) {
	defer qt.Recovering("QFinalState::onEntry")

	if ptr.Pointer() != nil {
		C.QFinalState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFinalState) OnEntryDefault(event QEvent_ITF) {
	defer qt.Recovering("QFinalState::onEntry")

	if ptr.Pointer() != nil {
		C.QFinalState_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFinalState) ConnectOnExit(f func(event *QEvent)) {
	defer qt.Recovering("connect QFinalState::onExit")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onExit", f)
	}
}

func (ptr *QFinalState) DisconnectOnExit() {
	defer qt.Recovering("disconnect QFinalState::onExit")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onExit")
	}
}

//export callbackQFinalStateOnExit
func callbackQFinalStateOnExit(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFinalState::onExit")

	if signal := qt.GetSignal(C.GoString(ptrName), "onExit"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQFinalStateFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QFinalState) OnExit(event QEvent_ITF) {
	defer qt.Recovering("QFinalState::onExit")

	if ptr.Pointer() != nil {
		C.QFinalState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFinalState) OnExitDefault(event QEvent_ITF) {
	defer qt.Recovering("QFinalState::onExit")

	if ptr.Pointer() != nil {
		C.QFinalState_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFinalState) DestroyQFinalState() {
	defer qt.Recovering("QFinalState::~QFinalState")

	if ptr.Pointer() != nil {
		C.QFinalState_DestroyQFinalState(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QFinalState) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QFinalState::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QFinalState) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QFinalState::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQFinalStateTimerEvent
func callbackQFinalStateTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFinalState::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQFinalStateFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QFinalState) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QFinalState::timerEvent")

	if ptr.Pointer() != nil {
		C.QFinalState_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFinalState) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QFinalState::timerEvent")

	if ptr.Pointer() != nil {
		C.QFinalState_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QFinalState) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QFinalState::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QFinalState) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QFinalState::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQFinalStateChildEvent
func callbackQFinalStateChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFinalState::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQFinalStateFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QFinalState) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QFinalState::childEvent")

	if ptr.Pointer() != nil {
		C.QFinalState_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFinalState) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QFinalState::childEvent")

	if ptr.Pointer() != nil {
		C.QFinalState_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QFinalState) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QFinalState::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QFinalState) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QFinalState::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQFinalStateCustomEvent
func callbackQFinalStateCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QFinalState::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQFinalStateFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QFinalState) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QFinalState::customEvent")

	if ptr.Pointer() != nil {
		C.QFinalState_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QFinalState) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QFinalState::customEvent")

	if ptr.Pointer() != nil {
		C.QFinalState_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QFlag struct {
	ptr unsafe.Pointer
}

type QFlag_ITF interface {
	QFlag_PTR() *QFlag
}

func (p *QFlag) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QFlag) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQFlag(ptr QFlag_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFlag_PTR().Pointer()
	}
	return nil
}

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

func newQFlagFromPointer(ptr unsafe.Pointer) *QFlag {
	var n = NewQFlagFromPointer(ptr)
	return n
}

func (ptr *QFlag) QFlag_PTR() *QFlag {
	return ptr
}

func NewQFlag(value int) *QFlag {
	defer qt.Recovering("QFlag::QFlag")

	return newQFlagFromPointer(C.QFlag_NewQFlag(C.int(value)))
}

type QFlags struct {
	ptr unsafe.Pointer
}

type QFlags_ITF interface {
	QFlags_PTR() *QFlags
}

func (p *QFlags) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QFlags) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQFlags(ptr QFlags_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFlags_PTR().Pointer()
	}
	return nil
}

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

func newQFlagsFromPointer(ptr unsafe.Pointer) *QFlags {
	var n = NewQFlagsFromPointer(ptr)
	return n
}

func (ptr *QFlags) QFlags_PTR() *QFlags {
	return ptr
}

type QFuture struct {
	ptr unsafe.Pointer
}

type QFuture_ITF interface {
	QFuture_PTR() *QFuture
}

func (p *QFuture) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QFuture) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQFuture(ptr QFuture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFuture_PTR().Pointer()
	}
	return nil
}

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

func newQFutureFromPointer(ptr unsafe.Pointer) *QFuture {
	var n = NewQFutureFromPointer(ptr)
	return n
}

func (ptr *QFuture) QFuture_PTR() *QFuture {
	return ptr
}

type QFutureIterator struct {
	ptr unsafe.Pointer
}

type QFutureIterator_ITF interface {
	QFutureIterator_PTR() *QFutureIterator
}

func (p *QFutureIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QFutureIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQFutureIterator(ptr QFutureIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureIterator_PTR().Pointer()
	}
	return nil
}

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

func newQFutureIteratorFromPointer(ptr unsafe.Pointer) *QFutureIterator {
	var n = NewQFutureIteratorFromPointer(ptr)
	return n
}

func (ptr *QFutureIterator) QFutureIterator_PTR() *QFutureIterator {
	return ptr
}

type QFutureSynchronizer struct {
	ptr unsafe.Pointer
}

type QFutureSynchronizer_ITF interface {
	QFutureSynchronizer_PTR() *QFutureSynchronizer
}

func (p *QFutureSynchronizer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QFutureSynchronizer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQFutureSynchronizer(ptr QFutureSynchronizer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureSynchronizer_PTR().Pointer()
	}
	return nil
}

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

func newQFutureSynchronizerFromPointer(ptr unsafe.Pointer) *QFutureSynchronizer {
	var n = NewQFutureSynchronizerFromPointer(ptr)
	return n
}

func (ptr *QFutureSynchronizer) QFutureSynchronizer_PTR() *QFutureSynchronizer {
	return ptr
}

type QFutureWatcher struct {
	QObject
}

type QFutureWatcher_ITF interface {
	QObject_ITF
	QFutureWatcher_PTR() *QFutureWatcher
}

func PointerFromQFutureWatcher(ptr QFutureWatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFutureWatcher_PTR().Pointer()
	}
	return nil
}

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

func newQFutureWatcherFromPointer(ptr unsafe.Pointer) *QFutureWatcher {
	var n = NewQFutureWatcherFromPointer(ptr)
	for len(n.ObjectName()) < len("QFutureWatcher_") {
		n.SetObjectName("QFutureWatcher_" + qt.Identifier())
	}
	return n
}

func (ptr *QFutureWatcher) QFutureWatcher_PTR() *QFutureWatcher {
	return ptr
}

type QGenericArgument struct {
	ptr unsafe.Pointer
}

type QGenericArgument_ITF interface {
	QGenericArgument_PTR() *QGenericArgument
}

func (p *QGenericArgument) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QGenericArgument) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQGenericArgument(ptr QGenericArgument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericArgument_PTR().Pointer()
	}
	return nil
}

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

func newQGenericArgumentFromPointer(ptr unsafe.Pointer) *QGenericArgument {
	var n = NewQGenericArgumentFromPointer(ptr)
	return n
}

func (ptr *QGenericArgument) QGenericArgument_PTR() *QGenericArgument {
	return ptr
}

func NewQGenericArgument(name string, data unsafe.Pointer) *QGenericArgument {
	defer qt.Recovering("QGenericArgument::QGenericArgument")

	return newQGenericArgumentFromPointer(C.QGenericArgument_NewQGenericArgument(C.CString(name), data))
}

func (ptr *QGenericArgument) Data() unsafe.Pointer {
	defer qt.Recovering("QGenericArgument::data")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QGenericArgument_Data(ptr.Pointer()))
	}
	return nil
}

type QGenericReturnArgument struct {
	QGenericArgument
}

type QGenericReturnArgument_ITF interface {
	QGenericArgument_ITF
	QGenericReturnArgument_PTR() *QGenericReturnArgument
}

func PointerFromQGenericReturnArgument(ptr QGenericReturnArgument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericReturnArgument_PTR().Pointer()
	}
	return nil
}

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

func newQGenericReturnArgumentFromPointer(ptr unsafe.Pointer) *QGenericReturnArgument {
	var n = NewQGenericReturnArgumentFromPointer(ptr)
	return n
}

func (ptr *QGenericReturnArgument) QGenericReturnArgument_PTR() *QGenericReturnArgument {
	return ptr
}

func NewQGenericReturnArgument(name string, data unsafe.Pointer) *QGenericReturnArgument {
	defer qt.Recovering("QGenericReturnArgument::QGenericReturnArgument")

	return newQGenericReturnArgumentFromPointer(C.QGenericReturnArgument_NewQGenericReturnArgument(C.CString(name), data))
}

type QGlobalStatic struct {
	ptr unsafe.Pointer
}

type QGlobalStatic_ITF interface {
	QGlobalStatic_PTR() *QGlobalStatic
}

func (p *QGlobalStatic) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QGlobalStatic) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQGlobalStatic(ptr QGlobalStatic_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGlobalStatic_PTR().Pointer()
	}
	return nil
}

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

func newQGlobalStaticFromPointer(ptr unsafe.Pointer) *QGlobalStatic {
	var n = NewQGlobalStaticFromPointer(ptr)
	return n
}

func (ptr *QGlobalStatic) QGlobalStatic_PTR() *QGlobalStatic {
	return ptr
}

type QHash struct {
	ptr unsafe.Pointer
}

type QHash_ITF interface {
	QHash_PTR() *QHash
}

func (p *QHash) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QHash) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQHash(ptr QHash_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHash_PTR().Pointer()
	}
	return nil
}

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

func newQHashFromPointer(ptr unsafe.Pointer) *QHash {
	var n = NewQHashFromPointer(ptr)
	return n
}

func (ptr *QHash) QHash_PTR() *QHash {
	return ptr
}

type QHashIterator struct {
	ptr unsafe.Pointer
}

type QHashIterator_ITF interface {
	QHashIterator_PTR() *QHashIterator
}

func (p *QHashIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QHashIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQHashIterator(ptr QHashIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHashIterator_PTR().Pointer()
	}
	return nil
}

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

func newQHashIteratorFromPointer(ptr unsafe.Pointer) *QHashIterator {
	var n = NewQHashIteratorFromPointer(ptr)
	return n
}

func (ptr *QHashIterator) QHashIterator_PTR() *QHashIterator {
	return ptr
}

type QHistoryState struct {
	QAbstractState
}

type QHistoryState_ITF interface {
	QAbstractState_ITF
	QHistoryState_PTR() *QHistoryState
}

func PointerFromQHistoryState(ptr QHistoryState_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHistoryState_PTR().Pointer()
	}
	return nil
}

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

func newQHistoryStateFromPointer(ptr unsafe.Pointer) *QHistoryState {
	var n = NewQHistoryStateFromPointer(ptr)
	for len(n.ObjectName()) < len("QHistoryState_") {
		n.SetObjectName("QHistoryState_" + qt.Identifier())
	}
	return n
}

func (ptr *QHistoryState) QHistoryState_PTR() *QHistoryState {
	return ptr
}

//QHistoryState::HistoryType
type QHistoryState__HistoryType int64

const (
	QHistoryState__ShallowHistory = QHistoryState__HistoryType(0)
	QHistoryState__DeepHistory    = QHistoryState__HistoryType(1)
)

func NewQHistoryState2(ty QHistoryState__HistoryType, parent QState_ITF) *QHistoryState {
	defer qt.Recovering("QHistoryState::QHistoryState")

	return newQHistoryStateFromPointer(C.QHistoryState_NewQHistoryState2(C.int(ty), PointerFromQState(parent)))
}

func NewQHistoryState(parent QState_ITF) *QHistoryState {
	defer qt.Recovering("QHistoryState::QHistoryState")

	return newQHistoryStateFromPointer(C.QHistoryState_NewQHistoryState(PointerFromQState(parent)))
}

func (ptr *QHistoryState) DefaultState() *QAbstractState {
	defer qt.Recovering("QHistoryState::defaultState")

	if ptr.Pointer() != nil {
		return NewQAbstractStateFromPointer(C.QHistoryState_DefaultState(ptr.Pointer()))
	}
	return nil
}

func (ptr *QHistoryState) ConnectDefaultStateChanged(f func()) {
	defer qt.Recovering("connect QHistoryState::defaultStateChanged")

	if ptr.Pointer() != nil {
		C.QHistoryState_ConnectDefaultStateChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "defaultStateChanged", f)
	}
}

func (ptr *QHistoryState) DisconnectDefaultStateChanged() {
	defer qt.Recovering("disconnect QHistoryState::defaultStateChanged")

	if ptr.Pointer() != nil {
		C.QHistoryState_DisconnectDefaultStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "defaultStateChanged")
	}
}

//export callbackQHistoryStateDefaultStateChanged
func callbackQHistoryStateDefaultStateChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QHistoryState::defaultStateChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "defaultStateChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QHistoryState) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QHistoryState::event")

	if ptr.Pointer() != nil {
		return C.QHistoryState_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QHistoryState) HistoryType() QHistoryState__HistoryType {
	defer qt.Recovering("QHistoryState::historyType")

	if ptr.Pointer() != nil {
		return QHistoryState__HistoryType(C.QHistoryState_HistoryType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QHistoryState) ConnectHistoryTypeChanged(f func()) {
	defer qt.Recovering("connect QHistoryState::historyTypeChanged")

	if ptr.Pointer() != nil {
		C.QHistoryState_ConnectHistoryTypeChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "historyTypeChanged", f)
	}
}

func (ptr *QHistoryState) DisconnectHistoryTypeChanged() {
	defer qt.Recovering("disconnect QHistoryState::historyTypeChanged")

	if ptr.Pointer() != nil {
		C.QHistoryState_DisconnectHistoryTypeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "historyTypeChanged")
	}
}

//export callbackQHistoryStateHistoryTypeChanged
func callbackQHistoryStateHistoryTypeChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QHistoryState::historyTypeChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "historyTypeChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QHistoryState) ConnectOnEntry(f func(event *QEvent)) {
	defer qt.Recovering("connect QHistoryState::onEntry")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onEntry", f)
	}
}

func (ptr *QHistoryState) DisconnectOnEntry() {
	defer qt.Recovering("disconnect QHistoryState::onEntry")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onEntry")
	}
}

//export callbackQHistoryStateOnEntry
func callbackQHistoryStateOnEntry(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QHistoryState::onEntry")

	if signal := qt.GetSignal(C.GoString(ptrName), "onEntry"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQHistoryStateFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QHistoryState) OnEntry(event QEvent_ITF) {
	defer qt.Recovering("QHistoryState::onEntry")

	if ptr.Pointer() != nil {
		C.QHistoryState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QHistoryState) OnEntryDefault(event QEvent_ITF) {
	defer qt.Recovering("QHistoryState::onEntry")

	if ptr.Pointer() != nil {
		C.QHistoryState_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QHistoryState) ConnectOnExit(f func(event *QEvent)) {
	defer qt.Recovering("connect QHistoryState::onExit")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onExit", f)
	}
}

func (ptr *QHistoryState) DisconnectOnExit() {
	defer qt.Recovering("disconnect QHistoryState::onExit")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onExit")
	}
}

//export callbackQHistoryStateOnExit
func callbackQHistoryStateOnExit(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QHistoryState::onExit")

	if signal := qt.GetSignal(C.GoString(ptrName), "onExit"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQHistoryStateFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QHistoryState) OnExit(event QEvent_ITF) {
	defer qt.Recovering("QHistoryState::onExit")

	if ptr.Pointer() != nil {
		C.QHistoryState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QHistoryState) OnExitDefault(event QEvent_ITF) {
	defer qt.Recovering("QHistoryState::onExit")

	if ptr.Pointer() != nil {
		C.QHistoryState_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QHistoryState) SetDefaultState(state QAbstractState_ITF) {
	defer qt.Recovering("QHistoryState::setDefaultState")

	if ptr.Pointer() != nil {
		C.QHistoryState_SetDefaultState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

func (ptr *QHistoryState) SetHistoryType(ty QHistoryState__HistoryType) {
	defer qt.Recovering("QHistoryState::setHistoryType")

	if ptr.Pointer() != nil {
		C.QHistoryState_SetHistoryType(ptr.Pointer(), C.int(ty))
	}
}

func (ptr *QHistoryState) DestroyQHistoryState() {
	defer qt.Recovering("QHistoryState::~QHistoryState")

	if ptr.Pointer() != nil {
		C.QHistoryState_DestroyQHistoryState(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QHistoryState) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QHistoryState::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QHistoryState) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QHistoryState::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQHistoryStateTimerEvent
func callbackQHistoryStateTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QHistoryState::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQHistoryStateFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QHistoryState) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QHistoryState::timerEvent")

	if ptr.Pointer() != nil {
		C.QHistoryState_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QHistoryState) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QHistoryState::timerEvent")

	if ptr.Pointer() != nil {
		C.QHistoryState_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QHistoryState) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QHistoryState::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QHistoryState) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QHistoryState::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQHistoryStateChildEvent
func callbackQHistoryStateChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QHistoryState::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQHistoryStateFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QHistoryState) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QHistoryState::childEvent")

	if ptr.Pointer() != nil {
		C.QHistoryState_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QHistoryState) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QHistoryState::childEvent")

	if ptr.Pointer() != nil {
		C.QHistoryState_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QHistoryState) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QHistoryState::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QHistoryState) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QHistoryState::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQHistoryStateCustomEvent
func callbackQHistoryStateCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QHistoryState::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQHistoryStateFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QHistoryState) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QHistoryState::customEvent")

	if ptr.Pointer() != nil {
		C.QHistoryState_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QHistoryState) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QHistoryState::customEvent")

	if ptr.Pointer() != nil {
		C.QHistoryState_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QHooks struct {
	ptr unsafe.Pointer
}

type QHooks_ITF interface {
	QHooks_PTR() *QHooks
}

func (p *QHooks) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QHooks) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQHooks(ptr QHooks_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHooks_PTR().Pointer()
	}
	return nil
}

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

func newQHooksFromPointer(ptr unsafe.Pointer) *QHooks {
	var n = NewQHooksFromPointer(ptr)
	return n
}

func (ptr *QHooks) QHooks_PTR() *QHooks {
	return ptr
}

//QHooks::HookIndex
type QHooks__HookIndex int64

const (
	QHooks__HookDataVersion = QHooks__HookIndex(0)
	QHooks__HookDataSize    = QHooks__HookIndex(1)
	QHooks__QtVersion       = QHooks__HookIndex(2)
	QHooks__AddQObject      = QHooks__HookIndex(3)
	QHooks__RemoveQObject   = QHooks__HookIndex(4)
	QHooks__Startup         = QHooks__HookIndex(5)
	QHooks__LastHookIndex   = QHooks__HookIndex(6)
)

type QIODevice struct {
	QObject
}

type QIODevice_ITF interface {
	QObject_ITF
	QIODevice_PTR() *QIODevice
}

func PointerFromQIODevice(ptr QIODevice_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIODevice_PTR().Pointer()
	}
	return nil
}

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

func newQIODeviceFromPointer(ptr unsafe.Pointer) *QIODevice {
	var n = NewQIODeviceFromPointer(ptr)
	for len(n.ObjectName()) < len("QIODevice_") {
		n.SetObjectName("QIODevice_" + qt.Identifier())
	}
	return n
}

func (ptr *QIODevice) QIODevice_PTR() *QIODevice {
	return ptr
}

//QIODevice::OpenModeFlag
type QIODevice__OpenModeFlag int64

const (
	QIODevice__NotOpen    = QIODevice__OpenModeFlag(0x0000)
	QIODevice__ReadOnly   = QIODevice__OpenModeFlag(0x0001)
	QIODevice__WriteOnly  = QIODevice__OpenModeFlag(0x0002)
	QIODevice__ReadWrite  = QIODevice__OpenModeFlag(QIODevice__ReadOnly | QIODevice__WriteOnly)
	QIODevice__Append     = QIODevice__OpenModeFlag(0x0004)
	QIODevice__Truncate   = QIODevice__OpenModeFlag(0x0008)
	QIODevice__Text       = QIODevice__OpenModeFlag(0x0010)
	QIODevice__Unbuffered = QIODevice__OpenModeFlag(0x0020)
)

func (ptr *QIODevice) GetChar(c string) bool {
	defer qt.Recovering("QIODevice::getChar")

	if ptr.Pointer() != nil {
		return C.QIODevice_GetChar(ptr.Pointer(), C.CString(c)) != 0
	}
	return false
}

func (ptr *QIODevice) PutChar(c string) bool {
	defer qt.Recovering("QIODevice::putChar")

	if ptr.Pointer() != nil {
		return C.QIODevice_PutChar(ptr.Pointer(), C.CString(c)) != 0
	}
	return false
}

func (ptr *QIODevice) ConnectAboutToClose(f func()) {
	defer qt.Recovering("connect QIODevice::aboutToClose")

	if ptr.Pointer() != nil {
		C.QIODevice_ConnectAboutToClose(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "aboutToClose", f)
	}
}

func (ptr *QIODevice) DisconnectAboutToClose() {
	defer qt.Recovering("disconnect QIODevice::aboutToClose")

	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectAboutToClose(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "aboutToClose")
	}
}

//export callbackQIODeviceAboutToClose
func callbackQIODeviceAboutToClose(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QIODevice::aboutToClose")

	if signal := qt.GetSignal(C.GoString(ptrName), "aboutToClose"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QIODevice) AboutToClose() {
	defer qt.Recovering("QIODevice::aboutToClose")

	if ptr.Pointer() != nil {
		C.QIODevice_AboutToClose(ptr.Pointer())
	}
}

func (ptr *QIODevice) AtEnd() bool {
	defer qt.Recovering("QIODevice::atEnd")

	if ptr.Pointer() != nil {
		return C.QIODevice_AtEnd(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QIODevice) BytesAvailable() int64 {
	defer qt.Recovering("QIODevice::bytesAvailable")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_BytesAvailable(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) BytesToWrite() int64 {
	defer qt.Recovering("QIODevice::bytesToWrite")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_BytesToWrite(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) ConnectBytesWritten(f func(bytes int64)) {
	defer qt.Recovering("connect QIODevice::bytesWritten")

	if ptr.Pointer() != nil {
		C.QIODevice_ConnectBytesWritten(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "bytesWritten", f)
	}
}

func (ptr *QIODevice) DisconnectBytesWritten() {
	defer qt.Recovering("disconnect QIODevice::bytesWritten")

	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectBytesWritten(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "bytesWritten")
	}
}

//export callbackQIODeviceBytesWritten
func callbackQIODeviceBytesWritten(ptr unsafe.Pointer, ptrName *C.char, bytes C.longlong) {
	defer qt.Recovering("callback QIODevice::bytesWritten")

	if signal := qt.GetSignal(C.GoString(ptrName), "bytesWritten"); signal != nil {
		signal.(func(int64))(int64(bytes))
	}

}

func (ptr *QIODevice) BytesWritten(bytes int64) {
	defer qt.Recovering("QIODevice::bytesWritten")

	if ptr.Pointer() != nil {
		C.QIODevice_BytesWritten(ptr.Pointer(), C.longlong(bytes))
	}
}

func (ptr *QIODevice) CanReadLine() bool {
	defer qt.Recovering("QIODevice::canReadLine")

	if ptr.Pointer() != nil {
		return C.QIODevice_CanReadLine(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QIODevice) ConnectClose(f func()) {
	defer qt.Recovering("connect QIODevice::close")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "close", f)
	}
}

func (ptr *QIODevice) DisconnectClose() {
	defer qt.Recovering("disconnect QIODevice::close")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "close")
	}
}

//export callbackQIODeviceClose
func callbackQIODeviceClose(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QIODevice::close")

	if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
		signal.(func())()
	} else {
		NewQIODeviceFromPointer(ptr).CloseDefault()
	}
}

func (ptr *QIODevice) Close() {
	defer qt.Recovering("QIODevice::close")

	if ptr.Pointer() != nil {
		C.QIODevice_Close(ptr.Pointer())
	}
}

func (ptr *QIODevice) CloseDefault() {
	defer qt.Recovering("QIODevice::close")

	if ptr.Pointer() != nil {
		C.QIODevice_CloseDefault(ptr.Pointer())
	}
}

func (ptr *QIODevice) ErrorString() string {
	defer qt.Recovering("QIODevice::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QIODevice_ErrorString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QIODevice) IsOpen() bool {
	defer qt.Recovering("QIODevice::isOpen")

	if ptr.Pointer() != nil {
		return C.QIODevice_IsOpen(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QIODevice) IsReadable() bool {
	defer qt.Recovering("QIODevice::isReadable")

	if ptr.Pointer() != nil {
		return C.QIODevice_IsReadable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QIODevice) IsSequential() bool {
	defer qt.Recovering("QIODevice::isSequential")

	if ptr.Pointer() != nil {
		return C.QIODevice_IsSequential(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QIODevice) IsTextModeEnabled() bool {
	defer qt.Recovering("QIODevice::isTextModeEnabled")

	if ptr.Pointer() != nil {
		return C.QIODevice_IsTextModeEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QIODevice) IsWritable() bool {
	defer qt.Recovering("QIODevice::isWritable")

	if ptr.Pointer() != nil {
		return C.QIODevice_IsWritable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QIODevice) Open(mode QIODevice__OpenModeFlag) bool {
	defer qt.Recovering("QIODevice::open")

	if ptr.Pointer() != nil {
		return C.QIODevice_Open(ptr.Pointer(), C.int(mode)) != 0
	}
	return false
}

func (ptr *QIODevice) OpenMode() QIODevice__OpenModeFlag {
	defer qt.Recovering("QIODevice::openMode")

	if ptr.Pointer() != nil {
		return QIODevice__OpenModeFlag(C.QIODevice_OpenMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) Peek2(maxSize int64) string {
	defer qt.Recovering("QIODevice::peek")

	if ptr.Pointer() != nil {
		return C.GoString(C.QIODevice_Peek2(ptr.Pointer(), C.longlong(maxSize)))
	}
	return ""
}

func (ptr *QIODevice) Peek(data string, maxSize int64) int64 {
	defer qt.Recovering("QIODevice::peek")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Peek(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) Pos() int64 {
	defer qt.Recovering("QIODevice::pos")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Pos(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) Read2(maxSize int64) string {
	defer qt.Recovering("QIODevice::read")

	if ptr.Pointer() != nil {
		return C.GoString(C.QIODevice_Read2(ptr.Pointer(), C.longlong(maxSize)))
	}
	return ""
}

func (ptr *QIODevice) Read(data string, maxSize int64) int64 {
	defer qt.Recovering("QIODevice::read")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Read(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) ReadAll() string {
	defer qt.Recovering("QIODevice::readAll")

	if ptr.Pointer() != nil {
		return C.GoString(C.QIODevice_ReadAll(ptr.Pointer()))
	}
	return ""
}

func (ptr *QIODevice) ConnectReadChannelFinished(f func()) {
	defer qt.Recovering("connect QIODevice::readChannelFinished")

	if ptr.Pointer() != nil {
		C.QIODevice_ConnectReadChannelFinished(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "readChannelFinished", f)
	}
}

func (ptr *QIODevice) DisconnectReadChannelFinished() {
	defer qt.Recovering("disconnect QIODevice::readChannelFinished")

	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectReadChannelFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "readChannelFinished")
	}
}

//export callbackQIODeviceReadChannelFinished
func callbackQIODeviceReadChannelFinished(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QIODevice::readChannelFinished")

	if signal := qt.GetSignal(C.GoString(ptrName), "readChannelFinished"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QIODevice) ReadChannelFinished() {
	defer qt.Recovering("QIODevice::readChannelFinished")

	if ptr.Pointer() != nil {
		C.QIODevice_ReadChannelFinished(ptr.Pointer())
	}
}

func (ptr *QIODevice) ReadLine2(maxSize int64) string {
	defer qt.Recovering("QIODevice::readLine")

	if ptr.Pointer() != nil {
		return C.GoString(C.QIODevice_ReadLine2(ptr.Pointer(), C.longlong(maxSize)))
	}
	return ""
}

func (ptr *QIODevice) ReadLine(data string, maxSize int64) int64 {
	defer qt.Recovering("QIODevice::readLine")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_ReadLine(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) ReadLineData(data string, maxSize int64) int64 {
	defer qt.Recovering("QIODevice::readLineData")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_ReadLineData(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) ConnectReadyRead(f func()) {
	defer qt.Recovering("connect QIODevice::readyRead")

	if ptr.Pointer() != nil {
		C.QIODevice_ConnectReadyRead(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "readyRead", f)
	}
}

func (ptr *QIODevice) DisconnectReadyRead() {
	defer qt.Recovering("disconnect QIODevice::readyRead")

	if ptr.Pointer() != nil {
		C.QIODevice_DisconnectReadyRead(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "readyRead")
	}
}

//export callbackQIODeviceReadyRead
func callbackQIODeviceReadyRead(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QIODevice::readyRead")

	if signal := qt.GetSignal(C.GoString(ptrName), "readyRead"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QIODevice) ReadyRead() {
	defer qt.Recovering("QIODevice::readyRead")

	if ptr.Pointer() != nil {
		C.QIODevice_ReadyRead(ptr.Pointer())
	}
}

func (ptr *QIODevice) Reset() bool {
	defer qt.Recovering("QIODevice::reset")

	if ptr.Pointer() != nil {
		return C.QIODevice_Reset(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QIODevice) Seek(pos int64) bool {
	defer qt.Recovering("QIODevice::seek")

	if ptr.Pointer() != nil {
		return C.QIODevice_Seek(ptr.Pointer(), C.longlong(pos)) != 0
	}
	return false
}

func (ptr *QIODevice) SetTextModeEnabled(enabled bool) {
	defer qt.Recovering("QIODevice::setTextModeEnabled")

	if ptr.Pointer() != nil {
		C.QIODevice_SetTextModeEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(enabled)))
	}
}

func (ptr *QIODevice) Size() int64 {
	defer qt.Recovering("QIODevice::size")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QIODevice) UngetChar(c string) {
	defer qt.Recovering("QIODevice::ungetChar")

	if ptr.Pointer() != nil {
		C.QIODevice_UngetChar(ptr.Pointer(), C.CString(c))
	}
}

func (ptr *QIODevice) WaitForBytesWritten(msecs int) bool {
	defer qt.Recovering("QIODevice::waitForBytesWritten")

	if ptr.Pointer() != nil {
		return C.QIODevice_WaitForBytesWritten(ptr.Pointer(), C.int(msecs)) != 0
	}
	return false
}

func (ptr *QIODevice) WaitForReadyRead(msecs int) bool {
	defer qt.Recovering("QIODevice::waitForReadyRead")

	if ptr.Pointer() != nil {
		return C.QIODevice_WaitForReadyRead(ptr.Pointer(), C.int(msecs)) != 0
	}
	return false
}

func (ptr *QIODevice) Write3(byteArray string) int64 {
	defer qt.Recovering("QIODevice::write")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Write3(ptr.Pointer(), C.CString(byteArray)))
	}
	return 0
}

func (ptr *QIODevice) Write2(data string) int64 {
	defer qt.Recovering("QIODevice::write")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Write2(ptr.Pointer(), C.CString(data)))
	}
	return 0
}

func (ptr *QIODevice) Write(data string, maxSize int64) int64 {
	defer qt.Recovering("QIODevice::write")

	if ptr.Pointer() != nil {
		return int64(C.QIODevice_Write(ptr.Pointer(), C.CString(data), C.longlong(maxSize)))
	}
	return 0
}

func (ptr *QIODevice) DestroyQIODevice() {
	defer qt.Recovering("QIODevice::~QIODevice")

	if ptr.Pointer() != nil {
		C.QIODevice_DestroyQIODevice(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QIODevice) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QIODevice::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QIODevice) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QIODevice::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQIODeviceTimerEvent
func callbackQIODeviceTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QIODevice::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQIODeviceFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QIODevice) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QIODevice::timerEvent")

	if ptr.Pointer() != nil {
		C.QIODevice_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QIODevice) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QIODevice::timerEvent")

	if ptr.Pointer() != nil {
		C.QIODevice_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QIODevice) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QIODevice::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QIODevice) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QIODevice::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQIODeviceChildEvent
func callbackQIODeviceChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QIODevice::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQIODeviceFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QIODevice) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QIODevice::childEvent")

	if ptr.Pointer() != nil {
		C.QIODevice_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QIODevice) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QIODevice::childEvent")

	if ptr.Pointer() != nil {
		C.QIODevice_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QIODevice) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QIODevice::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QIODevice) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QIODevice::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQIODeviceCustomEvent
func callbackQIODeviceCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QIODevice::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQIODeviceFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QIODevice) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QIODevice::customEvent")

	if ptr.Pointer() != nil {
		C.QIODevice_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QIODevice) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QIODevice::customEvent")

	if ptr.Pointer() != nil {
		C.QIODevice_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QIdentityProxyModel struct {
	QAbstractProxyModel
}

type QIdentityProxyModel_ITF interface {
	QAbstractProxyModel_ITF
	QIdentityProxyModel_PTR() *QIdentityProxyModel
}

func PointerFromQIdentityProxyModel(ptr QIdentityProxyModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIdentityProxyModel_PTR().Pointer()
	}
	return nil
}

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

func newQIdentityProxyModelFromPointer(ptr unsafe.Pointer) *QIdentityProxyModel {
	var n = NewQIdentityProxyModelFromPointer(ptr)
	for len(n.ObjectName()) < len("QIdentityProxyModel_") {
		n.SetObjectName("QIdentityProxyModel_" + qt.Identifier())
	}
	return n
}

func (ptr *QIdentityProxyModel) QIdentityProxyModel_PTR() *QIdentityProxyModel {
	return ptr
}

func NewQIdentityProxyModel(parent QObject_ITF) *QIdentityProxyModel {
	defer qt.Recovering("QIdentityProxyModel::QIdentityProxyModel")

	return newQIdentityProxyModelFromPointer(C.QIdentityProxyModel_NewQIdentityProxyModel(PointerFromQObject(parent)))
}

func (ptr *QIdentityProxyModel) ColumnCount(parent QModelIndex_ITF) int {
	defer qt.Recovering("QIdentityProxyModel::columnCount")

	if ptr.Pointer() != nil {
		return int(C.QIdentityProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
	}
	return 0
}

func (ptr *QIdentityProxyModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QIdentityProxyModel::dropMimeData")

	if ptr.Pointer() != nil {
		return C.QIdentityProxyModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QIdentityProxyModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
	defer qt.Recovering("QIdentityProxyModel::headerData")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QIdentityProxyModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
	}
	return nil
}

func (ptr *QIdentityProxyModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QIdentityProxyModel::insertColumns")

	if ptr.Pointer() != nil {
		return C.QIdentityProxyModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QIdentityProxyModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QIdentityProxyModel::insertRows")

	if ptr.Pointer() != nil {
		return C.QIdentityProxyModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QIdentityProxyModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QIdentityProxyModel::removeColumns")

	if ptr.Pointer() != nil {
		return C.QIdentityProxyModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QIdentityProxyModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QIdentityProxyModel::removeRows")

	if ptr.Pointer() != nil {
		return C.QIdentityProxyModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QIdentityProxyModel) RowCount(parent QModelIndex_ITF) int {
	defer qt.Recovering("QIdentityProxyModel::rowCount")

	if ptr.Pointer() != nil {
		return int(C.QIdentityProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
	}
	return 0
}

func (ptr *QIdentityProxyModel) ConnectSetSourceModel(f func(newSourceModel *QAbstractItemModel)) {
	defer qt.Recovering("connect QIdentityProxyModel::setSourceModel")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "setSourceModel", f)
	}
}

func (ptr *QIdentityProxyModel) DisconnectSetSourceModel() {
	defer qt.Recovering("disconnect QIdentityProxyModel::setSourceModel")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "setSourceModel")
	}
}

//export callbackQIdentityProxyModelSetSourceModel
func callbackQIdentityProxyModelSetSourceModel(ptr unsafe.Pointer, ptrName *C.char, newSourceModel unsafe.Pointer) {
	defer qt.Recovering("callback QIdentityProxyModel::setSourceModel")

	if signal := qt.GetSignal(C.GoString(ptrName), "setSourceModel"); signal != nil {
		signal.(func(*QAbstractItemModel))(NewQAbstractItemModelFromPointer(newSourceModel))
	} else {
		NewQIdentityProxyModelFromPointer(ptr).SetSourceModelDefault(NewQAbstractItemModelFromPointer(newSourceModel))
	}
}

func (ptr *QIdentityProxyModel) SetSourceModel(newSourceModel QAbstractItemModel_ITF) {
	defer qt.Recovering("QIdentityProxyModel::setSourceModel")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_SetSourceModel(ptr.Pointer(), PointerFromQAbstractItemModel(newSourceModel))
	}
}

func (ptr *QIdentityProxyModel) SetSourceModelDefault(newSourceModel QAbstractItemModel_ITF) {
	defer qt.Recovering("QIdentityProxyModel::setSourceModel")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_SetSourceModelDefault(ptr.Pointer(), PointerFromQAbstractItemModel(newSourceModel))
	}
}

func (ptr *QIdentityProxyModel) DestroyQIdentityProxyModel() {
	defer qt.Recovering("QIdentityProxyModel::~QIdentityProxyModel")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_DestroyQIdentityProxyModel(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QIdentityProxyModel) ConnectRevert(f func()) {
	defer qt.Recovering("connect QIdentityProxyModel::revert")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
	}
}

func (ptr *QIdentityProxyModel) DisconnectRevert() {
	defer qt.Recovering("disconnect QIdentityProxyModel::revert")

	if ptr.Pointer() != nil {

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

//export callbackQIdentityProxyModelRevert
func callbackQIdentityProxyModelRevert(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QIdentityProxyModel::revert")

	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QIdentityProxyModel) Revert() {
	defer qt.Recovering("QIdentityProxyModel::revert")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_Revert(ptr.Pointer())
	}
}

func (ptr *QIdentityProxyModel) RevertDefault() {
	defer qt.Recovering("QIdentityProxyModel::revert")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_RevertDefault(ptr.Pointer())
	}
}

func (ptr *QIdentityProxyModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
	defer qt.Recovering("connect QIdentityProxyModel::sort")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
	}
}

func (ptr *QIdentityProxyModel) DisconnectSort() {
	defer qt.Recovering("disconnect QIdentityProxyModel::sort")

	if ptr.Pointer() != nil {

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

//export callbackQIdentityProxyModelSort
func callbackQIdentityProxyModelSort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
	defer qt.Recovering("callback QIdentityProxyModel::sort")

	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
	} else {
		NewQIdentityProxyModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
	}
}

func (ptr *QIdentityProxyModel) Sort(column int, order Qt__SortOrder) {
	defer qt.Recovering("QIdentityProxyModel::sort")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QIdentityProxyModel) SortDefault(column int, order Qt__SortOrder) {
	defer qt.Recovering("QIdentityProxyModel::sort")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QIdentityProxyModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QIdentityProxyModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QIdentityProxyModel) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QIdentityProxyModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQIdentityProxyModelTimerEvent
func callbackQIdentityProxyModelTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QIdentityProxyModel::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQIdentityProxyModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QIdentityProxyModel) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QIdentityProxyModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QIdentityProxyModel) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QIdentityProxyModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QIdentityProxyModel) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QIdentityProxyModel::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QIdentityProxyModel) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QIdentityProxyModel::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQIdentityProxyModelChildEvent
func callbackQIdentityProxyModelChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QIdentityProxyModel::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQIdentityProxyModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QIdentityProxyModel) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QIdentityProxyModel::childEvent")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QIdentityProxyModel) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QIdentityProxyModel::childEvent")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QIdentityProxyModel) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QIdentityProxyModel::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QIdentityProxyModel) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QIdentityProxyModel::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQIdentityProxyModelCustomEvent
func callbackQIdentityProxyModelCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QIdentityProxyModel::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQIdentityProxyModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QIdentityProxyModel) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QIdentityProxyModel::customEvent")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QIdentityProxyModel) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QIdentityProxyModel::customEvent")

	if ptr.Pointer() != nil {
		C.QIdentityProxyModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QItemSelection struct {
	QList
}

type QItemSelection_ITF interface {
	QList_ITF
	QItemSelection_PTR() *QItemSelection
}

func PointerFromQItemSelection(ptr QItemSelection_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemSelection_PTR().Pointer()
	}
	return nil
}

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

func newQItemSelectionFromPointer(ptr unsafe.Pointer) *QItemSelection {
	var n = NewQItemSelectionFromPointer(ptr)
	return n
}

func (ptr *QItemSelection) QItemSelection_PTR() *QItemSelection {
	return ptr
}

func NewQItemSelection() *QItemSelection {
	defer qt.Recovering("QItemSelection::QItemSelection")

	return newQItemSelectionFromPointer(C.QItemSelection_NewQItemSelection())
}

func NewQItemSelection2(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF) *QItemSelection {
	defer qt.Recovering("QItemSelection::QItemSelection")

	return newQItemSelectionFromPointer(C.QItemSelection_NewQItemSelection2(PointerFromQModelIndex(topLeft), PointerFromQModelIndex(bottomRight)))
}

func (ptr *QItemSelection) Contains(index QModelIndex_ITF) bool {
	defer qt.Recovering("QItemSelection::contains")

	if ptr.Pointer() != nil {
		return C.QItemSelection_Contains(ptr.Pointer(), PointerFromQModelIndex(index)) != 0
	}
	return false
}

func (ptr *QItemSelection) Merge(other QItemSelection_ITF, command QItemSelectionModel__SelectionFlag) {
	defer qt.Recovering("QItemSelection::merge")

	if ptr.Pointer() != nil {
		C.QItemSelection_Merge(ptr.Pointer(), PointerFromQItemSelection(other), C.int(command))
	}
}

func (ptr *QItemSelection) Select(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF) {
	defer qt.Recovering("QItemSelection::select")

	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) {
	defer qt.Recovering("QItemSelection::split")

	C.QItemSelection_QItemSelection_Split(PointerFromQItemSelectionRange(ran), PointerFromQItemSelectionRange(other), PointerFromQItemSelection(result))
}

type QItemSelectionModel struct {
	QObject
}

type QItemSelectionModel_ITF interface {
	QObject_ITF
	QItemSelectionModel_PTR() *QItemSelectionModel
}

func PointerFromQItemSelectionModel(ptr QItemSelectionModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemSelectionModel_PTR().Pointer()
	}
	return nil
}

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

func newQItemSelectionModelFromPointer(ptr unsafe.Pointer) *QItemSelectionModel {
	var n = NewQItemSelectionModelFromPointer(ptr)
	for len(n.ObjectName()) < len("QItemSelectionModel_") {
		n.SetObjectName("QItemSelectionModel_" + qt.Identifier())
	}
	return n
}

func (ptr *QItemSelectionModel) QItemSelectionModel_PTR() *QItemSelectionModel {
	return ptr
}

//QItemSelectionModel::SelectionFlag
type QItemSelectionModel__SelectionFlag int64

const (
	QItemSelectionModel__NoUpdate       = QItemSelectionModel__SelectionFlag(0x0000)
	QItemSelectionModel__Clear          = QItemSelectionModel__SelectionFlag(0x0001)
	QItemSelectionModel__Select         = QItemSelectionModel__SelectionFlag(0x0002)
	QItemSelectionModel__Deselect       = QItemSelectionModel__SelectionFlag(0x0004)
	QItemSelectionModel__Toggle         = QItemSelectionModel__SelectionFlag(0x0008)
	QItemSelectionModel__Current        = QItemSelectionModel__SelectionFlag(0x0010)
	QItemSelectionModel__Rows           = QItemSelectionModel__SelectionFlag(0x0020)
	QItemSelectionModel__Columns        = QItemSelectionModel__SelectionFlag(0x0040)
	QItemSelectionModel__SelectCurrent  = QItemSelectionModel__SelectionFlag(QItemSelectionModel__Select | QItemSelectionModel__Current)
	QItemSelectionModel__ToggleCurrent  = QItemSelectionModel__SelectionFlag(QItemSelectionModel__Toggle | QItemSelectionModel__Current)
	QItemSelectionModel__ClearAndSelect = QItemSelectionModel__SelectionFlag(QItemSelectionModel__Clear | QItemSelectionModel__Select)
)

func NewQItemSelectionModel(model QAbstractItemModel_ITF) *QItemSelectionModel {
	defer qt.Recovering("QItemSelectionModel::QItemSelectionModel")

	return newQItemSelectionModelFromPointer(C.QItemSelectionModel_NewQItemSelectionModel(PointerFromQAbstractItemModel(model)))
}

func NewQItemSelectionModel2(model QAbstractItemModel_ITF, parent QObject_ITF) *QItemSelectionModel {
	defer qt.Recovering("QItemSelectionModel::QItemSelectionModel")

	return newQItemSelectionModelFromPointer(C.QItemSelectionModel_NewQItemSelectionModel2(PointerFromQAbstractItemModel(model), PointerFromQObject(parent)))
}

func (ptr *QItemSelectionModel) ConnectClear(f func()) {
	defer qt.Recovering("connect QItemSelectionModel::clear")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "clear", f)
	}
}

func (ptr *QItemSelectionModel) DisconnectClear() {
	defer qt.Recovering("disconnect QItemSelectionModel::clear")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "clear")
	}
}

//export callbackQItemSelectionModelClear
func callbackQItemSelectionModelClear(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QItemSelectionModel::clear")

	if signal := qt.GetSignal(C.GoString(ptrName), "clear"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QItemSelectionModel) Clear() {
	defer qt.Recovering("QItemSelectionModel::clear")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_Clear(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ClearDefault() {
	defer qt.Recovering("QItemSelectionModel::clear")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ClearDefault(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ConnectClearCurrentIndex(f func()) {
	defer qt.Recovering("connect QItemSelectionModel::clearCurrentIndex")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "clearCurrentIndex", f)
	}
}

func (ptr *QItemSelectionModel) DisconnectClearCurrentIndex() {
	defer qt.Recovering("disconnect QItemSelectionModel::clearCurrentIndex")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "clearCurrentIndex")
	}
}

//export callbackQItemSelectionModelClearCurrentIndex
func callbackQItemSelectionModelClearCurrentIndex(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QItemSelectionModel::clearCurrentIndex")

	if signal := qt.GetSignal(C.GoString(ptrName), "clearCurrentIndex"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QItemSelectionModel) ClearCurrentIndex() {
	defer qt.Recovering("QItemSelectionModel::clearCurrentIndex")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ClearCurrentIndex(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ClearCurrentIndexDefault() {
	defer qt.Recovering("QItemSelectionModel::clearCurrentIndex")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ClearCurrentIndexDefault(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ClearSelection() {
	defer qt.Recovering("QItemSelectionModel::clearSelection")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ClearSelection(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ColumnIntersectsSelection(column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QItemSelectionModel::columnIntersectsSelection")

	if ptr.Pointer() != nil {
		return C.QItemSelectionModel_ColumnIntersectsSelection(ptr.Pointer(), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) HasSelection() bool {
	defer qt.Recovering("QItemSelectionModel::hasSelection")

	if ptr.Pointer() != nil {
		return C.QItemSelectionModel_HasSelection(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) IsColumnSelected(column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QItemSelectionModel::isColumnSelected")

	if ptr.Pointer() != nil {
		return C.QItemSelectionModel_IsColumnSelected(ptr.Pointer(), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) IsRowSelected(row int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QItemSelectionModel::isRowSelected")

	if ptr.Pointer() != nil {
		return C.QItemSelectionModel_IsRowSelected(ptr.Pointer(), C.int(row), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) IsSelected(index QModelIndex_ITF) bool {
	defer qt.Recovering("QItemSelectionModel::isSelected")

	if ptr.Pointer() != nil {
		return C.QItemSelectionModel_IsSelected(ptr.Pointer(), PointerFromQModelIndex(index)) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) Model2() *QAbstractItemModel {
	defer qt.Recovering("QItemSelectionModel::model")

	if ptr.Pointer() != nil {
		return NewQAbstractItemModelFromPointer(C.QItemSelectionModel_Model2(ptr.Pointer()))
	}
	return nil
}

func (ptr *QItemSelectionModel) Model() *QAbstractItemModel {
	defer qt.Recovering("QItemSelectionModel::model")

	if ptr.Pointer() != nil {
		return NewQAbstractItemModelFromPointer(C.QItemSelectionModel_Model(ptr.Pointer()))
	}
	return nil
}

func (ptr *QItemSelectionModel) ConnectModelChanged(f func(model *QAbstractItemModel)) {
	defer qt.Recovering("connect QItemSelectionModel::modelChanged")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ConnectModelChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "modelChanged", f)
	}
}

func (ptr *QItemSelectionModel) DisconnectModelChanged() {
	defer qt.Recovering("disconnect QItemSelectionModel::modelChanged")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_DisconnectModelChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "modelChanged")
	}
}

//export callbackQItemSelectionModelModelChanged
func callbackQItemSelectionModelModelChanged(ptr unsafe.Pointer, ptrName *C.char, model unsafe.Pointer) {
	defer qt.Recovering("callback QItemSelectionModel::modelChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "modelChanged"); signal != nil {
		signal.(func(*QAbstractItemModel))(NewQAbstractItemModelFromPointer(model))
	}

}

func (ptr *QItemSelectionModel) ModelChanged(model QAbstractItemModel_ITF) {
	defer qt.Recovering("QItemSelectionModel::modelChanged")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ModelChanged(ptr.Pointer(), PointerFromQAbstractItemModel(model))
	}
}

func (ptr *QItemSelectionModel) ConnectReset(f func()) {
	defer qt.Recovering("connect QItemSelectionModel::reset")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "reset", f)
	}
}

func (ptr *QItemSelectionModel) DisconnectReset() {
	defer qt.Recovering("disconnect QItemSelectionModel::reset")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "reset")
	}
}

//export callbackQItemSelectionModelReset
func callbackQItemSelectionModelReset(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QItemSelectionModel::reset")

	if signal := qt.GetSignal(C.GoString(ptrName), "reset"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QItemSelectionModel) Reset() {
	defer qt.Recovering("QItemSelectionModel::reset")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_Reset(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) ResetDefault() {
	defer qt.Recovering("QItemSelectionModel::reset")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ResetDefault(ptr.Pointer())
	}
}

func (ptr *QItemSelectionModel) RowIntersectsSelection(row int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QItemSelectionModel::rowIntersectsSelection")

	if ptr.Pointer() != nil {
		return C.QItemSelectionModel_RowIntersectsSelection(ptr.Pointer(), C.int(row), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QItemSelectionModel) SetModel(model QAbstractItemModel_ITF) {
	defer qt.Recovering("QItemSelectionModel::setModel")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_SetModel(ptr.Pointer(), PointerFromQAbstractItemModel(model))
	}
}

func (ptr *QItemSelectionModel) DestroyQItemSelectionModel() {
	defer qt.Recovering("QItemSelectionModel::~QItemSelectionModel")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_DestroyQItemSelectionModel(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QItemSelectionModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QItemSelectionModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QItemSelectionModel) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QItemSelectionModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQItemSelectionModelTimerEvent
func callbackQItemSelectionModelTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QItemSelectionModel::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQItemSelectionModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QItemSelectionModel) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QItemSelectionModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QItemSelectionModel) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QItemSelectionModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QItemSelectionModel) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QItemSelectionModel::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QItemSelectionModel) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QItemSelectionModel::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQItemSelectionModelChildEvent
func callbackQItemSelectionModelChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QItemSelectionModel::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQItemSelectionModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QItemSelectionModel) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QItemSelectionModel::childEvent")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QItemSelectionModel) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QItemSelectionModel::childEvent")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QItemSelectionModel) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QItemSelectionModel::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QItemSelectionModel) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QItemSelectionModel::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQItemSelectionModelCustomEvent
func callbackQItemSelectionModelCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QItemSelectionModel::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQItemSelectionModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QItemSelectionModel) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QItemSelectionModel::customEvent")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QItemSelectionModel) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QItemSelectionModel::customEvent")

	if ptr.Pointer() != nil {
		C.QItemSelectionModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QItemSelectionRange struct {
	ptr unsafe.Pointer
}

type QItemSelectionRange_ITF interface {
	QItemSelectionRange_PTR() *QItemSelectionRange
}

func (p *QItemSelectionRange) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QItemSelectionRange) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQItemSelectionRange(ptr QItemSelectionRange_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemSelectionRange_PTR().Pointer()
	}
	return nil
}

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

func newQItemSelectionRangeFromPointer(ptr unsafe.Pointer) *QItemSelectionRange {
	var n = NewQItemSelectionRangeFromPointer(ptr)
	return n
}

func (ptr *QItemSelectionRange) QItemSelectionRange_PTR() *QItemSelectionRange {
	return ptr
}

func (ptr *QItemSelectionRange) Intersected(other QItemSelectionRange_ITF) *QItemSelectionRange {
	defer qt.Recovering("QItemSelectionRange::intersected")

	if ptr.Pointer() != nil {
		return NewQItemSelectionRangeFromPointer(C.QItemSelectionRange_Intersected(ptr.Pointer(), PointerFromQItemSelectionRange(other)))
	}
	return nil
}

func (ptr *QItemSelectionRange) Intersects(other QItemSelectionRange_ITF) bool {
	defer qt.Recovering("QItemSelectionRange::intersects")

	if ptr.Pointer() != nil {
		return C.QItemSelectionRange_Intersects(ptr.Pointer(), PointerFromQItemSelectionRange(other)) != 0
	}
	return false
}

func NewQItemSelectionRange() *QItemSelectionRange {
	defer qt.Recovering("QItemSelectionRange::QItemSelectionRange")

	return newQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange())
}

func NewQItemSelectionRange2(other QItemSelectionRange_ITF) *QItemSelectionRange {
	defer qt.Recovering("QItemSelectionRange::QItemSelectionRange")

	return newQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange2(PointerFromQItemSelectionRange(other)))
}

func NewQItemSelectionRange4(index QModelIndex_ITF) *QItemSelectionRange {
	defer qt.Recovering("QItemSelectionRange::QItemSelectionRange")

	return newQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange4(PointerFromQModelIndex(index)))
}

func NewQItemSelectionRange3(topLeft QModelIndex_ITF, bottomRight QModelIndex_ITF) *QItemSelectionRange {
	defer qt.Recovering("QItemSelectionRange::QItemSelectionRange")

	return newQItemSelectionRangeFromPointer(C.QItemSelectionRange_NewQItemSelectionRange3(PointerFromQModelIndex(topLeft), PointerFromQModelIndex(bottomRight)))
}

func (ptr *QItemSelectionRange) Bottom() int {
	defer qt.Recovering("QItemSelectionRange::bottom")

	if ptr.Pointer() != nil {
		return int(C.QItemSelectionRange_Bottom(ptr.Pointer()))
	}
	return 0
}

func (ptr *QItemSelectionRange) BottomRight() *QPersistentModelIndex {
	defer qt.Recovering("QItemSelectionRange::bottomRight")

	if ptr.Pointer() != nil {
		return NewQPersistentModelIndexFromPointer(C.QItemSelectionRange_BottomRight(ptr.Pointer()))
	}
	return nil
}

func (ptr *QItemSelectionRange) Contains(index QModelIndex_ITF) bool {
	defer qt.Recovering("QItemSelectionRange::contains")

	if ptr.Pointer() != nil {
		return C.QItemSelectionRange_Contains(ptr.Pointer(), PointerFromQModelIndex(index)) != 0
	}
	return false
}

func (ptr *QItemSelectionRange) Contains2(row int, column int, parentIndex QModelIndex_ITF) bool {
	defer qt.Recovering("QItemSelectionRange::contains")

	if ptr.Pointer() != nil {
		return C.QItemSelectionRange_Contains2(ptr.Pointer(), C.int(row), C.int(column), PointerFromQModelIndex(parentIndex)) != 0
	}
	return false
}

func (ptr *QItemSelectionRange) Height() int {
	defer qt.Recovering("QItemSelectionRange::height")

	if ptr.Pointer() != nil {
		return int(C.QItemSelectionRange_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QItemSelectionRange) IsEmpty() bool {
	defer qt.Recovering("QItemSelectionRange::isEmpty")

	if ptr.Pointer() != nil {
		return C.QItemSelectionRange_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QItemSelectionRange) IsValid() bool {
	defer qt.Recovering("QItemSelectionRange::isValid")

	if ptr.Pointer() != nil {
		return C.QItemSelectionRange_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QItemSelectionRange) Left() int {
	defer qt.Recovering("QItemSelectionRange::left")

	if ptr.Pointer() != nil {
		return int(C.QItemSelectionRange_Left(ptr.Pointer()))
	}
	return 0
}

func (ptr *QItemSelectionRange) Model() *QAbstractItemModel {
	defer qt.Recovering("QItemSelectionRange::model")

	if ptr.Pointer() != nil {
		return NewQAbstractItemModelFromPointer(C.QItemSelectionRange_Model(ptr.Pointer()))
	}
	return nil
}

func (ptr *QItemSelectionRange) Right() int {
	defer qt.Recovering("QItemSelectionRange::right")

	if ptr.Pointer() != nil {
		return int(C.QItemSelectionRange_Right(ptr.Pointer()))
	}
	return 0
}

func (ptr *QItemSelectionRange) Top() int {
	defer qt.Recovering("QItemSelectionRange::top")

	if ptr.Pointer() != nil {
		return int(C.QItemSelectionRange_Top(ptr.Pointer()))
	}
	return 0
}

func (ptr *QItemSelectionRange) TopLeft() *QPersistentModelIndex {
	defer qt.Recovering("QItemSelectionRange::topLeft")

	if ptr.Pointer() != nil {
		return NewQPersistentModelIndexFromPointer(C.QItemSelectionRange_TopLeft(ptr.Pointer()))
	}
	return nil
}

func (ptr *QItemSelectionRange) Width() int {
	defer qt.Recovering("QItemSelectionRange::width")

	if ptr.Pointer() != nil {
		return int(C.QItemSelectionRange_Width(ptr.Pointer()))
	}
	return 0
}

type QJsonArray struct {
	ptr unsafe.Pointer
}

type QJsonArray_ITF interface {
	QJsonArray_PTR() *QJsonArray
}

func (p *QJsonArray) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QJsonArray) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQJsonArray(ptr QJsonArray_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonArray_PTR().Pointer()
	}
	return nil
}

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

func newQJsonArrayFromPointer(ptr unsafe.Pointer) *QJsonArray {
	var n = NewQJsonArrayFromPointer(ptr)
	return n
}

func (ptr *QJsonArray) QJsonArray_PTR() *QJsonArray {
	return ptr
}

func (ptr *QJsonArray) Append(value QJsonValue_ITF) {
	defer qt.Recovering("QJsonArray::append")

	if ptr.Pointer() != nil {
		C.QJsonArray_Append(ptr.Pointer(), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) At(i int) *QJsonValue {
	defer qt.Recovering("QJsonArray::at")

	if ptr.Pointer() != nil {
		return NewQJsonValueFromPointer(C.QJsonArray_At(ptr.Pointer(), C.int(i)))
	}
	return nil
}

func (ptr *QJsonArray) Contains(value QJsonValue_ITF) bool {
	defer qt.Recovering("QJsonArray::contains")

	if ptr.Pointer() != nil {
		return C.QJsonArray_Contains(ptr.Pointer(), PointerFromQJsonValue(value)) != 0
	}
	return false
}

func (ptr *QJsonArray) Count() int {
	defer qt.Recovering("QJsonArray::count")

	if ptr.Pointer() != nil {
		return int(C.QJsonArray_Count(ptr.Pointer()))
	}
	return 0
}

func (ptr *QJsonArray) Empty() bool {
	defer qt.Recovering("QJsonArray::empty")

	if ptr.Pointer() != nil {
		return C.QJsonArray_Empty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonArray) First() *QJsonValue {
	defer qt.Recovering("QJsonArray::first")

	if ptr.Pointer() != nil {
		return NewQJsonValueFromPointer(C.QJsonArray_First(ptr.Pointer()))
	}
	return nil
}

func QJsonArray_FromStringList(list []string) *QJsonArray {
	defer qt.Recovering("QJsonArray::fromStringList")

	return NewQJsonArrayFromPointer(C.QJsonArray_QJsonArray_FromStringList(C.CString(strings.Join(list, "|"))))
}

func (ptr *QJsonArray) IsEmpty() bool {
	defer qt.Recovering("QJsonArray::isEmpty")

	if ptr.Pointer() != nil {
		return C.QJsonArray_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonArray) Last() *QJsonValue {
	defer qt.Recovering("QJsonArray::last")

	if ptr.Pointer() != nil {
		return NewQJsonValueFromPointer(C.QJsonArray_Last(ptr.Pointer()))
	}
	return nil
}

func (ptr *QJsonArray) Pop_back() {
	defer qt.Recovering("QJsonArray::pop_back")

	if ptr.Pointer() != nil {
		C.QJsonArray_Pop_back(ptr.Pointer())
	}
}

func (ptr *QJsonArray) Pop_front() {
	defer qt.Recovering("QJsonArray::pop_front")

	if ptr.Pointer() != nil {
		C.QJsonArray_Pop_front(ptr.Pointer())
	}
}

func (ptr *QJsonArray) Prepend(value QJsonValue_ITF) {
	defer qt.Recovering("QJsonArray::prepend")

	if ptr.Pointer() != nil {
		C.QJsonArray_Prepend(ptr.Pointer(), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) Push_back(value QJsonValue_ITF) {
	defer qt.Recovering("QJsonArray::push_back")

	if ptr.Pointer() != nil {
		C.QJsonArray_Push_back(ptr.Pointer(), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) Push_front(value QJsonValue_ITF) {
	defer qt.Recovering("QJsonArray::push_front")

	if ptr.Pointer() != nil {
		C.QJsonArray_Push_front(ptr.Pointer(), PointerFromQJsonValue(value))
	}
}

func (ptr *QJsonArray) RemoveAt(i int) {
	defer qt.Recovering("QJsonArray::removeAt")

	if ptr.Pointer() != nil {
		C.QJsonArray_RemoveAt(ptr.Pointer(), C.int(i))
	}
}

func (ptr *QJsonArray) RemoveFirst() {
	defer qt.Recovering("QJsonArray::removeFirst")

	if ptr.Pointer() != nil {
		C.QJsonArray_RemoveFirst(ptr.Pointer())
	}
}

func (ptr *QJsonArray) RemoveLast() {
	defer qt.Recovering("QJsonArray::removeLast")

	if ptr.Pointer() != nil {
		C.QJsonArray_RemoveLast(ptr.Pointer())
	}
}

func (ptr *QJsonArray) Size() int {
	defer qt.Recovering("QJsonArray::size")

	if ptr.Pointer() != nil {
		return int(C.QJsonArray_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QJsonArray) TakeAt(i int) *QJsonValue {
	defer qt.Recovering("QJsonArray::takeAt")

	if ptr.Pointer() != nil {
		return NewQJsonValueFromPointer(C.QJsonArray_TakeAt(ptr.Pointer(), C.int(i)))
	}
	return nil
}

func (ptr *QJsonArray) DestroyQJsonArray() {
	defer qt.Recovering("QJsonArray::~QJsonArray")

	if ptr.Pointer() != nil {
		C.QJsonArray_DestroyQJsonArray(ptr.Pointer())
	}
}

type QJsonDocument struct {
	ptr unsafe.Pointer
}

type QJsonDocument_ITF interface {
	QJsonDocument_PTR() *QJsonDocument
}

func (p *QJsonDocument) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QJsonDocument) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQJsonDocument(ptr QJsonDocument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonDocument_PTR().Pointer()
	}
	return nil
}

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

func newQJsonDocumentFromPointer(ptr unsafe.Pointer) *QJsonDocument {
	var n = NewQJsonDocumentFromPointer(ptr)
	return n
}

func (ptr *QJsonDocument) QJsonDocument_PTR() *QJsonDocument {
	return ptr
}

//QJsonDocument::DataValidation
type QJsonDocument__DataValidation int64

const (
	QJsonDocument__Validate         = QJsonDocument__DataValidation(0)
	QJsonDocument__BypassValidation = QJsonDocument__DataValidation(1)
)

//QJsonDocument::JsonFormat
type QJsonDocument__JsonFormat int64

const (
	QJsonDocument__Indented = QJsonDocument__JsonFormat(0)
	QJsonDocument__Compact  = QJsonDocument__JsonFormat(1)
)

func NewQJsonDocument() *QJsonDocument {
	defer qt.Recovering("QJsonDocument::QJsonDocument")

	return newQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument())
}

func NewQJsonDocument3(array QJsonArray_ITF) *QJsonDocument {
	defer qt.Recovering("QJsonDocument::QJsonDocument")

	return newQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument3(PointerFromQJsonArray(array)))
}

func NewQJsonDocument4(other QJsonDocument_ITF) *QJsonDocument {
	defer qt.Recovering("QJsonDocument::QJsonDocument")

	return newQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument4(PointerFromQJsonDocument(other)))
}

func NewQJsonDocument2(object QJsonObject_ITF) *QJsonDocument {
	defer qt.Recovering("QJsonDocument::QJsonDocument")

	return newQJsonDocumentFromPointer(C.QJsonDocument_NewQJsonDocument2(PointerFromQJsonObject(object)))
}

func (ptr *QJsonDocument) Array() *QJsonArray {
	defer qt.Recovering("QJsonDocument::array")

	if ptr.Pointer() != nil {
		return NewQJsonArrayFromPointer(C.QJsonDocument_Array(ptr.Pointer()))
	}
	return nil
}

func QJsonDocument_FromBinaryData(data string, validation QJsonDocument__DataValidation) *QJsonDocument {
	defer qt.Recovering("QJsonDocument::fromBinaryData")

	return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromBinaryData(C.CString(data), C.int(validation)))
}

func QJsonDocument_FromJson(json string, error QJsonParseError_ITF) *QJsonDocument {
	defer qt.Recovering("QJsonDocument::fromJson")

	return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromJson(C.CString(json), PointerFromQJsonParseError(error)))
}

func QJsonDocument_FromRawData(data string, size int, validation QJsonDocument__DataValidation) *QJsonDocument {
	defer qt.Recovering("QJsonDocument::fromRawData")

	return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromRawData(C.CString(data), C.int(size), C.int(validation)))
}

func QJsonDocument_FromVariant(variant QVariant_ITF) *QJsonDocument {
	defer qt.Recovering("QJsonDocument::fromVariant")

	return NewQJsonDocumentFromPointer(C.QJsonDocument_QJsonDocument_FromVariant(PointerFromQVariant(variant)))
}

func (ptr *QJsonDocument) IsArray() bool {
	defer qt.Recovering("QJsonDocument::isArray")

	if ptr.Pointer() != nil {
		return C.QJsonDocument_IsArray(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonDocument) IsEmpty() bool {
	defer qt.Recovering("QJsonDocument::isEmpty")

	if ptr.Pointer() != nil {
		return C.QJsonDocument_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonDocument) IsNull() bool {
	defer qt.Recovering("QJsonDocument::isNull")

	if ptr.Pointer() != nil {
		return C.QJsonDocument_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonDocument) IsObject() bool {
	defer qt.Recovering("QJsonDocument::isObject")

	if ptr.Pointer() != nil {
		return C.QJsonDocument_IsObject(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonDocument) Object() *QJsonObject {
	defer qt.Recovering("QJsonDocument::object")

	if ptr.Pointer() != nil {
		return NewQJsonObjectFromPointer(C.QJsonDocument_Object(ptr.Pointer()))
	}
	return nil
}

func (ptr *QJsonDocument) SetArray(array QJsonArray_ITF) {
	defer qt.Recovering("QJsonDocument::setArray")

	if ptr.Pointer() != nil {
		C.QJsonDocument_SetArray(ptr.Pointer(), PointerFromQJsonArray(array))
	}
}

func (ptr *QJsonDocument) SetObject(object QJsonObject_ITF) {
	defer qt.Recovering("QJsonDocument::setObject")

	if ptr.Pointer() != nil {
		C.QJsonDocument_SetObject(ptr.Pointer(), PointerFromQJsonObject(object))
	}
}

func (ptr *QJsonDocument) ToBinaryData() string {
	defer qt.Recovering("QJsonDocument::toBinaryData")

	if ptr.Pointer() != nil {
		return C.GoString(C.QJsonDocument_ToBinaryData(ptr.Pointer()))
	}
	return ""
}

func (ptr *QJsonDocument) ToJson(format QJsonDocument__JsonFormat) string {
	defer qt.Recovering("QJsonDocument::toJson")

	if ptr.Pointer() != nil {
		return C.GoString(C.QJsonDocument_ToJson(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func (ptr *QJsonDocument) ToVariant() *QVariant {
	defer qt.Recovering("QJsonDocument::toVariant")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QJsonDocument_ToVariant(ptr.Pointer()))
	}
	return nil
}

func (ptr *QJsonDocument) DestroyQJsonDocument() {
	defer qt.Recovering("QJsonDocument::~QJsonDocument")

	if ptr.Pointer() != nil {
		C.QJsonDocument_DestroyQJsonDocument(ptr.Pointer())
	}
}

type QJsonObject struct {
	ptr unsafe.Pointer
}

type QJsonObject_ITF interface {
	QJsonObject_PTR() *QJsonObject
}

func (p *QJsonObject) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QJsonObject) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQJsonObject(ptr QJsonObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonObject_PTR().Pointer()
	}
	return nil
}

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

func newQJsonObjectFromPointer(ptr unsafe.Pointer) *QJsonObject {
	var n = NewQJsonObjectFromPointer(ptr)
	return n
}

func (ptr *QJsonObject) QJsonObject_PTR() *QJsonObject {
	return ptr
}

func (ptr *QJsonObject) Contains(key string) bool {
	defer qt.Recovering("QJsonObject::contains")

	if ptr.Pointer() != nil {
		return C.QJsonObject_Contains(ptr.Pointer(), C.CString(key)) != 0
	}
	return false
}

func (ptr *QJsonObject) Count() int {
	defer qt.Recovering("QJsonObject::count")

	if ptr.Pointer() != nil {
		return int(C.QJsonObject_Count(ptr.Pointer()))
	}
	return 0
}

func (ptr *QJsonObject) Empty() bool {
	defer qt.Recovering("QJsonObject::empty")

	if ptr.Pointer() != nil {
		return C.QJsonObject_Empty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonObject) IsEmpty() bool {
	defer qt.Recovering("QJsonObject::isEmpty")

	if ptr.Pointer() != nil {
		return C.QJsonObject_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonObject) Keys() []string {
	defer qt.Recovering("QJsonObject::keys")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QJsonObject_Keys(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QJsonObject) Length() int {
	defer qt.Recovering("QJsonObject::length")

	if ptr.Pointer() != nil {
		return int(C.QJsonObject_Length(ptr.Pointer()))
	}
	return 0
}

func (ptr *QJsonObject) Size() int {
	defer qt.Recovering("QJsonObject::size")

	if ptr.Pointer() != nil {
		return int(C.QJsonObject_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QJsonObject) Take(key string) *QJsonValue {
	defer qt.Recovering("QJsonObject::take")

	if ptr.Pointer() != nil {
		return NewQJsonValueFromPointer(C.QJsonObject_Take(ptr.Pointer(), C.CString(key)))
	}
	return nil
}

func (ptr *QJsonObject) Value(key string) *QJsonValue {
	defer qt.Recovering("QJsonObject::value")

	if ptr.Pointer() != nil {
		return NewQJsonValueFromPointer(C.QJsonObject_Value(ptr.Pointer(), C.CString(key)))
	}
	return nil
}

func (ptr *QJsonObject) DestroyQJsonObject() {
	defer qt.Recovering("QJsonObject::~QJsonObject")

	if ptr.Pointer() != nil {
		C.QJsonObject_DestroyQJsonObject(ptr.Pointer())
	}
}

type QJsonParseError struct {
	ptr unsafe.Pointer
}

type QJsonParseError_ITF interface {
	QJsonParseError_PTR() *QJsonParseError
}

func (p *QJsonParseError) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QJsonParseError) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQJsonParseError(ptr QJsonParseError_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonParseError_PTR().Pointer()
	}
	return nil
}

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

func newQJsonParseErrorFromPointer(ptr unsafe.Pointer) *QJsonParseError {
	var n = NewQJsonParseErrorFromPointer(ptr)
	return n
}

func (ptr *QJsonParseError) QJsonParseError_PTR() *QJsonParseError {
	return ptr
}

//QJsonParseError::ParseError
type QJsonParseError__ParseError int64

const (
	QJsonParseError__NoError               = QJsonParseError__ParseError(0)
	QJsonParseError__UnterminatedObject    = QJsonParseError__ParseError(1)
	QJsonParseError__MissingNameSeparator  = QJsonParseError__ParseError(2)
	QJsonParseError__UnterminatedArray     = QJsonParseError__ParseError(3)
	QJsonParseError__MissingValueSeparator = QJsonParseError__ParseError(4)
	QJsonParseError__IllegalValue          = QJsonParseError__ParseError(5)
	QJsonParseError__TerminationByNumber   = QJsonParseError__ParseError(6)
	QJsonParseError__IllegalNumber         = QJsonParseError__ParseError(7)
	QJsonParseError__IllegalEscapeSequence = QJsonParseError__ParseError(8)
	QJsonParseError__IllegalUTF8String     = QJsonParseError__ParseError(9)
	QJsonParseError__UnterminatedString    = QJsonParseError__ParseError(10)
	QJsonParseError__MissingObject         = QJsonParseError__ParseError(11)
	QJsonParseError__DeepNesting           = QJsonParseError__ParseError(12)
	QJsonParseError__DocumentTooLarge      = QJsonParseError__ParseError(13)
	QJsonParseError__GarbageAtEnd          = QJsonParseError__ParseError(14)
)

func (ptr *QJsonParseError) ErrorString() string {
	defer qt.Recovering("QJsonParseError::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QJsonParseError_ErrorString(ptr.Pointer()))
	}
	return ""
}

type QJsonValue struct {
	ptr unsafe.Pointer
}

type QJsonValue_ITF interface {
	QJsonValue_PTR() *QJsonValue
}

func (p *QJsonValue) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QJsonValue) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQJsonValue(ptr QJsonValue_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QJsonValue_PTR().Pointer()
	}
	return nil
}

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

func newQJsonValueFromPointer(ptr unsafe.Pointer) *QJsonValue {
	var n = NewQJsonValueFromPointer(ptr)
	return n
}

func (ptr *QJsonValue) QJsonValue_PTR() *QJsonValue {
	return ptr
}

//QJsonValue::Type
type QJsonValue__Type int64

const (
	QJsonValue__Null      = QJsonValue__Type(0x0)
	QJsonValue__Bool      = QJsonValue__Type(0x1)
	QJsonValue__Double    = QJsonValue__Type(0x2)
	QJsonValue__String    = QJsonValue__Type(0x3)
	QJsonValue__Array     = QJsonValue__Type(0x4)
	QJsonValue__Object    = QJsonValue__Type(0x5)
	QJsonValue__Undefined = QJsonValue__Type(0x80)
)

func NewQJsonValue5(s QLatin1String_ITF) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue5(PointerFromQLatin1String(s)))
}

func NewQJsonValue(ty QJsonValue__Type) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue(C.int(ty)))
}

func NewQJsonValue2(b bool) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue2(C.int(qt.GoBoolToInt(b))))
}

func NewQJsonValue7(a QJsonArray_ITF) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue7(PointerFromQJsonArray(a)))
}

func NewQJsonValue8(o QJsonObject_ITF) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue8(PointerFromQJsonObject(o)))
}

func NewQJsonValue9(other QJsonValue_ITF) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue9(PointerFromQJsonValue(other)))
}

func NewQJsonValue4(s string) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue4(C.CString(s)))
}

func NewQJsonValue6(s string) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue6(C.CString(s)))
}

func NewQJsonValue12(n int) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue12(C.int(n)))
}

func NewQJsonValue13(n int64) *QJsonValue {
	defer qt.Recovering("QJsonValue::QJsonValue")

	return newQJsonValueFromPointer(C.QJsonValue_NewQJsonValue13(C.longlong(n)))
}

func QJsonValue_FromVariant(variant QVariant_ITF) *QJsonValue {
	defer qt.Recovering("QJsonValue::fromVariant")

	return NewQJsonValueFromPointer(C.QJsonValue_QJsonValue_FromVariant(PointerFromQVariant(variant)))
}

func (ptr *QJsonValue) IsArray() bool {
	defer qt.Recovering("QJsonValue::isArray")

	if ptr.Pointer() != nil {
		return C.QJsonValue_IsArray(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonValue) IsBool() bool {
	defer qt.Recovering("QJsonValue::isBool")

	if ptr.Pointer() != nil {
		return C.QJsonValue_IsBool(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonValue) IsDouble() bool {
	defer qt.Recovering("QJsonValue::isDouble")

	if ptr.Pointer() != nil {
		return C.QJsonValue_IsDouble(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonValue) IsNull() bool {
	defer qt.Recovering("QJsonValue::isNull")

	if ptr.Pointer() != nil {
		return C.QJsonValue_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonValue) IsObject() bool {
	defer qt.Recovering("QJsonValue::isObject")

	if ptr.Pointer() != nil {
		return C.QJsonValue_IsObject(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonValue) IsString() bool {
	defer qt.Recovering("QJsonValue::isString")

	if ptr.Pointer() != nil {
		return C.QJsonValue_IsString(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonValue) IsUndefined() bool {
	defer qt.Recovering("QJsonValue::isUndefined")

	if ptr.Pointer() != nil {
		return C.QJsonValue_IsUndefined(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QJsonValue) ToArray2() *QJsonArray {
	defer qt.Recovering("QJsonValue::toArray")

	if ptr.Pointer() != nil {
		return NewQJsonArrayFromPointer(C.QJsonValue_ToArray2(ptr.Pointer()))
	}
	return nil
}

func (ptr *QJsonValue) ToArray(defaultValue QJsonArray_ITF) *QJsonArray {
	defer qt.Recovering("QJsonValue::toArray")

	if ptr.Pointer() != nil {
		return NewQJsonArrayFromPointer(C.QJsonValue_ToArray(ptr.Pointer(), PointerFromQJsonArray(defaultValue)))
	}
	return nil
}

func (ptr *QJsonValue) ToBool(defaultValue bool) bool {
	defer qt.Recovering("QJsonValue::toBool")

	if ptr.Pointer() != nil {
		return C.QJsonValue_ToBool(ptr.Pointer(), C.int(qt.GoBoolToInt(defaultValue))) != 0
	}
	return false
}

func (ptr *QJsonValue) ToInt(defaultValue int) int {
	defer qt.Recovering("QJsonValue::toInt")

	if ptr.Pointer() != nil {
		return int(C.QJsonValue_ToInt(ptr.Pointer(), C.int(defaultValue)))
	}
	return 0
}

func (ptr *QJsonValue) ToObject2() *QJsonObject {
	defer qt.Recovering("QJsonValue::toObject")

	if ptr.Pointer() != nil {
		return NewQJsonObjectFromPointer(C.QJsonValue_ToObject2(ptr.Pointer()))
	}
	return nil
}

func (ptr *QJsonValue) ToObject(defaultValue QJsonObject_ITF) *QJsonObject {
	defer qt.Recovering("QJsonValue::toObject")

	if ptr.Pointer() != nil {
		return NewQJsonObjectFromPointer(C.QJsonValue_ToObject(ptr.Pointer(), PointerFromQJsonObject(defaultValue)))
	}
	return nil
}

func (ptr *QJsonValue) ToString(defaultValue string) string {
	defer qt.Recovering("QJsonValue::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QJsonValue_ToString(ptr.Pointer(), C.CString(defaultValue)))
	}
	return ""
}

func (ptr *QJsonValue) ToVariant() *QVariant {
	defer qt.Recovering("QJsonValue::toVariant")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QJsonValue_ToVariant(ptr.Pointer()))
	}
	return nil
}

func (ptr *QJsonValue) Type() QJsonValue__Type {
	defer qt.Recovering("QJsonValue::type")

	if ptr.Pointer() != nil {
		return QJsonValue__Type(C.QJsonValue_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QJsonValue) DestroyQJsonValue() {
	defer qt.Recovering("QJsonValue::~QJsonValue")

	if ptr.Pointer() != nil {
		C.QJsonValue_DestroyQJsonValue(ptr.Pointer())
	}
}

type QLatin1Char struct {
	ptr unsafe.Pointer
}

type QLatin1Char_ITF interface {
	QLatin1Char_PTR() *QLatin1Char
}

func (p *QLatin1Char) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLatin1Char) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLatin1Char(ptr QLatin1Char_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLatin1Char_PTR().Pointer()
	}
	return nil
}

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

func newQLatin1CharFromPointer(ptr unsafe.Pointer) *QLatin1Char {
	var n = NewQLatin1CharFromPointer(ptr)
	return n
}

func (ptr *QLatin1Char) QLatin1Char_PTR() *QLatin1Char {
	return ptr
}

func NewQLatin1Char(c string) *QLatin1Char {
	defer qt.Recovering("QLatin1Char::QLatin1Char")

	return newQLatin1CharFromPointer(C.QLatin1Char_NewQLatin1Char(C.CString(c)))
}

type QLatin1String struct {
	ptr unsafe.Pointer
}

type QLatin1String_ITF interface {
	QLatin1String_PTR() *QLatin1String
}

func (p *QLatin1String) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLatin1String) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLatin1String(ptr QLatin1String_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLatin1String_PTR().Pointer()
	}
	return nil
}

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

func newQLatin1StringFromPointer(ptr unsafe.Pointer) *QLatin1String {
	var n = NewQLatin1StringFromPointer(ptr)
	return n
}

func (ptr *QLatin1String) QLatin1String_PTR() *QLatin1String {
	return ptr
}

func NewQLatin1String3(str string) *QLatin1String {
	defer qt.Recovering("QLatin1String::QLatin1String")

	return newQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String3(C.CString(str)))
}

func NewQLatin1String(str string) *QLatin1String {
	defer qt.Recovering("QLatin1String::QLatin1String")

	return newQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String(C.CString(str)))
}

func NewQLatin1String2(str string, size int) *QLatin1String {
	defer qt.Recovering("QLatin1String::QLatin1String")

	return newQLatin1StringFromPointer(C.QLatin1String_NewQLatin1String2(C.CString(str), C.int(size)))
}

func (ptr *QLatin1String) Size() int {
	defer qt.Recovering("QLatin1String::size")

	if ptr.Pointer() != nil {
		return int(C.QLatin1String_Size(ptr.Pointer()))
	}
	return 0
}

type QLibrary struct {
	QObject
}

type QLibrary_ITF interface {
	QObject_ITF
	QLibrary_PTR() *QLibrary
}

func PointerFromQLibrary(ptr QLibrary_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLibrary_PTR().Pointer()
	}
	return nil
}

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

func newQLibraryFromPointer(ptr unsafe.Pointer) *QLibrary {
	var n = NewQLibraryFromPointer(ptr)
	for len(n.ObjectName()) < len("QLibrary_") {
		n.SetObjectName("QLibrary_" + qt.Identifier())
	}
	return n
}

func (ptr *QLibrary) QLibrary_PTR() *QLibrary {
	return ptr
}

//QLibrary::LoadHint
type QLibrary__LoadHint int64

const (
	QLibrary__ResolveAllSymbolsHint     = QLibrary__LoadHint(0x01)
	QLibrary__ExportExternalSymbolsHint = QLibrary__LoadHint(0x02)
	QLibrary__LoadArchiveMemberHint     = QLibrary__LoadHint(0x04)
	QLibrary__PreventUnloadHint         = QLibrary__LoadHint(0x08)
	QLibrary__DeepBindHint              = QLibrary__LoadHint(0x10)
)

func (ptr *QLibrary) FileName() string {
	defer qt.Recovering("QLibrary::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLibrary_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLibrary) LoadHints() QLibrary__LoadHint {
	defer qt.Recovering("QLibrary::loadHints")

	if ptr.Pointer() != nil {
		return QLibrary__LoadHint(C.QLibrary_LoadHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLibrary) SetFileName(fileName string) {
	defer qt.Recovering("QLibrary::setFileName")

	if ptr.Pointer() != nil {
		C.QLibrary_SetFileName(ptr.Pointer(), C.CString(fileName))
	}
}

func (ptr *QLibrary) SetFileNameAndVersion(fileName string, versionNumber int) {
	defer qt.Recovering("QLibrary::setFileNameAndVersion")

	if ptr.Pointer() != nil {
		C.QLibrary_SetFileNameAndVersion(ptr.Pointer(), C.CString(fileName), C.int(versionNumber))
	}
}

func (ptr *QLibrary) SetLoadHints(hints QLibrary__LoadHint) {
	defer qt.Recovering("QLibrary::setLoadHints")

	if ptr.Pointer() != nil {
		C.QLibrary_SetLoadHints(ptr.Pointer(), C.int(hints))
	}
}

func NewQLibrary(parent QObject_ITF) *QLibrary {
	defer qt.Recovering("QLibrary::QLibrary")

	return newQLibraryFromPointer(C.QLibrary_NewQLibrary(PointerFromQObject(parent)))
}

func NewQLibrary2(fileName string, parent QObject_ITF) *QLibrary {
	defer qt.Recovering("QLibrary::QLibrary")

	return newQLibraryFromPointer(C.QLibrary_NewQLibrary2(C.CString(fileName), PointerFromQObject(parent)))
}

func NewQLibrary4(fileName string, version string, parent QObject_ITF) *QLibrary {
	defer qt.Recovering("QLibrary::QLibrary")

	return newQLibraryFromPointer(C.QLibrary_NewQLibrary4(C.CString(fileName), C.CString(version), PointerFromQObject(parent)))
}

func NewQLibrary3(fileName string, verNum int, parent QObject_ITF) *QLibrary {
	defer qt.Recovering("QLibrary::QLibrary")

	return newQLibraryFromPointer(C.QLibrary_NewQLibrary3(C.CString(fileName), C.int(verNum), PointerFromQObject(parent)))
}

func (ptr *QLibrary) ErrorString() string {
	defer qt.Recovering("QLibrary::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLibrary_ErrorString(ptr.Pointer()))
	}
	return ""
}

func QLibrary_IsLibrary(fileName string) bool {
	defer qt.Recovering("QLibrary::isLibrary")

	return C.QLibrary_QLibrary_IsLibrary(C.CString(fileName)) != 0
}

func (ptr *QLibrary) IsLoaded() bool {
	defer qt.Recovering("QLibrary::isLoaded")

	if ptr.Pointer() != nil {
		return C.QLibrary_IsLoaded(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLibrary) Load() bool {
	defer qt.Recovering("QLibrary::load")

	if ptr.Pointer() != nil {
		return C.QLibrary_Load(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLibrary) SetFileNameAndVersion2(fileName string, version string) {
	defer qt.Recovering("QLibrary::setFileNameAndVersion")

	if ptr.Pointer() != nil {
		C.QLibrary_SetFileNameAndVersion2(ptr.Pointer(), C.CString(fileName), C.CString(version))
	}
}

func (ptr *QLibrary) Unload() bool {
	defer qt.Recovering("QLibrary::unload")

	if ptr.Pointer() != nil {
		return C.QLibrary_Unload(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLibrary) DestroyQLibrary() {
	defer qt.Recovering("QLibrary::~QLibrary")

	if ptr.Pointer() != nil {
		C.QLibrary_DestroyQLibrary(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QLibrary) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QLibrary::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QLibrary) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QLibrary::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQLibraryTimerEvent
func callbackQLibraryTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QLibrary::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQLibraryFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QLibrary) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QLibrary::timerEvent")

	if ptr.Pointer() != nil {
		C.QLibrary_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QLibrary) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QLibrary::timerEvent")

	if ptr.Pointer() != nil {
		C.QLibrary_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QLibrary) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QLibrary::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QLibrary) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QLibrary::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQLibraryChildEvent
func callbackQLibraryChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QLibrary::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQLibraryFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QLibrary) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QLibrary::childEvent")

	if ptr.Pointer() != nil {
		C.QLibrary_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QLibrary) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QLibrary::childEvent")

	if ptr.Pointer() != nil {
		C.QLibrary_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QLibrary) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QLibrary::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QLibrary) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QLibrary::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQLibraryCustomEvent
func callbackQLibraryCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QLibrary::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQLibraryFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QLibrary) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QLibrary::customEvent")

	if ptr.Pointer() != nil {
		C.QLibrary_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QLibrary) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QLibrary::customEvent")

	if ptr.Pointer() != nil {
		C.QLibrary_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QLibraryInfo struct {
	ptr unsafe.Pointer
}

type QLibraryInfo_ITF interface {
	QLibraryInfo_PTR() *QLibraryInfo
}

func (p *QLibraryInfo) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLibraryInfo) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLibraryInfo(ptr QLibraryInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLibraryInfo_PTR().Pointer()
	}
	return nil
}

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

func newQLibraryInfoFromPointer(ptr unsafe.Pointer) *QLibraryInfo {
	var n = NewQLibraryInfoFromPointer(ptr)
	return n
}

func (ptr *QLibraryInfo) QLibraryInfo_PTR() *QLibraryInfo {
	return ptr
}

//QLibraryInfo::LibraryLocation
type QLibraryInfo__LibraryLocation int64

const (
	QLibraryInfo__PrefixPath             = QLibraryInfo__LibraryLocation(0)
	QLibraryInfo__DocumentationPath      = QLibraryInfo__LibraryLocation(1)
	QLibraryInfo__HeadersPath            = QLibraryInfo__LibraryLocation(2)
	QLibraryInfo__LibrariesPath          = QLibraryInfo__LibraryLocation(3)
	QLibraryInfo__LibraryExecutablesPath = QLibraryInfo__LibraryLocation(4)
	QLibraryInfo__BinariesPath           = QLibraryInfo__LibraryLocation(5)
	QLibraryInfo__PluginsPath            = QLibraryInfo__LibraryLocation(6)
	QLibraryInfo__ImportsPath            = QLibraryInfo__LibraryLocation(7)
	QLibraryInfo__Qml2ImportsPath        = QLibraryInfo__LibraryLocation(8)
	QLibraryInfo__ArchDataPath           = QLibraryInfo__LibraryLocation(9)
	QLibraryInfo__DataPath               = QLibraryInfo__LibraryLocation(10)
	QLibraryInfo__TranslationsPath       = QLibraryInfo__LibraryLocation(11)
	QLibraryInfo__ExamplesPath           = QLibraryInfo__LibraryLocation(12)
	QLibraryInfo__TestsPath              = QLibraryInfo__LibraryLocation(13)
	QLibraryInfo__SettingsPath           = QLibraryInfo__LibraryLocation(100)
)

func QLibraryInfo_IsDebugBuild() bool {
	defer qt.Recovering("QLibraryInfo::isDebugBuild")

	return C.QLibraryInfo_QLibraryInfo_IsDebugBuild() != 0
}

func QLibraryInfo_LicensedProducts() string {
	defer qt.Recovering("QLibraryInfo::licensedProducts")

	return C.GoString(C.QLibraryInfo_QLibraryInfo_LicensedProducts())
}

func QLibraryInfo_Licensee() string {
	defer qt.Recovering("QLibraryInfo::licensee")

	return C.GoString(C.QLibraryInfo_QLibraryInfo_Licensee())
}

func QLibraryInfo_Location(loc QLibraryInfo__LibraryLocation) string {
	defer qt.Recovering("QLibraryInfo::location")

	return C.GoString(C.QLibraryInfo_QLibraryInfo_Location(C.int(loc)))
}

type QLine struct {
	ptr unsafe.Pointer
}

type QLine_ITF interface {
	QLine_PTR() *QLine
}

func (p *QLine) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLine) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLine(ptr QLine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLine_PTR().Pointer()
	}
	return nil
}

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

func newQLineFromPointer(ptr unsafe.Pointer) *QLine {
	var n = NewQLineFromPointer(ptr)
	return n
}

func (ptr *QLine) QLine_PTR() *QLine {
	return ptr
}

func NewQLine() *QLine {
	defer qt.Recovering("QLine::QLine")

	return newQLineFromPointer(C.QLine_NewQLine())
}

func NewQLine2(p1 QPoint_ITF, p2 QPoint_ITF) *QLine {
	defer qt.Recovering("QLine::QLine")

	return newQLineFromPointer(C.QLine_NewQLine2(PointerFromQPoint(p1), PointerFromQPoint(p2)))
}

func NewQLine3(x1 int, y1 int, x2 int, y2 int) *QLine {
	defer qt.Recovering("QLine::QLine")

	return newQLineFromPointer(C.QLine_NewQLine3(C.int(x1), C.int(y1), C.int(x2), C.int(y2)))
}

func (ptr *QLine) Dx() int {
	defer qt.Recovering("QLine::dx")

	if ptr.Pointer() != nil {
		return int(C.QLine_Dx(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLine) Dy() int {
	defer qt.Recovering("QLine::dy")

	if ptr.Pointer() != nil {
		return int(C.QLine_Dy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLine) IsNull() bool {
	defer qt.Recovering("QLine::isNull")

	if ptr.Pointer() != nil {
		return C.QLine_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLine) P1() *QPoint {
	defer qt.Recovering("QLine::p1")

	if ptr.Pointer() != nil {
		return NewQPointFromPointer(C.QLine_P1(ptr.Pointer()))
	}
	return nil
}

func (ptr *QLine) P2() *QPoint {
	defer qt.Recovering("QLine::p2")

	if ptr.Pointer() != nil {
		return NewQPointFromPointer(C.QLine_P2(ptr.Pointer()))
	}
	return nil
}

func (ptr *QLine) SetLine(x1 int, y1 int, x2 int, y2 int) {
	defer qt.Recovering("QLine::setLine")

	if ptr.Pointer() != nil {
		C.QLine_SetLine(ptr.Pointer(), C.int(x1), C.int(y1), C.int(x2), C.int(y2))
	}
}

func (ptr *QLine) SetP1(p1 QPoint_ITF) {
	defer qt.Recovering("QLine::setP1")

	if ptr.Pointer() != nil {
		C.QLine_SetP1(ptr.Pointer(), PointerFromQPoint(p1))
	}
}

func (ptr *QLine) SetP2(p2 QPoint_ITF) {
	defer qt.Recovering("QLine::setP2")

	if ptr.Pointer() != nil {
		C.QLine_SetP2(ptr.Pointer(), PointerFromQPoint(p2))
	}
}

func (ptr *QLine) SetPoints(p1 QPoint_ITF, p2 QPoint_ITF) {
	defer qt.Recovering("QLine::setPoints")

	if ptr.Pointer() != nil {
		C.QLine_SetPoints(ptr.Pointer(), PointerFromQPoint(p1), PointerFromQPoint(p2))
	}
}

func (ptr *QLine) Translate(offset QPoint_ITF) {
	defer qt.Recovering("QLine::translate")

	if ptr.Pointer() != nil {
		C.QLine_Translate(ptr.Pointer(), PointerFromQPoint(offset))
	}
}

func (ptr *QLine) Translate2(dx int, dy int) {
	defer qt.Recovering("QLine::translate")

	if ptr.Pointer() != nil {
		C.QLine_Translate2(ptr.Pointer(), C.int(dx), C.int(dy))
	}
}

func (ptr *QLine) X1() int {
	defer qt.Recovering("QLine::x1")

	if ptr.Pointer() != nil {
		return int(C.QLine_X1(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLine) X2() int {
	defer qt.Recovering("QLine::x2")

	if ptr.Pointer() != nil {
		return int(C.QLine_X2(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLine) Y1() int {
	defer qt.Recovering("QLine::y1")

	if ptr.Pointer() != nil {
		return int(C.QLine_Y1(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLine) Y2() int {
	defer qt.Recovering("QLine::y2")

	if ptr.Pointer() != nil {
		return int(C.QLine_Y2(ptr.Pointer()))
	}
	return 0
}

type QLineF struct {
	ptr unsafe.Pointer
}

type QLineF_ITF interface {
	QLineF_PTR() *QLineF
}

func (p *QLineF) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLineF) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLineF(ptr QLineF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLineF_PTR().Pointer()
	}
	return nil
}

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

func newQLineFFromPointer(ptr unsafe.Pointer) *QLineF {
	var n = NewQLineFFromPointer(ptr)
	return n
}

func (ptr *QLineF) QLineF_PTR() *QLineF {
	return ptr
}

//QLineF::IntersectType
type QLineF__IntersectType int64

const (
	QLineF__NoIntersection        = QLineF__IntersectType(0)
	QLineF__BoundedIntersection   = QLineF__IntersectType(1)
	QLineF__UnboundedIntersection = QLineF__IntersectType(2)
)

func (ptr *QLineF) AngleTo(line QLineF_ITF) float64 {
	defer qt.Recovering("QLineF::angleTo")

	if ptr.Pointer() != nil {
		return float64(C.QLineF_AngleTo(ptr.Pointer(), PointerFromQLineF(line)))
	}
	return 0
}

func (ptr *QLineF) Intersect(line QLineF_ITF, intersectionPoint QPointF_ITF) QLineF__IntersectType {
	defer qt.Recovering("QLineF::intersect")

	if ptr.Pointer() != nil {
		return QLineF__IntersectType(C.QLineF_Intersect(ptr.Pointer(), PointerFromQLineF(line), PointerFromQPointF(intersectionPoint)))
	}
	return 0
}

func NewQLineF() *QLineF {
	defer qt.Recovering("QLineF::QLineF")

	return newQLineFFromPointer(C.QLineF_NewQLineF())
}

func NewQLineF4(line QLine_ITF) *QLineF {
	defer qt.Recovering("QLineF::QLineF")

	return newQLineFFromPointer(C.QLineF_NewQLineF4(PointerFromQLine(line)))
}

func NewQLineF2(p1 QPointF_ITF, p2 QPointF_ITF) *QLineF {
	defer qt.Recovering("QLineF::QLineF")

	return newQLineFFromPointer(C.QLineF_NewQLineF2(PointerFromQPointF(p1), PointerFromQPointF(p2)))
}

func NewQLineF3(x1 float64, y1 float64, x2 float64, y2 float64) *QLineF {
	defer qt.Recovering("QLineF::QLineF")

	return newQLineFFromPointer(C.QLineF_NewQLineF3(C.double(x1), C.double(y1), C.double(x2), C.double(y2)))
}

func (ptr *QLineF) Angle() float64 {
	defer qt.Recovering("QLineF::angle")

	if ptr.Pointer() != nil {
		return float64(C.QLineF_Angle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) Dx() float64 {
	defer qt.Recovering("QLineF::dx")

	if ptr.Pointer() != nil {
		return float64(C.QLineF_Dx(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) Dy() float64 {
	defer qt.Recovering("QLineF::dy")

	if ptr.Pointer() != nil {
		return float64(C.QLineF_Dy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) IsNull() bool {
	defer qt.Recovering("QLineF::isNull")

	if ptr.Pointer() != nil {
		return C.QLineF_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLineF) Length() float64 {
	defer qt.Recovering("QLineF::length")

	if ptr.Pointer() != nil {
		return float64(C.QLineF_Length(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) SetAngle(angle float64) {
	defer qt.Recovering("QLineF::setAngle")

	if ptr.Pointer() != nil {
		C.QLineF_SetAngle(ptr.Pointer(), C.double(angle))
	}
}

func (ptr *QLineF) SetLength(length float64) {
	defer qt.Recovering("QLineF::setLength")

	if ptr.Pointer() != nil {
		C.QLineF_SetLength(ptr.Pointer(), C.double(length))
	}
}

func (ptr *QLineF) SetLine(x1 float64, y1 float64, x2 float64, y2 float64) {
	defer qt.Recovering("QLineF::setLine")

	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) {
	defer qt.Recovering("QLineF::setP1")

	if ptr.Pointer() != nil {
		C.QLineF_SetP1(ptr.Pointer(), PointerFromQPointF(p1))
	}
}

func (ptr *QLineF) SetP2(p2 QPointF_ITF) {
	defer qt.Recovering("QLineF::setP2")

	if ptr.Pointer() != nil {
		C.QLineF_SetP2(ptr.Pointer(), PointerFromQPointF(p2))
	}
}

func (ptr *QLineF) SetPoints(p1 QPointF_ITF, p2 QPointF_ITF) {
	defer qt.Recovering("QLineF::setPoints")

	if ptr.Pointer() != nil {
		C.QLineF_SetPoints(ptr.Pointer(), PointerFromQPointF(p1), PointerFromQPointF(p2))
	}
}

func (ptr *QLineF) Translate(offset QPointF_ITF) {
	defer qt.Recovering("QLineF::translate")

	if ptr.Pointer() != nil {
		C.QLineF_Translate(ptr.Pointer(), PointerFromQPointF(offset))
	}
}

func (ptr *QLineF) Translate2(dx float64, dy float64) {
	defer qt.Recovering("QLineF::translate")

	if ptr.Pointer() != nil {
		C.QLineF_Translate2(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

func (ptr *QLineF) X1() float64 {
	defer qt.Recovering("QLineF::x1")

	if ptr.Pointer() != nil {
		return float64(C.QLineF_X1(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) X2() float64 {
	defer qt.Recovering("QLineF::x2")

	if ptr.Pointer() != nil {
		return float64(C.QLineF_X2(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) Y1() float64 {
	defer qt.Recovering("QLineF::y1")

	if ptr.Pointer() != nil {
		return float64(C.QLineF_Y1(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineF) Y2() float64 {
	defer qt.Recovering("QLineF::y2")

	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 (p *QLinkedList) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLinkedList) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLinkedList(ptr QLinkedList_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLinkedList_PTR().Pointer()
	}
	return nil
}

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

func newQLinkedListFromPointer(ptr unsafe.Pointer) *QLinkedList {
	var n = NewQLinkedListFromPointer(ptr)
	return n
}

func (ptr *QLinkedList) QLinkedList_PTR() *QLinkedList {
	return ptr
}

type QLinkedListIterator struct {
	ptr unsafe.Pointer
}

type QLinkedListIterator_ITF interface {
	QLinkedListIterator_PTR() *QLinkedListIterator
}

func (p *QLinkedListIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLinkedListIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLinkedListIterator(ptr QLinkedListIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLinkedListIterator_PTR().Pointer()
	}
	return nil
}

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

func newQLinkedListIteratorFromPointer(ptr unsafe.Pointer) *QLinkedListIterator {
	var n = NewQLinkedListIteratorFromPointer(ptr)
	return n
}

func (ptr *QLinkedListIterator) QLinkedListIterator_PTR() *QLinkedListIterator {
	return ptr
}

type QList struct {
	ptr unsafe.Pointer
}

type QList_ITF interface {
	QList_PTR() *QList
}

func (p *QList) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QList) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQList(ptr QList_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QList_PTR().Pointer()
	}
	return nil
}

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

func newQListFromPointer(ptr unsafe.Pointer) *QList {
	var n = NewQListFromPointer(ptr)
	return n
}

func (ptr *QList) QList_PTR() *QList {
	return ptr
}

type QListIterator struct {
	ptr unsafe.Pointer
}

type QListIterator_ITF interface {
	QListIterator_PTR() *QListIterator
}

func (p *QListIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QListIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQListIterator(ptr QListIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QListIterator_PTR().Pointer()
	}
	return nil
}

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

func newQListIteratorFromPointer(ptr unsafe.Pointer) *QListIterator {
	var n = NewQListIteratorFromPointer(ptr)
	return n
}

func (ptr *QListIterator) QListIterator_PTR() *QListIterator {
	return ptr
}

type QLocale struct {
	ptr unsafe.Pointer
}

type QLocale_ITF interface {
	QLocale_PTR() *QLocale
}

func (p *QLocale) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLocale) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLocale(ptr QLocale_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLocale_PTR().Pointer()
	}
	return nil
}

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

func newQLocaleFromPointer(ptr unsafe.Pointer) *QLocale {
	var n = NewQLocaleFromPointer(ptr)
	return n
}

func (ptr *QLocale) QLocale_PTR() *QLocale {
	return ptr
}

//QLocale::Country
type QLocale__Country int64

const (
	QLocale__AnyCountry                             = QLocale__Country(0)
	QLocale__Afghanistan                            = QLocale__Country(1)
	QLocale__Albania                                = QLocale__Country(2)
	QLocale__Algeria                                = QLocale__Country(3)
	QLocale__AmericanSamoa                          = QLocale__Country(4)
	QLocale__Andorra                                = QLocale__Country(5)
	QLocale__Angola                                 = QLocale__Country(6)
	QLocale__Anguilla                               = QLocale__Country(7)
	QLocale__Antarctica                             = QLocale__Country(8)
	QLocale__AntiguaAndBarbuda                      = QLocale__Country(9)
	QLocale__Argentina                              = QLocale__Country(10)
	QLocale__Armenia                                = QLocale__Country(11)
	QLocale__Aruba                                  = QLocale__Country(12)
	QLocale__Australia                              = QLocale__Country(13)
	QLocale__Austria                                = QLocale__Country(14)
	QLocale__Azerbaijan                             = QLocale__Country(15)
	QLocale__Bahamas                                = QLocale__Country(16)
	QLocale__Bahrain                                = QLocale__Country(17)
	QLocale__Bangladesh                             = QLocale__Country(18)
	QLocale__Barbados                               = QLocale__Country(19)
	QLocale__Belarus                                = QLocale__Country(20)
	QLocale__Belgium                                = QLocale__Country(21)
	QLocale__Belize                                 = QLocale__Country(22)
	QLocale__Benin                                  = QLocale__Country(23)
	QLocale__Bermuda                                = QLocale__Country(24)
	QLocale__Bhutan                                 = QLocale__Country(25)
	QLocale__Bolivia                                = QLocale__Country(26)
	QLocale__BosniaAndHerzegowina                   = QLocale__Country(27)
	QLocale__Botswana                               = QLocale__Country(28)
	QLocale__BouvetIsland                           = QLocale__Country(29)
	QLocale__Brazil                                 = QLocale__Country(30)
	QLocale__BritishIndianOceanTerritory            = QLocale__Country(31)
	QLocale__Brunei                                 = QLocale__Country(32)
	QLocale__Bulgaria                               = QLocale__Country(33)
	QLocale__BurkinaFaso                            = QLocale__Country(34)
	QLocale__Burundi                                = QLocale__Country(35)
	QLocale__Cambodia                               = QLocale__Country(36)
	QLocale__Cameroon                               = QLocale__Country(37)
	QLocale__Canada                                 = QLocale__Country(38)
	QLocale__CapeVerde                              = QLocale__Country(39)
	QLocale__CaymanIslands                          = QLocale__Country(40)
	QLocale__CentralAfricanRepublic                 = QLocale__Country(41)
	QLocale__Chad                                   = QLocale__Country(42)
	QLocale__Chile                                  = QLocale__Country(43)
	QLocale__China                                  = QLocale__Country(44)
	QLocale__ChristmasIsland                        = QLocale__Country(45)
	QLocale__CocosIslands                           = QLocale__Country(46)
	QLocale__Colombia                               = QLocale__Country(47)
	QLocale__Comoros                                = QLocale__Country(48)
	QLocale__CongoKinshasa                          = QLocale__Country(49)
	QLocale__CongoBrazzaville                       = QLocale__Country(50)
	QLocale__CookIslands                            = QLocale__Country(51)
	QLocale__CostaRica                              = QLocale__Country(52)
	QLocale__IvoryCoast                             = QLocale__Country(53)
	QLocale__Croatia                                = QLocale__Country(54)
	QLocale__Cuba                                   = QLocale__Country(55)
	QLocale__Cyprus                                 = QLocale__Country(56)
	QLocale__CzechRepublic                          = QLocale__Country(57)
	QLocale__Denmark                                = QLocale__Country(58)
	QLocale__Djibouti                               = QLocale__Country(59)
	QLocale__Dominica                               = QLocale__Country(60)
	QLocale__DominicanRepublic                      = QLocale__Country(61)
	QLocale__EastTimor                              = QLocale__Country(62)
	QLocale__Ecuador                                = QLocale__Country(63)
	QLocale__Egypt                                  = QLocale__Country(64)
	QLocale__ElSalvador                             = QLocale__Country(65)
	QLocale__EquatorialGuinea                       = QLocale__Country(66)
	QLocale__Eritrea                                = QLocale__Country(67)
	QLocale__Estonia                                = QLocale__Country(68)
	QLocale__Ethiopia                               = QLocale__Country(69)
	QLocale__FalklandIslands                        = QLocale__Country(70)
	QLocale__FaroeIslands                           = QLocale__Country(71)
	QLocale__Fiji                                   = QLocale__Country(72)
	QLocale__Finland                                = QLocale__Country(73)
	QLocale__France                                 = QLocale__Country(74)
	QLocale__Guernsey                               = QLocale__Country(75)
	QLocale__FrenchGuiana                           = QLocale__Country(76)
	QLocale__FrenchPolynesia                        = QLocale__Country(77)
	QLocale__FrenchSouthernTerritories              = QLocale__Country(78)
	QLocale__Gabon                                  = QLocale__Country(79)
	QLocale__Gambia                                 = QLocale__Country(80)
	QLocale__Georgia                                = QLocale__Country(81)
	QLocale__Germany                                = QLocale__Country(82)
	QLocale__Ghana                                  = QLocale__Country(83)
	QLocale__Gibraltar                              = QLocale__Country(84)
	QLocale__Greece                                 = QLocale__Country(85)
	QLocale__Greenland                              = QLocale__Country(86)
	QLocale__Grenada                                = QLocale__Country(87)
	QLocale__Guadeloupe                             = QLocale__Country(88)
	QLocale__Guam                                   = QLocale__Country(89)
	QLocale__Guatemala                              = QLocale__Country(90)
	QLocale__Guinea                                 = QLocale__Country(91)
	QLocale__GuineaBissau                           = QLocale__Country(92)
	QLocale__Guyana                                 = QLocale__Country(93)
	QLocale__Haiti                                  = QLocale__Country(94)
	QLocale__HeardAndMcDonaldIslands                = QLocale__Country(95)
	QLocale__Honduras                               = QLocale__Country(96)
	QLocale__HongKong                               = QLocale__Country(97)
	QLocale__Hungary                                = QLocale__Country(98)
	QLocale__Iceland                                = QLocale__Country(99)
	QLocale__India                                  = QLocale__Country(100)
	QLocale__Indonesia                              = QLocale__Country(101)
	QLocale__Iran                                   = QLocale__Country(102)
	QLocale__Iraq                                   = QLocale__Country(103)
	QLocale__Ireland                                = QLocale__Country(104)
	QLocale__Israel                                 = QLocale__Country(105)
	QLocale__Italy                                  = QLocale__Country(106)
	QLocale__Jamaica                                = QLocale__Country(107)
	QLocale__Japan                                  = QLocale__Country(108)
	QLocale__Jordan                                 = QLocale__Country(109)
	QLocale__Kazakhstan                             = QLocale__Country(110)
	QLocale__Kenya                                  = QLocale__Country(111)
	QLocale__Kiribati                               = QLocale__Country(112)
	QLocale__NorthKorea                             = QLocale__Country(113)
	QLocale__SouthKorea                             = QLocale__Country(114)
	QLocale__Kuwait                                 = QLocale__Country(115)
	QLocale__Kyrgyzstan                             = QLocale__Country(116)
	QLocale__Laos                                   = QLocale__Country(117)
	QLocale__Latvia                                 = QLocale__Country(118)
	QLocale__Lebanon                                = QLocale__Country(119)
	QLocale__Lesotho                                = QLocale__Country(120)
	QLocale__Liberia                                = QLocale__Country(121)
	QLocale__Libya                                  = QLocale__Country(122)
	QLocale__Liechtenstein                          = QLocale__Country(123)
	QLocale__Lithuania                              = QLocale__Country(124)
	QLocale__Luxembourg                             = QLocale__Country(125)
	QLocale__Macau                                  = QLocale__Country(126)
	QLocale__Macedonia                              = QLocale__Country(127)
	QLocale__Madagascar                             = QLocale__Country(128)
	QLocale__Malawi                                 = QLocale__Country(129)
	QLocale__Malaysia                               = QLocale__Country(130)
	QLocale__Maldives                               = QLocale__Country(131)
	QLocale__Mali                                   = QLocale__Country(132)
	QLocale__Malta                                  = QLocale__Country(133)
	QLocale__MarshallIslands                        = QLocale__Country(134)
	QLocale__Martinique                             = QLocale__Country(135)
	QLocale__Mauritania                             = QLocale__Country(136)
	QLocale__Mauritius                              = QLocale__Country(137)
	QLocale__Mayotte                                = QLocale__Country(138)
	QLocale__Mexico                                 = QLocale__Country(139)
	QLocale__Micronesia                             = QLocale__Country(140)
	QLocale__Moldova                                = QLocale__Country(141)
	QLocale__Monaco                                 = QLocale__Country(142)
	QLocale__Mongolia                               = QLocale__Country(143)
	QLocale__Montserrat                             = QLocale__Country(144)
	QLocale__Morocco                                = QLocale__Country(145)
	QLocale__Mozambique                             = QLocale__Country(146)
	QLocale__Myanmar                                = QLocale__Country(147)
	QLocale__Namibia                                = QLocale__Country(148)
	QLocale__NauruCountry                           = QLocale__Country(149)
	QLocale__Nepal                                  = QLocale__Country(150)
	QLocale__Netherlands                            = QLocale__Country(151)
	QLocale__CuraSao                                = QLocale__Country(152)
	QLocale__NewCaledonia                           = QLocale__Country(153)
	QLocale__NewZealand                             = QLocale__Country(154)
	QLocale__Nicaragua                              = QLocale__Country(155)
	QLocale__Niger                                  = QLocale__Country(156)
	QLocale__Nigeria                                = QLocale__Country(157)
	QLocale__Niue                                   = QLocale__Country(158)
	QLocale__NorfolkIsland                          = QLocale__Country(159)
	QLocale__NorthernMarianaIslands                 = QLocale__Country(160)
	QLocale__Norway                                 = QLocale__Country(161)
	QLocale__Oman                                   = QLocale__Country(162)
	QLocale__Pakistan                               = QLocale__Country(163)
	QLocale__Palau                                  = QLocale__Country(164)
	QLocale__PalestinianTerritories                 = QLocale__Country(165)
	QLocale__Panama                                 = QLocale__Country(166)
	QLocale__PapuaNewGuinea                         = QLocale__Country(167)
	QLocale__Paraguay                               = QLocale__Country(168)
	QLocale__Peru                                   = QLocale__Country(169)
	QLocale__Philippines                            = QLocale__Country(170)
	QLocale__Pitcairn                               = QLocale__Country(171)
	QLocale__Poland                                 = QLocale__Country(172)
	QLocale__Portugal                               = QLocale__Country(173)
	QLocale__PuertoRico                             = QLocale__Country(174)
	QLocale__Qatar                                  = QLocale__Country(175)
	QLocale__Reunion                                = QLocale__Country(176)
	QLocale__Romania                                = QLocale__Country(177)
	QLocale__Russia                                 = QLocale__Country(178)
	QLocale__Rwanda                                 = QLocale__Country(179)
	QLocale__SaintKittsAndNevis                     = QLocale__Country(180)
	QLocale__SaintLucia                             = QLocale__Country(181)
	QLocale__SaintVincentAndTheGrenadines           = QLocale__Country(182)
	QLocale__Samoa                                  = QLocale__Country(183)
	QLocale__SanMarino                              = QLocale__Country(184)
	QLocale__SaoTomeAndPrincipe                     = QLocale__Country(185)
	QLocale__SaudiArabia                            = QLocale__Country(186)
	QLocale__Senegal                                = QLocale__Country(187)
	QLocale__Seychelles                             = QLocale__Country(188)
	QLocale__SierraLeone                            = QLocale__Country(189)
	QLocale__Singapore                              = QLocale__Country(190)
	QLocale__Slovakia                               = QLocale__Country(191)
	QLocale__Slovenia                               = QLocale__Country(192)
	QLocale__SolomonIslands                         = QLocale__Country(193)
	QLocale__Somalia                                = QLocale__Country(194)
	QLocale__SouthAfrica                            = QLocale__Country(195)
	QLocale__SouthGeorgiaAndTheSouthSandwichIslands = QLocale__Country(196)
	QLocale__Spain                                  = QLocale__Country(197)
	QLocale__SriLanka                               = QLocale__Country(198)
	QLocale__SaintHelena                            = QLocale__Country(199)
	QLocale__SaintPierreAndMiquelon                 = QLocale__Country(200)
	QLocale__Sudan                                  = QLocale__Country(201)
	QLocale__Suriname                               = QLocale__Country(202)
	QLocale__SvalbardAndJanMayenIslands             = QLocale__Country(203)
	QLocale__Swaziland                              = QLocale__Country(204)
	QLocale__Sweden                                 = QLocale__Country(205)
	QLocale__Switzerland                            = QLocale__Country(206)
	QLocale__Syria                                  = QLocale__Country(207)
	QLocale__Taiwan                                 = QLocale__Country(208)
	QLocale__Tajikistan                             = QLocale__Country(209)
	QLocale__Tanzania                               = QLocale__Country(210)
	QLocale__Thailand                               = QLocale__Country(211)
	QLocale__Togo                                   = QLocale__Country(212)
	QLocale__Tokelau                                = QLocale__Country(213)
	QLocale__Tonga                                  = QLocale__Country(214)
	QLocale__TrinidadAndTobago                      = QLocale__Country(215)
	QLocale__Tunisia                                = QLocale__Country(216)
	QLocale__Turkey                                 = QLocale__Country(217)
	QLocale__Turkmenistan                           = QLocale__Country(218)
	QLocale__TurksAndCaicosIslands                  = QLocale__Country(219)
	QLocale__Tuvalu                                 = QLocale__Country(220)
	QLocale__Uganda                                 = QLocale__Country(221)
	QLocale__Ukraine                                = QLocale__Country(222)
	QLocale__UnitedArabEmirates                     = QLocale__Country(223)
	QLocale__UnitedKingdom                          = QLocale__Country(224)
	QLocale__UnitedStates                           = QLocale__Country(225)
	QLocale__UnitedStatesMinorOutlyingIslands       = QLocale__Country(226)
	QLocale__Uruguay                                = QLocale__Country(227)
	QLocale__Uzbekistan                             = QLocale__Country(228)
	QLocale__Vanuatu                                = QLocale__Country(229)
	QLocale__VaticanCityState                       = QLocale__Country(230)
	QLocale__Venezuela                              = QLocale__Country(231)
	QLocale__Vietnam                                = QLocale__Country(232)
	QLocale__BritishVirginIslands                   = QLocale__Country(233)
	QLocale__UnitedStatesVirginIslands              = QLocale__Country(234)
	QLocale__WallisAndFutunaIslands                 = QLocale__Country(235)
	QLocale__WesternSahara                          = QLocale__Country(236)
	QLocale__Yemen                                  = QLocale__Country(237)
	QLocale__CanaryIslands                          = QLocale__Country(238)
	QLocale__Zambia                                 = QLocale__Country(239)
	QLocale__Zimbabwe                               = QLocale__Country(240)
	QLocale__ClippertonIsland                       = QLocale__Country(241)
	QLocale__Montenegro                             = QLocale__Country(242)
	QLocale__Serbia                                 = QLocale__Country(243)
	QLocale__SaintBarthelemy                        = QLocale__Country(244)
	QLocale__SaintMartin                            = QLocale__Country(245)
	QLocale__LatinAmericaAndTheCaribbean            = QLocale__Country(246)
	QLocale__AscensionIsland                        = QLocale__Country(247)
	QLocale__AlandIslands                           = QLocale__Country(248)
	QLocale__DiegoGarcia                            = QLocale__Country(249)
	QLocale__CeutaAndMelilla                        = QLocale__Country(250)
	QLocale__IsleOfMan                              = QLocale__Country(251)
	QLocale__Jersey                                 = QLocale__Country(252)
	QLocale__TristanDaCunha                         = QLocale__Country(253)
	QLocale__SouthSudan                             = QLocale__Country(254)
	QLocale__Bonaire                                = QLocale__Country(255)
	QLocale__SintMaarten                            = QLocale__Country(256)
	QLocale__Kosovo                                 = QLocale__Country(257)
	QLocale__DemocraticRepublicOfCongo              = QLocale__Country(QLocale__CongoKinshasa)
	QLocale__PeoplesRepublicOfCongo                 = QLocale__Country(QLocale__CongoBrazzaville)
	QLocale__DemocraticRepublicOfKorea              = QLocale__Country(QLocale__NorthKorea)
	QLocale__RepublicOfKorea                        = QLocale__Country(QLocale__SouthKorea)
	QLocale__RussianFederation                      = QLocale__Country(QLocale__Russia)
	QLocale__SyrianArabRepublic                     = QLocale__Country(QLocale__Syria)
	QLocale__LastCountry                            = QLocale__Country(QLocale__Kosovo)
)

//QLocale::CurrencySymbolFormat
type QLocale__CurrencySymbolFormat int64

const (
	QLocale__CurrencyIsoCode     = QLocale__CurrencySymbolFormat(0)
	QLocale__CurrencySymbol      = QLocale__CurrencySymbolFormat(1)
	QLocale__CurrencyDisplayName = QLocale__CurrencySymbolFormat(2)
)

//QLocale::FormatType
type QLocale__FormatType int64

const (
	QLocale__LongFormat   = QLocale__FormatType(0)
	QLocale__ShortFormat  = QLocale__FormatType(1)
	QLocale__NarrowFormat = QLocale__FormatType(2)
)

//QLocale::Language
type QLocale__Language int64

const (
	QLocale__AnyLanguage               = QLocale__Language(0)
	QLocale__C                         = QLocale__Language(1)
	QLocale__Abkhazian                 = QLocale__Language(2)
	QLocale__Oromo                     = QLocale__Language(3)
	QLocale__Afar                      = QLocale__Language(4)
	QLocale__Afrikaans                 = QLocale__Language(5)
	QLocale__Albanian                  = QLocale__Language(6)
	QLocale__Amharic                   = QLocale__Language(7)
	QLocale__Arabic                    = QLocale__Language(8)
	QLocale__Armenian                  = QLocale__Language(9)
	QLocale__Assamese                  = QLocale__Language(10)
	QLocale__Aymara                    = QLocale__Language(11)
	QLocale__Azerbaijani               = QLocale__Language(12)
	QLocale__Bashkir                   = QLocale__Language(13)
	QLocale__Basque                    = QLocale__Language(14)
	QLocale__Bengali                   = QLocale__Language(15)
	QLocale__Dzongkha                  = QLocale__Language(16)
	QLocale__Bihari                    = QLocale__Language(17)
	QLocale__Bislama                   = QLocale__Language(18)
	QLocale__Breton                    = QLocale__Language(19)
	QLocale__Bulgarian                 = QLocale__Language(20)
	QLocale__Burmese                   = QLocale__Language(21)
	QLocale__Belarusian                = QLocale__Language(22)
	QLocale__Khmer                     = QLocale__Language(23)
	QLocale__Catalan                   = QLocale__Language(24)
	QLocale__Chinese                   = QLocale__Language(25)
	QLocale__Corsican                  = QLocale__Language(26)
	QLocale__Croatian                  = QLocale__Language(27)
	QLocale__Czech                     = QLocale__Language(28)
	QLocale__Danish                    = QLocale__Language(29)
	QLocale__Dutch                     = QLocale__Language(30)
	QLocale__English                   = QLocale__Language(31)
	QLocale__Esperanto                 = QLocale__Language(32)
	QLocale__Estonian                  = QLocale__Language(33)
	QLocale__Faroese                   = QLocale__Language(34)
	QLocale__Fijian                    = QLocale__Language(35)
	QLocale__Finnish                   = QLocale__Language(36)
	QLocale__French                    = QLocale__Language(37)
	QLocale__WesternFrisian            = QLocale__Language(38)
	QLocale__Gaelic                    = QLocale__Language(39)
	QLocale__Galician                  = QLocale__Language(40)
	QLocale__Georgian                  = QLocale__Language(41)
	QLocale__German                    = QLocale__Language(42)
	QLocale__Greek                     = QLocale__Language(43)
	QLocale__Greenlandic               = QLocale__Language(44)
	QLocale__Guarani                   = QLocale__Language(45)
	QLocale__Gujarati                  = QLocale__Language(46)
	QLocale__Hausa                     = QLocale__Language(47)
	QLocale__Hebrew                    = QLocale__Language(48)
	QLocale__Hindi                     = QLocale__Language(49)
	QLocale__Hungarian                 = QLocale__Language(50)
	QLocale__Icelandic                 = QLocale__Language(51)
	QLocale__Indonesian                = QLocale__Language(52)
	QLocale__Interlingua               = QLocale__Language(53)
	QLocale__Interlingue               = QLocale__Language(54)
	QLocale__Inuktitut                 = QLocale__Language(55)
	QLocale__Inupiak                   = QLocale__Language(56)
	QLocale__Irish                     = QLocale__Language(57)
	QLocale__Italian                   = QLocale__Language(58)
	QLocale__Japanese                  = QLocale__Language(59)
	QLocale__Javanese                  = QLocale__Language(60)
	QLocale__Kannada                   = QLocale__Language(61)
	QLocale__Kashmiri                  = QLocale__Language(62)
	QLocale__Kazakh                    = QLocale__Language(63)
	QLocale__Kinyarwanda               = QLocale__Language(64)
	QLocale__Kirghiz                   = QLocale__Language(65)
	QLocale__Korean                    = QLocale__Language(66)
	QLocale__Kurdish                   = QLocale__Language(67)
	QLocale__Rundi                     = QLocale__Language(68)
	QLocale__Lao                       = QLocale__Language(69)
	QLocale__Latin                     = QLocale__Language(70)
	QLocale__Latvian                   = QLocale__Language(71)
	QLocale__Lingala                   = QLocale__Language(72)
	QLocale__Lithuanian                = QLocale__Language(73)
	QLocale__Macedonian                = QLocale__Language(74)
	QLocale__Malagasy                  = QLocale__Language(75)
	QLocale__Malay                     = QLocale__Language(76)
	QLocale__Malayalam                 = QLocale__Language(77)
	QLocale__Maltese                   = QLocale__Language(78)
	QLocale__Maori                     = QLocale__Language(79)
	QLocale__Marathi                   = QLocale__Language(80)
	QLocale__Marshallese               = QLocale__Language(81)
	QLocale__Mongolian                 = QLocale__Language(82)
	QLocale__NauruLanguage             = QLocale__Language(83)
	QLocale__Nepali                    = QLocale__Language(84)
	QLocale__NorwegianBokmal           = QLocale__Language(85)
	QLocale__Occitan                   = QLocale__Language(86)
	QLocale__Oriya                     = QLocale__Language(87)
	QLocale__Pashto                    = QLocale__Language(88)
	QLocale__Persian                   = QLocale__Language(89)
	QLocale__Polish                    = QLocale__Language(90)
	QLocale__Portuguese                = QLocale__Language(91)
	QLocale__Punjabi                   = QLocale__Language(92)
	QLocale__Quechua                   = QLocale__Language(93)
	QLocale__Romansh                   = QLocale__Language(94)
	QLocale__Romanian                  = QLocale__Language(95)
	QLocale__Russian                   = QLocale__Language(96)
	QLocale__Samoan                    = QLocale__Language(97)
	QLocale__Sango                     = QLocale__Language(98)
	QLocale__Sanskrit                  = QLocale__Language(99)
	QLocale__Serbian                   = QLocale__Language(100)
	QLocale__Ossetic                   = QLocale__Language(101)
	QLocale__SouthernSotho             = QLocale__Language(102)
	QLocale__Tswana                    = QLocale__Language(103)
	QLocale__Shona                     = QLocale__Language(104)
	QLocale__Sindhi                    = QLocale__Language(105)
	QLocale__Sinhala                   = QLocale__Language(106)
	QLocale__Swati                     = QLocale__Language(107)
	QLocale__Slovak                    = QLocale__Language(108)
	QLocale__Slovenian                 = QLocale__Language(109)
	QLocale__Somali                    = QLocale__Language(110)
	QLocale__Spanish                   = QLocale__Language(111)
	QLocale__Sundanese                 = QLocale__Language(112)
	QLocale__Swahili                   = QLocale__Language(113)
	QLocale__Swedish                   = QLocale__Language(114)
	QLocale__Sardinian                 = QLocale__Language(115)
	QLocale__Tajik                     = QLocale__Language(116)
	QLocale__Tamil                     = QLocale__Language(117)
	QLocale__Tatar                     = QLocale__Language(118)
	QLocale__Telugu                    = QLocale__Language(119)
	QLocale__Thai                      = QLocale__Language(120)
	QLocale__Tibetan                   = QLocale__Language(121)
	QLocale__Tigrinya                  = QLocale__Language(122)
	QLocale__Tongan                    = QLocale__Language(123)
	QLocale__Tsonga                    = QLocale__Language(124)
	QLocale__Turkish                   = QLocale__Language(125)
	QLocale__Turkmen                   = QLocale__Language(126)
	QLocale__Tahitian                  = QLocale__Language(127)
	QLocale__Uighur                    = QLocale__Language(128)
	QLocale__Ukrainian                 = QLocale__Language(129)
	QLocale__Urdu                      = QLocale__Language(130)
	QLocale__Uzbek                     = QLocale__Language(131)
	QLocale__Vietnamese                = QLocale__Language(132)
	QLocale__Volapuk                   = QLocale__Language(133)
	QLocale__Welsh                     = QLocale__Language(134)
	QLocale__Wolof                     = QLocale__Language(135)
	QLocale__Xhosa                     = QLocale__Language(136)
	QLocale__Yiddish                   = QLocale__Language(137)
	QLocale__Yoruba                    = QLocale__Language(138)
	QLocale__Zhuang                    = QLocale__Language(139)
	QLocale__Zulu                      = QLocale__Language(140)
	QLocale__NorwegianNynorsk          = QLocale__Language(141)
	QLocale__Bosnian                   = QLocale__Language(142)
	QLocale__Divehi                    = QLocale__Language(143)
	QLocale__Manx                      = QLocale__Language(144)
	QLocale__Cornish                   = QLocale__Language(145)
	QLocale__Akan                      = QLocale__Language(146)
	QLocale__Konkani                   = QLocale__Language(147)
	QLocale__Ga                        = QLocale__Language(148)
	QLocale__Igbo                      = QLocale__Language(149)
	QLocale__Kamba                     = QLocale__Language(150)
	QLocale__Syriac                    = QLocale__Language(151)
	QLocale__Blin                      = QLocale__Language(152)
	QLocale__Geez                      = QLocale__Language(153)
	QLocale__Koro                      = QLocale__Language(154)
	QLocale__Sidamo                    = QLocale__Language(155)
	QLocale__Atsam                     = QLocale__Language(156)
	QLocale__Tigre                     = QLocale__Language(157)
	QLocale__Jju                       = QLocale__Language(158)
	QLocale__Friulian                  = QLocale__Language(159)
	QLocale__Venda                     = QLocale__Language(160)
	QLocale__Ewe                       = QLocale__Language(161)
	QLocale__Walamo                    = QLocale__Language(162)
	QLocale__Hawaiian                  = QLocale__Language(163)
	QLocale__Tyap                      = QLocale__Language(164)
	QLocale__Nyanja                    = QLocale__Language(165)
	QLocale__Filipino                  = QLocale__Language(166)
	QLocale__SwissGerman               = QLocale__Language(167)
	QLocale__SichuanYi                 = QLocale__Language(168)
	QLocale__Kpelle                    = QLocale__Language(169)
	QLocale__LowGerman                 = QLocale__Language(170)
	QLocale__SouthNdebele              = QLocale__Language(171)
	QLocale__NorthernSotho             = QLocale__Language(172)
	QLocale__NorthernSami              = QLocale__Language(173)
	QLocale__Taroko                    = QLocale__Language(174)
	QLocale__Gusii                     = QLocale__Language(175)
	QLocale__Taita                     = QLocale__Language(176)
	QLocale__Fulah                     = QLocale__Language(177)
	QLocale__Kikuyu                    = QLocale__Language(178)
	QLocale__Samburu                   = QLocale__Language(179)
	QLocale__Sena                      = QLocale__Language(180)
	QLocale__NorthNdebele              = QLocale__Language(181)
	QLocale__Rombo                     = QLocale__Language(182)
	QLocale__Tachelhit                 = QLocale__Language(183)
	QLocale__Kabyle                    = QLocale__Language(184)
	QLocale__Nyankole                  = QLocale__Language(185)
	QLocale__Bena                      = QLocale__Language(186)
	QLocale__Vunjo                     = QLocale__Language(187)
	QLocale__Bambara                   = QLocale__Language(188)
	QLocale__Embu                      = QLocale__Language(189)
	QLocale__Cherokee                  = QLocale__Language(190)
	QLocale__Morisyen                  = QLocale__Language(191)
	QLocale__Makonde                   = QLocale__Language(192)
	QLocale__Langi                     = QLocale__Language(193)
	QLocale__Ganda                     = QLocale__Language(194)
	QLocale__Bemba                     = QLocale__Language(195)
	QLocale__Kabuverdianu              = QLocale__Language(196)
	QLocale__Meru                      = QLocale__Language(197)
	QLocale__Kalenjin                  = QLocale__Language(198)
	QLocale__Nama                      = QLocale__Language(199)
	QLocale__Machame                   = QLocale__Language(200)
	QLocale__Colognian                 = QLocale__Language(201)
	QLocale__Masai                     = QLocale__Language(202)
	QLocale__Soga                      = QLocale__Language(203)
	QLocale__Luyia                     = QLocale__Language(204)
	QLocale__Asu                       = QLocale__Language(205)
	QLocale__Teso                      = QLocale__Language(206)
	QLocale__Saho                      = QLocale__Language(207)
	QLocale__KoyraChiini               = QLocale__Language(208)
	QLocale__Rwa                       = QLocale__Language(209)
	QLocale__Luo                       = QLocale__Language(210)
	QLocale__Chiga                     = QLocale__Language(211)
	QLocale__CentralMoroccoTamazight   = QLocale__Language(212)
	QLocale__KoyraboroSenni            = QLocale__Language(213)
	QLocale__Shambala                  = QLocale__Language(214)
	QLocale__Bodo                      = QLocale__Language(215)
	QLocale__Avaric                    = QLocale__Language(216)
	QLocale__Chamorro                  = QLocale__Language(217)
	QLocale__Chechen                   = QLocale__Language(218)
	QLocale__Church                    = QLocale__Language(219)
	QLocale__Chuvash                   = QLocale__Language(220)
	QLocale__Cree                      = QLocale__Language(221)
	QLocale__Haitian                   = QLocale__Language(222)
	QLocale__Herero                    = QLocale__Language(223)
	QLocale__HiriMotu                  = QLocale__Language(224)
	QLocale__Kanuri                    = QLocale__Language(225)
	QLocale__Komi                      = QLocale__Language(226)
	QLocale__Kongo                     = QLocale__Language(227)
	QLocale__Kwanyama                  = QLocale__Language(228)
	QLocale__Limburgish                = QLocale__Language(229)
	QLocale__LubaKatanga               = QLocale__Language(230)
	QLocale__Luxembourgish             = QLocale__Language(231)
	QLocale__Navaho                    = QLocale__Language(232)
	QLocale__Ndonga                    = QLocale__Language(233)
	QLocale__Ojibwa                    = QLocale__Language(234)
	QLocale__Pali                      = QLocale__Language(235)
	QLocale__Walloon                   = QLocale__Language(236)
	QLocale__Aghem                     = QLocale__Language(237)
	QLocale__Basaa                     = QLocale__Language(238)
	QLocale__Zarma                     = QLocale__Language(239)
	QLocale__Duala                     = QLocale__Language(240)
	QLocale__JolaFonyi                 = QLocale__Language(241)
	QLocale__Ewondo                    = QLocale__Language(242)
	QLocale__Bafia                     = QLocale__Language(243)
	QLocale__MakhuwaMeetto             = QLocale__Language(244)
	QLocale__Mundang                   = QLocale__Language(245)
	QLocale__Kwasio                    = QLocale__Language(246)
	QLocale__Nuer                      = QLocale__Language(247)
	QLocale__Sakha                     = QLocale__Language(248)
	QLocale__Sangu                     = QLocale__Language(249)
	QLocale__CongoSwahili              = QLocale__Language(250)
	QLocale__Tasawaq                   = QLocale__Language(251)
	QLocale__Vai                       = QLocale__Language(252)
	QLocale__Walser                    = QLocale__Language(253)
	QLocale__Yangben                   = QLocale__Language(254)
	QLocale__Avestan                   = QLocale__Language(255)
	QLocale__Asturian                  = QLocale__Language(256)
	QLocale__Ngomba                    = QLocale__Language(257)
	QLocale__Kako                      = QLocale__Language(258)
	QLocale__Meta                      = QLocale__Language(259)
	QLocale__Ngiemboon                 = QLocale__Language(260)
	QLocale__Aragonese                 = QLocale__Language(261)
	QLocale__Akkadian                  = QLocale__Language(262)
	QLocale__AncientEgyptian           = QLocale__Language(263)
	QLocale__AncientGreek              = QLocale__Language(264)
	QLocale__Aramaic                   = QLocale__Language(265)
	QLocale__Balinese                  = QLocale__Language(266)
	QLocale__Bamun                     = QLocale__Language(267)
	QLocale__BatakToba                 = QLocale__Language(268)
	QLocale__Buginese                  = QLocale__Language(269)
	QLocale__Buhid                     = QLocale__Language(270)
	QLocale__Carian                    = QLocale__Language(271)
	QLocale__Chakma                    = QLocale__Language(272)
	QLocale__ClassicalMandaic          = QLocale__Language(273)
	QLocale__Coptic                    = QLocale__Language(274)
	QLocale__Dogri                     = QLocale__Language(275)
	QLocale__EasternCham               = QLocale__Language(276)
	QLocale__EasternKayah              = QLocale__Language(277)
	QLocale__Etruscan                  = QLocale__Language(278)
	QLocale__Gothic                    = QLocale__Language(279)
	QLocale__Hanunoo                   = QLocale__Language(280)
	QLocale__Ingush                    = QLocale__Language(281)
	QLocale__LargeFloweryMiao          = QLocale__Language(282)
	QLocale__Lepcha                    = QLocale__Language(283)
	QLocale__Limbu                     = QLocale__Language(284)
	QLocale__Lisu                      = QLocale__Language(285)
	QLocale__Lu                        = QLocale__Language(286)
	QLocale__Lycian                    = QLocale__Language(287)
	QLocale__Lydian                    = QLocale__Language(288)
	QLocale__Mandingo                  = QLocale__Language(289)
	QLocale__Manipuri                  = QLocale__Language(290)
	QLocale__Meroitic                  = QLocale__Language(291)
	QLocale__NorthernThai              = QLocale__Language(292)
	QLocale__OldIrish                  = QLocale__Language(293)
	QLocale__OldNorse                  = QLocale__Language(294)
	QLocale__OldPersian                = QLocale__Language(295)
	QLocale__OldTurkish                = QLocale__Language(296)
	QLocale__Pahlavi                   = QLocale__Language(297)
	QLocale__Parthian                  = QLocale__Language(298)
	QLocale__Phoenician                = QLocale__Language(299)
	QLocale__PrakritLanguage           = QLocale__Language(300)
	QLocale__Rejang                    = QLocale__Language(301)
	QLocale__Sabaean                   = QLocale__Language(302)
	QLocale__Samaritan                 = QLocale__Language(303)
	QLocale__Santali                   = QLocale__Language(304)
	QLocale__Saurashtra                = QLocale__Language(305)
	QLocale__Sora                      = QLocale__Language(306)
	QLocale__Sylheti                   = QLocale__Language(307)
	QLocale__Tagbanwa                  = QLocale__Language(308)
	QLocale__TaiDam                    = QLocale__Language(309)
	QLocale__TaiNua                    = QLocale__Language(310)
	QLocale__Ugaritic                  = QLocale__Language(311)
	QLocale__Akoose                    = QLocale__Language(312)
	QLocale__Lakota                    = QLocale__Language(313)
	QLocale__StandardMoroccanTamazight = QLocale__Language(314)
	QLocale__Mapuche                   = QLocale__Language(315)
	QLocale__CentralKurdish            = QLocale__Language(316)
	QLocale__LowerSorbian              = QLocale__Language(317)
	QLocale__UpperSorbian              = QLocale__Language(318)
	QLocale__Kenyang                   = QLocale__Language(319)
	QLocale__Mohawk                    = QLocale__Language(320)
	QLocale__Nko                       = QLocale__Language(321)
	QLocale__Prussian                  = QLocale__Language(322)
	QLocale__Kiche                     = QLocale__Language(323)
	QLocale__SouthernSami              = QLocale__Language(324)
	QLocale__LuleSami                  = QLocale__Language(325)
	QLocale__InariSami                 = QLocale__Language(326)
	QLocale__SkoltSami                 = QLocale__Language(327)
	QLocale__Warlpiri                  = QLocale__Language(328)
	QLocale__ManichaeanMiddlePersian   = QLocale__Language(329)
	QLocale__Mende                     = QLocale__Language(330)
	QLocale__AncientNorthArabian       = QLocale__Language(331)
	QLocale__LinearA                   = QLocale__Language(332)
	QLocale__HmongNjua                 = QLocale__Language(333)
	QLocale__Ho                        = QLocale__Language(334)
	QLocale__Lezghian                  = QLocale__Language(335)
	QLocale__Bassa                     = QLocale__Language(336)
	QLocale__Mono                      = QLocale__Language(337)
	QLocale__TedimChin                 = QLocale__Language(338)
	QLocale__Maithili                  = QLocale__Language(339)
	QLocale__Norwegian                 = QLocale__Language(QLocale__NorwegianBokmal)
	QLocale__Moldavian                 = QLocale__Language(QLocale__Romanian)
	QLocale__SerboCroatian             = QLocale__Language(QLocale__Serbian)
	QLocale__Tagalog                   = QLocale__Language(QLocale__Filipino)
	QLocale__Twi                       = QLocale__Language(QLocale__Akan)
	QLocale__Afan                      = QLocale__Language(QLocale__Oromo)
	QLocale__Byelorussian              = QLocale__Language(QLocale__Belarusian)
	QLocale__Bhutani                   = QLocale__Language(QLocale__Dzongkha)
	QLocale__Cambodian                 = QLocale__Language(QLocale__Khmer)
	QLocale__Kurundi                   = QLocale__Language(QLocale__Rundi)
	QLocale__RhaetoRomance             = QLocale__Language(QLocale__Romansh)
	QLocale__Chewa                     = QLocale__Language(QLocale__Nyanja)
	QLocale__Frisian                   = QLocale__Language(QLocale__WesternFrisian)
	QLocale__Uigur                     = QLocale__Language(QLocale__Uighur)
	QLocale__LastLanguage              = QLocale__Language(QLocale__Maithili)
)

//QLocale::MeasurementSystem
type QLocale__MeasurementSystem int64

const (
	QLocale__MetricSystem     = QLocale__MeasurementSystem(0)
	QLocale__ImperialUSSystem = QLocale__MeasurementSystem(1)
	QLocale__ImperialUKSystem = QLocale__MeasurementSystem(2)
	QLocale__ImperialSystem   = QLocale__MeasurementSystem(QLocale__ImperialUSSystem)
)

//QLocale::NumberOption
type QLocale__NumberOption int64

const (
	QLocale__OmitGroupSeparator   = QLocale__NumberOption(0x01)
	QLocale__RejectGroupSeparator = QLocale__NumberOption(0x02)
)

//QLocale::QuotationStyle
type QLocale__QuotationStyle int64

var (
	QLocale__StandardQuotation  = QLocale__QuotationStyle(0)
	QLocale__AlternateQuotation = QLocale__QuotationStyle(1)
)

//QLocale::Script
type QLocale__Script int64

const (
	QLocale__AnyScript                   = QLocale__Script(0)
	QLocale__ArabicScript                = QLocale__Script(1)
	QLocale__CyrillicScript              = QLocale__Script(2)
	QLocale__DeseretScript               = QLocale__Script(3)
	QLocale__GurmukhiScript              = QLocale__Script(4)
	QLocale__SimplifiedHanScript         = QLocale__Script(5)
	QLocale__TraditionalHanScript        = QLocale__Script(6)
	QLocale__LatinScript                 = QLocale__Script(7)
	QLocale__MongolianScript             = QLocale__Script(8)
	QLocale__TifinaghScript              = QLocale__Script(9)
	QLocale__ArmenianScript              = QLocale__Script(10)
	QLocale__BengaliScript               = QLocale__Script(11)
	QLocale__CherokeeScript              = QLocale__Script(12)
	QLocale__DevanagariScript            = QLocale__Script(13)
	QLocale__EthiopicScript              = QLocale__Script(14)
	QLocale__GeorgianScript              = QLocale__Script(15)
	QLocale__GreekScript                 = QLocale__Script(16)
	QLocale__GujaratiScript              = QLocale__Script(17)
	QLocale__HebrewScript                = QLocale__Script(18)
	QLocale__JapaneseScript              = QLocale__Script(19)
	QLocale__KhmerScript                 = QLocale__Script(20)
	QLocale__KannadaScript               = QLocale__Script(21)
	QLocale__KoreanScript                = QLocale__Script(22)
	QLocale__LaoScript                   = QLocale__Script(23)
	QLocale__MalayalamScript             = QLocale__Script(24)
	QLocale__MyanmarScript               = QLocale__Script(25)
	QLocale__OriyaScript                 = QLocale__Script(26)
	QLocale__TamilScript                 = QLocale__Script(27)
	QLocale__TeluguScript                = QLocale__Script(28)
	QLocale__ThaanaScript                = QLocale__Script(29)
	QLocale__ThaiScript                  = QLocale__Script(30)
	QLocale__TibetanScript               = QLocale__Script(31)
	QLocale__SinhalaScript               = QLocale__Script(32)
	QLocale__SyriacScript                = QLocale__Script(33)
	QLocale__YiScript                    = QLocale__Script(34)
	QLocale__VaiScript                   = QLocale__Script(35)
	QLocale__AvestanScript               = QLocale__Script(36)
	QLocale__BalineseScript              = QLocale__Script(37)
	QLocale__BamumScript                 = QLocale__Script(38)
	QLocale__BatakScript                 = QLocale__Script(39)
	QLocale__BopomofoScript              = QLocale__Script(40)
	QLocale__BrahmiScript                = QLocale__Script(41)
	QLocale__BugineseScript              = QLocale__Script(42)
	QLocale__BuhidScript                 = QLocale__Script(43)
	QLocale__CanadianAboriginalScript    = QLocale__Script(44)
	QLocale__CarianScript                = QLocale__Script(45)
	QLocale__ChakmaScript                = QLocale__Script(46)
	QLocale__ChamScript                  = QLocale__Script(47)
	QLocale__CopticScript                = QLocale__Script(48)
	QLocale__CypriotScript               = QLocale__Script(49)
	QLocale__EgyptianHieroglyphsScript   = QLocale__Script(50)
	QLocale__FraserScript                = QLocale__Script(51)
	QLocale__GlagoliticScript            = QLocale__Script(52)
	QLocale__GothicScript                = QLocale__Script(53)
	QLocale__HanScript                   = QLocale__Script(54)
	QLocale__HangulScript                = QLocale__Script(55)
	QLocale__HanunooScript               = QLocale__Script(56)
	QLocale__ImperialAramaicScript       = QLocale__Script(57)
	QLocale__InscriptionalPahlaviScript  = QLocale__Script(58)
	QLocale__InscriptionalParthianScript = QLocale__Script(59)
	QLocale__JavaneseScript              = QLocale__Script(60)
	QLocale__KaithiScript                = QLocale__Script(61)
	QLocale__KatakanaScript              = QLocale__Script(62)
	QLocale__KayahLiScript               = QLocale__Script(63)
	QLocale__KharoshthiScript            = QLocale__Script(64)
	QLocale__LannaScript                 = QLocale__Script(65)
	QLocale__LepchaScript                = QLocale__Script(66)
	QLocale__LimbuScript                 = QLocale__Script(67)
	QLocale__LinearBScript               = QLocale__Script(68)
	QLocale__LycianScript                = QLocale__Script(69)
	QLocale__LydianScript                = QLocale__Script(70)
	QLocale__MandaeanScript              = QLocale__Script(71)
	QLocale__MeiteiMayekScript           = QLocale__Script(72)
	QLocale__MeroiticScript              = QLocale__Script(73)
	QLocale__MeroiticCursiveScript       = QLocale__Script(74)
	QLocale__NkoScript                   = QLocale__Script(75)
	QLocale__NewTaiLueScript             = QLocale__Script(76)
	QLocale__OghamScript                 = QLocale__Script(77)
	QLocale__OlChikiScript               = QLocale__Script(78)
	QLocale__OldItalicScript             = QLocale__Script(79)
	QLocale__OldPersianScript            = QLocale__Script(80)
	QLocale__OldSouthArabianScript       = QLocale__Script(81)
	QLocale__OrkhonScript                = QLocale__Script(82)
	QLocale__OsmanyaScript               = QLocale__Script(83)
	QLocale__PhagsPaScript               = QLocale__Script(84)
	QLocale__PhoenicianScript            = QLocale__Script(85)
	QLocale__PollardPhoneticScript       = QLocale__Script(86)
	QLocale__RejangScript                = QLocale__Script(87)
	QLocale__RunicScript                 = QLocale__Script(88)
	QLocale__SamaritanScript             = QLocale__Script(89)
	QLocale__SaurashtraScript            = QLocale__Script(90)
	QLocale__SharadaScript               = QLocale__Script(91)
	QLocale__ShavianScript               = QLocale__Script(92)
	QLocale__SoraSompengScript           = QLocale__Script(93)
	QLocale__CuneiformScript             = QLocale__Script(94)
	QLocale__SundaneseScript             = QLocale__Script(95)
	QLocale__SylotiNagriScript           = QLocale__Script(96)
	QLocale__TagalogScript               = QLocale__Script(97)
	QLocale__TagbanwaScript              = QLocale__Script(98)
	QLocale__TaiLeScript                 = QLocale__Script(99)
	QLocale__TaiVietScript               = QLocale__Script(100)
	QLocale__TakriScript                 = QLocale__Script(101)
	QLocale__UgariticScript              = QLocale__Script(102)
	QLocale__BrailleScript               = QLocale__Script(103)
	QLocale__HiraganaScript              = QLocale__Script(104)
	QLocale__CaucasianAlbanianScript     = QLocale__Script(105)
	QLocale__BassaVahScript              = QLocale__Script(106)
	QLocale__DuployanScript              = QLocale__Script(107)
	QLocale__ElbasanScript               = QLocale__Script(108)
	QLocale__GranthaScript               = QLocale__Script(109)
	QLocale__PahawhHmongScript           = QLocale__Script(110)
	QLocale__KhojkiScript                = QLocale__Script(111)
	QLocale__LinearAScript               = QLocale__Script(112)
	QLocale__MahajaniScript              = QLocale__Script(113)
	QLocale__ManichaeanScript            = QLocale__Script(114)
	QLocale__MendeKikakuiScript          = QLocale__Script(115)
	QLocale__ModiScript                  = QLocale__Script(116)
	QLocale__MroScript                   = QLocale__Script(117)
	QLocale__OldNorthArabianScript       = QLocale__Script(118)
	QLocale__NabataeanScript             = QLocale__Script(119)
	QLocale__PalmyreneScript             = QLocale__Script(120)
	QLocale__PauCinHauScript             = QLocale__Script(121)
	QLocale__OldPermicScript             = QLocale__Script(122)
	QLocale__PsalterPahlaviScript        = QLocale__Script(123)
	QLocale__SiddhamScript               = QLocale__Script(124)
	QLocale__KhudawadiScript             = QLocale__Script(125)
	QLocale__TirhutaScript               = QLocale__Script(126)
	QLocale__VarangKshitiScript          = QLocale__Script(127)
	QLocale__SimplifiedChineseScript     = QLocale__Script(QLocale__SimplifiedHanScript)
	QLocale__TraditionalChineseScript    = QLocale__Script(QLocale__TraditionalHanScript)
	QLocale__LastScript                  = QLocale__Script(QLocale__VarangKshitiScript)
)

func NewQLocale() *QLocale {
	defer qt.Recovering("QLocale::QLocale")

	return newQLocaleFromPointer(C.QLocale_NewQLocale())
}

func NewQLocale3(language QLocale__Language, country QLocale__Country) *QLocale {
	defer qt.Recovering("QLocale::QLocale")

	return newQLocaleFromPointer(C.QLocale_NewQLocale3(C.int(language), C.int(country)))
}

func NewQLocale4(language QLocale__Language, script QLocale__Script, country QLocale__Country) *QLocale {
	defer qt.Recovering("QLocale::QLocale")

	return newQLocaleFromPointer(C.QLocale_NewQLocale4(C.int(language), C.int(script), C.int(country)))
}

func NewQLocale5(other QLocale_ITF) *QLocale {
	defer qt.Recovering("QLocale::QLocale")

	return newQLocaleFromPointer(C.QLocale_NewQLocale5(PointerFromQLocale(other)))
}

func NewQLocale2(name string) *QLocale {
	defer qt.Recovering("QLocale::QLocale")

	return newQLocaleFromPointer(C.QLocale_NewQLocale2(C.CString(name)))
}

func (ptr *QLocale) AmText() string {
	defer qt.Recovering("QLocale::amText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_AmText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) Bcp47Name() string {
	defer qt.Recovering("QLocale::bcp47Name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_Bcp47Name(ptr.Pointer()))
	}
	return ""
}

func QLocale_C() *QLocale {
	defer qt.Recovering("QLocale::c")

	return NewQLocaleFromPointer(C.QLocale_QLocale_C())
}

func (ptr *QLocale) Country() QLocale__Country {
	defer qt.Recovering("QLocale::country")

	if ptr.Pointer() != nil {
		return QLocale__Country(C.QLocale_Country(ptr.Pointer()))
	}
	return 0
}

func QLocale_CountryToString(country QLocale__Country) string {
	defer qt.Recovering("QLocale::countryToString")

	return C.GoString(C.QLocale_QLocale_CountryToString(C.int(country)))
}

func (ptr *QLocale) CreateSeparatedList(list []string) string {
	defer qt.Recovering("QLocale::createSeparatedList")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_CreateSeparatedList(ptr.Pointer(), C.CString(strings.Join(list, "|"))))
	}
	return ""
}

func (ptr *QLocale) CurrencySymbol(format QLocale__CurrencySymbolFormat) string {
	defer qt.Recovering("QLocale::currencySymbol")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_CurrencySymbol(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func (ptr *QLocale) DateFormat(format QLocale__FormatType) string {
	defer qt.Recovering("QLocale::dateFormat")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_DateFormat(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func (ptr *QLocale) DateTimeFormat(format QLocale__FormatType) string {
	defer qt.Recovering("QLocale::dateTimeFormat")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_DateTimeFormat(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func (ptr *QLocale) DayName(day int, ty QLocale__FormatType) string {
	defer qt.Recovering("QLocale::dayName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_DayName(ptr.Pointer(), C.int(day), C.int(ty)))
	}
	return ""
}

func (ptr *QLocale) FirstDayOfWeek() Qt__DayOfWeek {
	defer qt.Recovering("QLocale::firstDayOfWeek")

	if ptr.Pointer() != nil {
		return Qt__DayOfWeek(C.QLocale_FirstDayOfWeek(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLocale) Language() QLocale__Language {
	defer qt.Recovering("QLocale::language")

	if ptr.Pointer() != nil {
		return QLocale__Language(C.QLocale_Language(ptr.Pointer()))
	}
	return 0
}

func QLocale_LanguageToString(language QLocale__Language) string {
	defer qt.Recovering("QLocale::languageToString")

	return C.GoString(C.QLocale_QLocale_LanguageToString(C.int(language)))
}

func (ptr *QLocale) MeasurementSystem() QLocale__MeasurementSystem {
	defer qt.Recovering("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 {
	defer qt.Recovering("QLocale::monthName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_MonthName(ptr.Pointer(), C.int(month), C.int(ty)))
	}
	return ""
}

func (ptr *QLocale) Name() string {
	defer qt.Recovering("QLocale::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) NativeCountryName() string {
	defer qt.Recovering("QLocale::nativeCountryName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_NativeCountryName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) NativeLanguageName() string {
	defer qt.Recovering("QLocale::nativeLanguageName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_NativeLanguageName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) NumberOptions() QLocale__NumberOption {
	defer qt.Recovering("QLocale::numberOptions")

	if ptr.Pointer() != nil {
		return QLocale__NumberOption(C.QLocale_NumberOptions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLocale) PmText() string {
	defer qt.Recovering("QLocale::pmText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_PmText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLocale) QuoteString(str string, style QLocale__QuotationStyle) string {
	defer qt.Recovering("QLocale::quoteString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_QuoteString(ptr.Pointer(), C.CString(str), C.int(style)))
	}
	return ""
}

func (ptr *QLocale) QuoteString2(str QStringRef_ITF, style QLocale__QuotationStyle) string {
	defer qt.Recovering("QLocale::quoteString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_QuoteString2(ptr.Pointer(), PointerFromQStringRef(str), C.int(style)))
	}
	return ""
}

func (ptr *QLocale) Script() QLocale__Script {
	defer qt.Recovering("QLocale::script")

	if ptr.Pointer() != nil {
		return QLocale__Script(C.QLocale_Script(ptr.Pointer()))
	}
	return 0
}

func QLocale_ScriptToString(script QLocale__Script) string {
	defer qt.Recovering("QLocale::scriptToString")

	return C.GoString(C.QLocale_QLocale_ScriptToString(C.int(script)))
}

func QLocale_SetDefault(locale QLocale_ITF) {
	defer qt.Recovering("QLocale::setDefault")

	C.QLocale_QLocale_SetDefault(PointerFromQLocale(locale))
}

func (ptr *QLocale) SetNumberOptions(options QLocale__NumberOption) {
	defer qt.Recovering("QLocale::setNumberOptions")

	if ptr.Pointer() != nil {
		C.QLocale_SetNumberOptions(ptr.Pointer(), C.int(options))
	}
}

func (ptr *QLocale) StandaloneDayName(day int, ty QLocale__FormatType) string {
	defer qt.Recovering("QLocale::standaloneDayName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_StandaloneDayName(ptr.Pointer(), C.int(day), C.int(ty)))
	}
	return ""
}

func (ptr *QLocale) StandaloneMonthName(month int, ty QLocale__FormatType) string {
	defer qt.Recovering("QLocale::standaloneMonthName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_StandaloneMonthName(ptr.Pointer(), C.int(month), C.int(ty)))
	}
	return ""
}

func QLocale_System() *QLocale {
	defer qt.Recovering("QLocale::system")

	return NewQLocaleFromPointer(C.QLocale_QLocale_System())
}

func (ptr *QLocale) TextDirection() Qt__LayoutDirection {
	defer qt.Recovering("QLocale::textDirection")

	if ptr.Pointer() != nil {
		return Qt__LayoutDirection(C.QLocale_TextDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLocale) TimeFormat(format QLocale__FormatType) string {
	defer qt.Recovering("QLocale::timeFormat")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_TimeFormat(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func (ptr *QLocale) ToCurrencyString6(value int, symbol string) string {
	defer qt.Recovering("QLocale::toCurrencyString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToCurrencyString6(ptr.Pointer(), C.int(value), C.CString(symbol)))
	}
	return ""
}

func (ptr *QLocale) ToDateTime(stri string, format QLocale__FormatType) *QDateTime {
	defer qt.Recovering("QLocale::toDateTime")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QLocale_ToDateTime(ptr.Pointer(), C.CString(stri), C.int(format)))
	}
	return nil
}

func (ptr *QLocale) ToDateTime2(stri string, format string) *QDateTime {
	defer qt.Recovering("QLocale::toDateTime")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QLocale_ToDateTime2(ptr.Pointer(), C.CString(stri), C.CString(format)))
	}
	return nil
}

func (ptr *QLocale) ToInt(s string, ok bool) int {
	defer qt.Recovering("QLocale::toInt")

	if ptr.Pointer() != nil {
		return int(C.QLocale_ToInt(ptr.Pointer(), C.CString(s), C.int(qt.GoBoolToInt(ok))))
	}
	return 0
}

func (ptr *QLocale) ToInt2(s QStringRef_ITF, ok bool) int {
	defer qt.Recovering("QLocale::toInt")

	if ptr.Pointer() != nil {
		return int(C.QLocale_ToInt2(ptr.Pointer(), PointerFromQStringRef(s), C.int(qt.GoBoolToInt(ok))))
	}
	return 0
}

func (ptr *QLocale) ToLower(str string) string {
	defer qt.Recovering("QLocale::toLower")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToLower(ptr.Pointer(), C.CString(str)))
	}
	return ""
}

func (ptr *QLocale) ToString3(date QDate_ITF, format QLocale__FormatType) string {
	defer qt.Recovering("QLocale::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToString3(ptr.Pointer(), PointerFromQDate(date), C.int(format)))
	}
	return ""
}

func (ptr *QLocale) ToString2(date QDate_ITF, format string) string {
	defer qt.Recovering("QLocale::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToString2(ptr.Pointer(), PointerFromQDate(date), C.CString(format)))
	}
	return ""
}

func (ptr *QLocale) ToString6(dateTime QDateTime_ITF, format QLocale__FormatType) string {
	defer qt.Recovering("QLocale::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToString6(ptr.Pointer(), PointerFromQDateTime(dateTime), C.int(format)))
	}
	return ""
}

func (ptr *QLocale) ToString7(dateTime QDateTime_ITF, format string) string {
	defer qt.Recovering("QLocale::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToString7(ptr.Pointer(), PointerFromQDateTime(dateTime), C.CString(format)))
	}
	return ""
}

func (ptr *QLocale) ToString5(time QTime_ITF, format QLocale__FormatType) string {
	defer qt.Recovering("QLocale::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToString5(ptr.Pointer(), PointerFromQTime(time), C.int(format)))
	}
	return ""
}

func (ptr *QLocale) ToString4(time QTime_ITF, format string) string {
	defer qt.Recovering("QLocale::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToString4(ptr.Pointer(), PointerFromQTime(time), C.CString(format)))
	}
	return ""
}

func (ptr *QLocale) ToString12(i int) string {
	defer qt.Recovering("QLocale::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToString12(ptr.Pointer(), C.int(i)))
	}
	return ""
}

func (ptr *QLocale) ToUpper(str string) string {
	defer qt.Recovering("QLocale::toUpper")

	if ptr.Pointer() != nil {
		return C.GoString(C.QLocale_ToUpper(ptr.Pointer(), C.CString(str)))
	}
	return ""
}

func (ptr *QLocale) UiLanguages() []string {
	defer qt.Recovering("QLocale::uiLanguages")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QLocale_UiLanguages(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QLocale) DestroyQLocale() {
	defer qt.Recovering("QLocale::~QLocale")

	if ptr.Pointer() != nil {
		C.QLocale_DestroyQLocale(ptr.Pointer())
	}
}

type QLockFile struct {
	ptr unsafe.Pointer
}

type QLockFile_ITF interface {
	QLockFile_PTR() *QLockFile
}

func (p *QLockFile) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLockFile) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLockFile(ptr QLockFile_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLockFile_PTR().Pointer()
	}
	return nil
}

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

func newQLockFileFromPointer(ptr unsafe.Pointer) *QLockFile {
	var n = NewQLockFileFromPointer(ptr)
	return n
}

func (ptr *QLockFile) QLockFile_PTR() *QLockFile {
	return ptr
}

//QLockFile::LockError
type QLockFile__LockError int64

const (
	QLockFile__NoError         = QLockFile__LockError(0)
	QLockFile__LockFailedError = QLockFile__LockError(1)
	QLockFile__PermissionError = QLockFile__LockError(2)
	QLockFile__UnknownError    = QLockFile__LockError(3)
)

func NewQLockFile(fileName string) *QLockFile {
	defer qt.Recovering("QLockFile::QLockFile")

	return newQLockFileFromPointer(C.QLockFile_NewQLockFile(C.CString(fileName)))
}

func (ptr *QLockFile) Error() QLockFile__LockError {
	defer qt.Recovering("QLockFile::error")

	if ptr.Pointer() != nil {
		return QLockFile__LockError(C.QLockFile_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLockFile) IsLocked() bool {
	defer qt.Recovering("QLockFile::isLocked")

	if ptr.Pointer() != nil {
		return C.QLockFile_IsLocked(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLockFile) Lock() bool {
	defer qt.Recovering("QLockFile::lock")

	if ptr.Pointer() != nil {
		return C.QLockFile_Lock(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLockFile) RemoveStaleLockFile() bool {
	defer qt.Recovering("QLockFile::removeStaleLockFile")

	if ptr.Pointer() != nil {
		return C.QLockFile_RemoveStaleLockFile(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLockFile) SetStaleLockTime(staleLockTime int) {
	defer qt.Recovering("QLockFile::setStaleLockTime")

	if ptr.Pointer() != nil {
		C.QLockFile_SetStaleLockTime(ptr.Pointer(), C.int(staleLockTime))
	}
}

func (ptr *QLockFile) StaleLockTime() int {
	defer qt.Recovering("QLockFile::staleLockTime")

	if ptr.Pointer() != nil {
		return int(C.QLockFile_StaleLockTime(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLockFile) TryLock(timeout int) bool {
	defer qt.Recovering("QLockFile::tryLock")

	if ptr.Pointer() != nil {
		return C.QLockFile_TryLock(ptr.Pointer(), C.int(timeout)) != 0
	}
	return false
}

func (ptr *QLockFile) DestroyQLockFile() {
	defer qt.Recovering("QLockFile::~QLockFile")

	if ptr.Pointer() != nil {
		C.QLockFile_DestroyQLockFile(ptr.Pointer())
	}
}

func (ptr *QLockFile) Unlock() {
	defer qt.Recovering("QLockFile::unlock")

	if ptr.Pointer() != nil {
		C.QLockFile_Unlock(ptr.Pointer())
	}
}

type QLoggingCategory struct {
	ptr unsafe.Pointer
}

type QLoggingCategory_ITF interface {
	QLoggingCategory_PTR() *QLoggingCategory
}

func (p *QLoggingCategory) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QLoggingCategory) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQLoggingCategory(ptr QLoggingCategory_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLoggingCategory_PTR().Pointer()
	}
	return nil
}

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

func newQLoggingCategoryFromPointer(ptr unsafe.Pointer) *QLoggingCategory {
	var n = NewQLoggingCategoryFromPointer(ptr)
	return n
}

func (ptr *QLoggingCategory) QLoggingCategory_PTR() *QLoggingCategory {
	return ptr
}

func NewQLoggingCategory(category string) *QLoggingCategory {
	defer qt.Recovering("QLoggingCategory::QLoggingCategory")

	return newQLoggingCategoryFromPointer(C.QLoggingCategory_NewQLoggingCategory(C.CString(category)))
}

func QLoggingCategory_DefaultCategory() *QLoggingCategory {
	defer qt.Recovering("QLoggingCategory::defaultCategory")

	return NewQLoggingCategoryFromPointer(C.QLoggingCategory_QLoggingCategory_DefaultCategory())
}

func (ptr *QLoggingCategory) IsCriticalEnabled() bool {
	defer qt.Recovering("QLoggingCategory::isCriticalEnabled")

	if ptr.Pointer() != nil {
		return C.QLoggingCategory_IsCriticalEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLoggingCategory) IsDebugEnabled() bool {
	defer qt.Recovering("QLoggingCategory::isDebugEnabled")

	if ptr.Pointer() != nil {
		return C.QLoggingCategory_IsDebugEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLoggingCategory) IsInfoEnabled() bool {
	defer qt.Recovering("QLoggingCategory::isInfoEnabled")

	if ptr.Pointer() != nil {
		return C.QLoggingCategory_IsInfoEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QLoggingCategory) IsWarningEnabled() bool {
	defer qt.Recovering("QLoggingCategory::isWarningEnabled")

	if ptr.Pointer() != nil {
		return C.QLoggingCategory_IsWarningEnabled(ptr.Pointer()) != 0
	}
	return false
}

func QLoggingCategory_SetFilterRules(rules string) {
	defer qt.Recovering("QLoggingCategory::setFilterRules")

	C.QLoggingCategory_QLoggingCategory_SetFilterRules(C.CString(rules))
}

func (ptr *QLoggingCategory) DestroyQLoggingCategory() {
	defer qt.Recovering("QLoggingCategory::~QLoggingCategory")

	if ptr.Pointer() != nil {
		C.QLoggingCategory_DestroyQLoggingCategory(ptr.Pointer())
	}
}

type QMap struct {
	ptr unsafe.Pointer
}

type QMap_ITF interface {
	QMap_PTR() *QMap
}

func (p *QMap) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMap) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMap(ptr QMap_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMap_PTR().Pointer()
	}
	return nil
}

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

func newQMapFromPointer(ptr unsafe.Pointer) *QMap {
	var n = NewQMapFromPointer(ptr)
	return n
}

func (ptr *QMap) QMap_PTR() *QMap {
	return ptr
}

type QMapIterator struct {
	ptr unsafe.Pointer
}

type QMapIterator_ITF interface {
	QMapIterator_PTR() *QMapIterator
}

func (p *QMapIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMapIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMapIterator(ptr QMapIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMapIterator_PTR().Pointer()
	}
	return nil
}

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

func newQMapIteratorFromPointer(ptr unsafe.Pointer) *QMapIterator {
	var n = NewQMapIteratorFromPointer(ptr)
	return n
}

func (ptr *QMapIterator) QMapIterator_PTR() *QMapIterator {
	return ptr
}

type QMargins struct {
	ptr unsafe.Pointer
}

type QMargins_ITF interface {
	QMargins_PTR() *QMargins
}

func (p *QMargins) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMargins) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMargins(ptr QMargins_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMargins_PTR().Pointer()
	}
	return nil
}

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

func newQMarginsFromPointer(ptr unsafe.Pointer) *QMargins {
	var n = NewQMarginsFromPointer(ptr)
	return n
}

func (ptr *QMargins) QMargins_PTR() *QMargins {
	return ptr
}

func NewQMargins() *QMargins {
	defer qt.Recovering("QMargins::QMargins")

	return newQMarginsFromPointer(C.QMargins_NewQMargins())
}

func NewQMargins2(left int, top int, right int, bottom int) *QMargins {
	defer qt.Recovering("QMargins::QMargins")

	return newQMarginsFromPointer(C.QMargins_NewQMargins2(C.int(left), C.int(top), C.int(right), C.int(bottom)))
}

func (ptr *QMargins) Bottom() int {
	defer qt.Recovering("QMargins::bottom")

	if ptr.Pointer() != nil {
		return int(C.QMargins_Bottom(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMargins) IsNull() bool {
	defer qt.Recovering("QMargins::isNull")

	if ptr.Pointer() != nil {
		return C.QMargins_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMargins) Left() int {
	defer qt.Recovering("QMargins::left")

	if ptr.Pointer() != nil {
		return int(C.QMargins_Left(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMargins) Right() int {
	defer qt.Recovering("QMargins::right")

	if ptr.Pointer() != nil {
		return int(C.QMargins_Right(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMargins) SetBottom(bottom int) {
	defer qt.Recovering("QMargins::setBottom")

	if ptr.Pointer() != nil {
		C.QMargins_SetBottom(ptr.Pointer(), C.int(bottom))
	}
}

func (ptr *QMargins) SetLeft(left int) {
	defer qt.Recovering("QMargins::setLeft")

	if ptr.Pointer() != nil {
		C.QMargins_SetLeft(ptr.Pointer(), C.int(left))
	}
}

func (ptr *QMargins) SetRight(right int) {
	defer qt.Recovering("QMargins::setRight")

	if ptr.Pointer() != nil {
		C.QMargins_SetRight(ptr.Pointer(), C.int(right))
	}
}

func (ptr *QMargins) SetTop(Top int) {
	defer qt.Recovering("QMargins::setTop")

	if ptr.Pointer() != nil {
		C.QMargins_SetTop(ptr.Pointer(), C.int(Top))
	}
}

func (ptr *QMargins) Top() int {
	defer qt.Recovering("QMargins::top")

	if ptr.Pointer() != nil {
		return int(C.QMargins_Top(ptr.Pointer()))
	}
	return 0
}

type QMarginsF struct {
	ptr unsafe.Pointer
}

type QMarginsF_ITF interface {
	QMarginsF_PTR() *QMarginsF
}

func (p *QMarginsF) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMarginsF) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMarginsF(ptr QMarginsF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMarginsF_PTR().Pointer()
	}
	return nil
}

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

func newQMarginsFFromPointer(ptr unsafe.Pointer) *QMarginsF {
	var n = NewQMarginsFFromPointer(ptr)
	return n
}

func (ptr *QMarginsF) QMarginsF_PTR() *QMarginsF {
	return ptr
}

func NewQMarginsF() *QMarginsF {
	defer qt.Recovering("QMarginsF::QMarginsF")

	return newQMarginsFFromPointer(C.QMarginsF_NewQMarginsF())
}

func NewQMarginsF3(margins QMargins_ITF) *QMarginsF {
	defer qt.Recovering("QMarginsF::QMarginsF")

	return newQMarginsFFromPointer(C.QMarginsF_NewQMarginsF3(PointerFromQMargins(margins)))
}

func NewQMarginsF2(left float64, top float64, right float64, bottom float64) *QMarginsF {
	defer qt.Recovering("QMarginsF::QMarginsF")

	return newQMarginsFFromPointer(C.QMarginsF_NewQMarginsF2(C.double(left), C.double(top), C.double(right), C.double(bottom)))
}

func (ptr *QMarginsF) Bottom() float64 {
	defer qt.Recovering("QMarginsF::bottom")

	if ptr.Pointer() != nil {
		return float64(C.QMarginsF_Bottom(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMarginsF) IsNull() bool {
	defer qt.Recovering("QMarginsF::isNull")

	if ptr.Pointer() != nil {
		return C.QMarginsF_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMarginsF) Left() float64 {
	defer qt.Recovering("QMarginsF::left")

	if ptr.Pointer() != nil {
		return float64(C.QMarginsF_Left(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMarginsF) Right() float64 {
	defer qt.Recovering("QMarginsF::right")

	if ptr.Pointer() != nil {
		return float64(C.QMarginsF_Right(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMarginsF) SetBottom(bottom float64) {
	defer qt.Recovering("QMarginsF::setBottom")

	if ptr.Pointer() != nil {
		C.QMarginsF_SetBottom(ptr.Pointer(), C.double(bottom))
	}
}

func (ptr *QMarginsF) SetLeft(left float64) {
	defer qt.Recovering("QMarginsF::setLeft")

	if ptr.Pointer() != nil {
		C.QMarginsF_SetLeft(ptr.Pointer(), C.double(left))
	}
}

func (ptr *QMarginsF) SetRight(right float64) {
	defer qt.Recovering("QMarginsF::setRight")

	if ptr.Pointer() != nil {
		C.QMarginsF_SetRight(ptr.Pointer(), C.double(right))
	}
}

func (ptr *QMarginsF) SetTop(Top float64) {
	defer qt.Recovering("QMarginsF::setTop")

	if ptr.Pointer() != nil {
		C.QMarginsF_SetTop(ptr.Pointer(), C.double(Top))
	}
}

func (ptr *QMarginsF) Top() float64 {
	defer qt.Recovering("QMarginsF::top")

	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 (p *QMessageAuthenticationCode) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMessageAuthenticationCode) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMessageAuthenticationCode(ptr QMessageAuthenticationCode_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMessageAuthenticationCode_PTR().Pointer()
	}
	return nil
}

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

func newQMessageAuthenticationCodeFromPointer(ptr unsafe.Pointer) *QMessageAuthenticationCode {
	var n = NewQMessageAuthenticationCodeFromPointer(ptr)
	return n
}

func (ptr *QMessageAuthenticationCode) QMessageAuthenticationCode_PTR() *QMessageAuthenticationCode {
	return ptr
}

func NewQMessageAuthenticationCode(method QCryptographicHash__Algorithm, key string) *QMessageAuthenticationCode {
	defer qt.Recovering("QMessageAuthenticationCode::QMessageAuthenticationCode")

	return newQMessageAuthenticationCodeFromPointer(C.QMessageAuthenticationCode_NewQMessageAuthenticationCode(C.int(method), C.CString(key)))
}

func (ptr *QMessageAuthenticationCode) AddData2(device QIODevice_ITF) bool {
	defer qt.Recovering("QMessageAuthenticationCode::addData")

	if ptr.Pointer() != nil {
		return C.QMessageAuthenticationCode_AddData2(ptr.Pointer(), PointerFromQIODevice(device)) != 0
	}
	return false
}

func (ptr *QMessageAuthenticationCode) AddData3(data string) {
	defer qt.Recovering("QMessageAuthenticationCode::addData")

	if ptr.Pointer() != nil {
		C.QMessageAuthenticationCode_AddData3(ptr.Pointer(), C.CString(data))
	}
}

func (ptr *QMessageAuthenticationCode) AddData(data string, length int) {
	defer qt.Recovering("QMessageAuthenticationCode::addData")

	if ptr.Pointer() != nil {
		C.QMessageAuthenticationCode_AddData(ptr.Pointer(), C.CString(data), C.int(length))
	}
}

func QMessageAuthenticationCode_Hash(message string, key string, method QCryptographicHash__Algorithm) string {
	defer qt.Recovering("QMessageAuthenticationCode::hash")

	return C.GoString(C.QMessageAuthenticationCode_QMessageAuthenticationCode_Hash(C.CString(message), C.CString(key), C.int(method)))
}

func (ptr *QMessageAuthenticationCode) Reset() {
	defer qt.Recovering("QMessageAuthenticationCode::reset")

	if ptr.Pointer() != nil {
		C.QMessageAuthenticationCode_Reset(ptr.Pointer())
	}
}

func (ptr *QMessageAuthenticationCode) Result() string {
	defer qt.Recovering("QMessageAuthenticationCode::result")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMessageAuthenticationCode_Result(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMessageAuthenticationCode) SetKey(key string) {
	defer qt.Recovering("QMessageAuthenticationCode::setKey")

	if ptr.Pointer() != nil {
		C.QMessageAuthenticationCode_SetKey(ptr.Pointer(), C.CString(key))
	}
}

func (ptr *QMessageAuthenticationCode) DestroyQMessageAuthenticationCode() {
	defer qt.Recovering("QMessageAuthenticationCode::~QMessageAuthenticationCode")

	if ptr.Pointer() != nil {
		C.QMessageAuthenticationCode_DestroyQMessageAuthenticationCode(ptr.Pointer())
	}
}

type QMessageLogContext struct {
	ptr unsafe.Pointer
}

type QMessageLogContext_ITF interface {
	QMessageLogContext_PTR() *QMessageLogContext
}

func (p *QMessageLogContext) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMessageLogContext) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMessageLogContext(ptr QMessageLogContext_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMessageLogContext_PTR().Pointer()
	}
	return nil
}

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

func newQMessageLogContextFromPointer(ptr unsafe.Pointer) *QMessageLogContext {
	var n = NewQMessageLogContextFromPointer(ptr)
	return n
}

func (ptr *QMessageLogContext) QMessageLogContext_PTR() *QMessageLogContext {
	return ptr
}

type QMessageLogger struct {
	ptr unsafe.Pointer
}

type QMessageLogger_ITF interface {
	QMessageLogger_PTR() *QMessageLogger
}

func (p *QMessageLogger) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMessageLogger) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMessageLogger(ptr QMessageLogger_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMessageLogger_PTR().Pointer()
	}
	return nil
}

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

func newQMessageLoggerFromPointer(ptr unsafe.Pointer) *QMessageLogger {
	var n = NewQMessageLoggerFromPointer(ptr)
	return n
}

func (ptr *QMessageLogger) QMessageLogger_PTR() *QMessageLogger {
	return ptr
}

func NewQMessageLogger() *QMessageLogger {
	defer qt.Recovering("QMessageLogger::QMessageLogger")

	return newQMessageLoggerFromPointer(C.QMessageLogger_NewQMessageLogger())
}

func NewQMessageLogger2(file string, line int, function string) *QMessageLogger {
	defer qt.Recovering("QMessageLogger::QMessageLogger")

	return newQMessageLoggerFromPointer(C.QMessageLogger_NewQMessageLogger2(C.CString(file), C.int(line), C.CString(function)))
}

func NewQMessageLogger3(file string, line int, function string, category string) *QMessageLogger {
	defer qt.Recovering("QMessageLogger::QMessageLogger")

	return newQMessageLoggerFromPointer(C.QMessageLogger_NewQMessageLogger3(C.CString(file), C.int(line), C.CString(function), C.CString(category)))
}

func (ptr *QMessageLogger) Critical4() *QDebug {
	defer qt.Recovering("QMessageLogger::critical")

	if ptr.Pointer() != nil {
		return NewQDebugFromPointer(C.QMessageLogger_Critical4(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMessageLogger) Critical5(cat QLoggingCategory_ITF) *QDebug {
	defer qt.Recovering("QMessageLogger::critical")

	if ptr.Pointer() != nil {
		return NewQDebugFromPointer(C.QMessageLogger_Critical5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
	}
	return nil
}

func (ptr *QMessageLogger) Debug4() *QDebug {
	defer qt.Recovering("QMessageLogger::debug")

	if ptr.Pointer() != nil {
		return NewQDebugFromPointer(C.QMessageLogger_Debug4(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMessageLogger) Debug5(cat QLoggingCategory_ITF) *QDebug {
	defer qt.Recovering("QMessageLogger::debug")

	if ptr.Pointer() != nil {
		return NewQDebugFromPointer(C.QMessageLogger_Debug5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
	}
	return nil
}

func (ptr *QMessageLogger) Info3() *QDebug {
	defer qt.Recovering("QMessageLogger::info")

	if ptr.Pointer() != nil {
		return NewQDebugFromPointer(C.QMessageLogger_Info3(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMessageLogger) Info4(cat QLoggingCategory_ITF) *QDebug {
	defer qt.Recovering("QMessageLogger::info")

	if ptr.Pointer() != nil {
		return NewQDebugFromPointer(C.QMessageLogger_Info4(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
	}
	return nil
}

func (ptr *QMessageLogger) Warning4() *QDebug {
	defer qt.Recovering("QMessageLogger::warning")

	if ptr.Pointer() != nil {
		return NewQDebugFromPointer(C.QMessageLogger_Warning4(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMessageLogger) Warning5(cat QLoggingCategory_ITF) *QDebug {
	defer qt.Recovering("QMessageLogger::warning")

	if ptr.Pointer() != nil {
		return NewQDebugFromPointer(C.QMessageLogger_Warning5(ptr.Pointer(), PointerFromQLoggingCategory(cat)))
	}
	return nil
}

type QMetaClassInfo struct {
	ptr unsafe.Pointer
}

type QMetaClassInfo_ITF interface {
	QMetaClassInfo_PTR() *QMetaClassInfo
}

func (p *QMetaClassInfo) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMetaClassInfo) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMetaClassInfo(ptr QMetaClassInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaClassInfo_PTR().Pointer()
	}
	return nil
}

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

func newQMetaClassInfoFromPointer(ptr unsafe.Pointer) *QMetaClassInfo {
	var n = NewQMetaClassInfoFromPointer(ptr)
	return n
}

func (ptr *QMetaClassInfo) QMetaClassInfo_PTR() *QMetaClassInfo {
	return ptr
}

type QMetaEnum struct {
	ptr unsafe.Pointer
}

type QMetaEnum_ITF interface {
	QMetaEnum_PTR() *QMetaEnum
}

func (p *QMetaEnum) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMetaEnum) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMetaEnum(ptr QMetaEnum_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaEnum_PTR().Pointer()
	}
	return nil
}

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

func newQMetaEnumFromPointer(ptr unsafe.Pointer) *QMetaEnum {
	var n = NewQMetaEnumFromPointer(ptr)
	return n
}

func (ptr *QMetaEnum) QMetaEnum_PTR() *QMetaEnum {
	return ptr
}

func (ptr *QMetaEnum) IsFlag() bool {
	defer qt.Recovering("QMetaEnum::isFlag")

	if ptr.Pointer() != nil {
		return C.QMetaEnum_IsFlag(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaEnum) IsValid() bool {
	defer qt.Recovering("QMetaEnum::isValid")

	if ptr.Pointer() != nil {
		return C.QMetaEnum_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaEnum) KeyCount() int {
	defer qt.Recovering("QMetaEnum::keyCount")

	if ptr.Pointer() != nil {
		return int(C.QMetaEnum_KeyCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaEnum) KeyToValue(key string, ok bool) int {
	defer qt.Recovering("QMetaEnum::keyToValue")

	if ptr.Pointer() != nil {
		return int(C.QMetaEnum_KeyToValue(ptr.Pointer(), C.CString(key), C.int(qt.GoBoolToInt(ok))))
	}
	return 0
}

func (ptr *QMetaEnum) KeysToValue(keys string, ok bool) int {
	defer qt.Recovering("QMetaEnum::keysToValue")

	if ptr.Pointer() != nil {
		return int(C.QMetaEnum_KeysToValue(ptr.Pointer(), C.CString(keys), C.int(qt.GoBoolToInt(ok))))
	}
	return 0
}

func (ptr *QMetaEnum) Value(index int) int {
	defer qt.Recovering("QMetaEnum::value")

	if ptr.Pointer() != nil {
		return int(C.QMetaEnum_Value(ptr.Pointer(), C.int(index)))
	}
	return 0
}

func (ptr *QMetaEnum) ValueToKeys(value int) string {
	defer qt.Recovering("QMetaEnum::valueToKeys")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMetaEnum_ValueToKeys(ptr.Pointer(), C.int(value)))
	}
	return ""
}

type QMetaMethod struct {
	ptr unsafe.Pointer
}

type QMetaMethod_ITF interface {
	QMetaMethod_PTR() *QMetaMethod
}

func (p *QMetaMethod) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMetaMethod) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMetaMethod(ptr QMetaMethod_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaMethod_PTR().Pointer()
	}
	return nil
}

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

func newQMetaMethodFromPointer(ptr unsafe.Pointer) *QMetaMethod {
	var n = NewQMetaMethodFromPointer(ptr)
	return n
}

func (ptr *QMetaMethod) QMetaMethod_PTR() *QMetaMethod {
	return ptr
}

//QMetaMethod::Access
type QMetaMethod__Access int64

const (
	QMetaMethod__Private   = QMetaMethod__Access(0)
	QMetaMethod__Protected = QMetaMethod__Access(1)
	QMetaMethod__Public    = QMetaMethod__Access(2)
)

//QMetaMethod::MethodType
type QMetaMethod__MethodType int64

const (
	QMetaMethod__Method      = QMetaMethod__MethodType(0)
	QMetaMethod__Signal      = QMetaMethod__MethodType(1)
	QMetaMethod__Slot        = QMetaMethod__MethodType(2)
	QMetaMethod__Constructor = QMetaMethod__MethodType(3)
)

func (ptr *QMetaMethod) Access() QMetaMethod__Access {
	defer qt.Recovering("QMetaMethod::access")

	if ptr.Pointer() != nil {
		return QMetaMethod__Access(C.QMetaMethod_Access(ptr.Pointer()))
	}
	return 0
}

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 {
	defer qt.Recovering("QMetaMethod::invoke")

	if ptr.Pointer() != nil {
		return 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) 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 {
	defer qt.Recovering("QMetaMethod::invoke")

	if ptr.Pointer() != nil {
		return 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 {
	defer qt.Recovering("QMetaMethod::invoke")

	if ptr.Pointer() != nil {
		return C.QMetaMethod_Invoke3(ptr.Pointer(), PointerFromQObject(object), C.int(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) 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 {
	defer qt.Recovering("QMetaMethod::invoke")

	if ptr.Pointer() != nil {
		return C.QMetaMethod_Invoke(ptr.Pointer(), PointerFromQObject(object), C.int(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) 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 {
	defer qt.Recovering("QMetaMethod::invokeOnGadget")

	if ptr.Pointer() != nil {
		return 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) 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 {
	defer qt.Recovering("QMetaMethod::invokeOnGadget")

	if ptr.Pointer() != nil {
		return 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) IsValid() bool {
	defer qt.Recovering("QMetaMethod::isValid")

	if ptr.Pointer() != nil {
		return C.QMetaMethod_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaMethod) MethodIndex() int {
	defer qt.Recovering("QMetaMethod::methodIndex")

	if ptr.Pointer() != nil {
		return int(C.QMetaMethod_MethodIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaMethod) MethodSignature() string {
	defer qt.Recovering("QMetaMethod::methodSignature")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMetaMethod_MethodSignature(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaMethod) MethodType() QMetaMethod__MethodType {
	defer qt.Recovering("QMetaMethod::methodType")

	if ptr.Pointer() != nil {
		return QMetaMethod__MethodType(C.QMetaMethod_MethodType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaMethod) Name() string {
	defer qt.Recovering("QMetaMethod::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMetaMethod_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMetaMethod) ParameterCount() int {
	defer qt.Recovering("QMetaMethod::parameterCount")

	if ptr.Pointer() != nil {
		return int(C.QMetaMethod_ParameterCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaMethod) ParameterType(index int) int {
	defer qt.Recovering("QMetaMethod::parameterType")

	if ptr.Pointer() != nil {
		return int(C.QMetaMethod_ParameterType(ptr.Pointer(), C.int(index)))
	}
	return 0
}

func (ptr *QMetaMethod) ReturnType() int {
	defer qt.Recovering("QMetaMethod::returnType")

	if ptr.Pointer() != nil {
		return int(C.QMetaMethod_ReturnType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaMethod) Revision() int {
	defer qt.Recovering("QMetaMethod::revision")

	if ptr.Pointer() != nil {
		return int(C.QMetaMethod_Revision(ptr.Pointer()))
	}
	return 0
}

type QMetaObject struct {
	ptr unsafe.Pointer
}

type QMetaObject_ITF interface {
	QMetaObject_PTR() *QMetaObject
}

func (p *QMetaObject) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMetaObject) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMetaObject(ptr QMetaObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaObject_PTR().Pointer()
	}
	return nil
}

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

func newQMetaObjectFromPointer(ptr unsafe.Pointer) *QMetaObject {
	var n = NewQMetaObjectFromPointer(ptr)
	return n
}

func (ptr *QMetaObject) QMetaObject_PTR() *QMetaObject {
	return ptr
}

func QMetaObject_ConnectSlotsByName(object QObject_ITF) {
	defer qt.Recovering("QMetaObject::connectSlotsByName")

	C.QMetaObject_QMetaObject_ConnectSlotsByName(PointerFromQObject(object))
}

func QMetaObject_CheckConnectArgs2(signal QMetaMethod_ITF, method QMetaMethod_ITF) bool {
	defer qt.Recovering("QMetaObject::checkConnectArgs")

	return C.QMetaObject_QMetaObject_CheckConnectArgs2(PointerFromQMetaMethod(signal), PointerFromQMetaMethod(method)) != 0
}

func QMetaObject_CheckConnectArgs(signal string, method string) bool {
	defer qt.Recovering("QMetaObject::checkConnectArgs")

	return C.QMetaObject_QMetaObject_CheckConnectArgs(C.CString(signal), C.CString(method)) != 0
}

func (ptr *QMetaObject) ClassInfoCount() int {
	defer qt.Recovering("QMetaObject::classInfoCount")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_ClassInfoCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaObject) ClassInfoOffset() int {
	defer qt.Recovering("QMetaObject::classInfoOffset")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_ClassInfoOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaObject) ConstructorCount() int {
	defer qt.Recovering("QMetaObject::constructorCount")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_ConstructorCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaObject) EnumeratorCount() int {
	defer qt.Recovering("QMetaObject::enumeratorCount")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_EnumeratorCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaObject) EnumeratorOffset() int {
	defer qt.Recovering("QMetaObject::enumeratorOffset")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_EnumeratorOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfClassInfo(name string) int {
	defer qt.Recovering("QMetaObject::indexOfClassInfo")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_IndexOfClassInfo(ptr.Pointer(), C.CString(name)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfConstructor(constructor string) int {
	defer qt.Recovering("QMetaObject::indexOfConstructor")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_IndexOfConstructor(ptr.Pointer(), C.CString(constructor)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfEnumerator(name string) int {
	defer qt.Recovering("QMetaObject::indexOfEnumerator")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_IndexOfEnumerator(ptr.Pointer(), C.CString(name)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfMethod(method string) int {
	defer qt.Recovering("QMetaObject::indexOfMethod")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_IndexOfMethod(ptr.Pointer(), C.CString(method)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfProperty(name string) int {
	defer qt.Recovering("QMetaObject::indexOfProperty")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_IndexOfProperty(ptr.Pointer(), C.CString(name)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfSignal(signal string) int {
	defer qt.Recovering("QMetaObject::indexOfSignal")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_IndexOfSignal(ptr.Pointer(), C.CString(signal)))
	}
	return 0
}

func (ptr *QMetaObject) IndexOfSlot(slot string) int {
	defer qt.Recovering("QMetaObject::indexOfSlot")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_IndexOfSlot(ptr.Pointer(), C.CString(slot)))
	}
	return 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 {
	defer qt.Recovering("QMetaObject::invokeMethod")

	return C.QMetaObject_QMetaObject_InvokeMethod4(PointerFromQObject(obj), C.CString(member), 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 {
	defer qt.Recovering("QMetaObject::invokeMethod")

	return C.QMetaObject_QMetaObject_InvokeMethod2(PointerFromQObject(obj), C.CString(member), 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 {
	defer qt.Recovering("QMetaObject::invokeMethod")

	return C.QMetaObject_QMetaObject_InvokeMethod3(PointerFromQObject(obj), C.CString(member), C.int(ty), PointerFromQGenericArgument(val0), PointerFromQGenericArgument(val1), PointerFromQGenericArgument(val2), PointerFromQGenericArgument(val3), PointerFromQGenericArgument(val4), PointerFromQGenericArgument(val5), PointerFromQGenericArgument(val6), PointerFromQGenericArgument(val7), PointerFromQGenericArgument(val8), PointerFromQGenericArgument(val9)) != 0
}

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 {
	defer qt.Recovering("QMetaObject::invokeMethod")

	return C.QMetaObject_QMetaObject_InvokeMethod(PointerFromQObject(obj), C.CString(member), C.int(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) MethodCount() int {
	defer qt.Recovering("QMetaObject::methodCount")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_MethodCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaObject) MethodOffset() int {
	defer qt.Recovering("QMetaObject::methodOffset")

	if ptr.Pointer() != nil {
		return int(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 {
	defer qt.Recovering("QMetaObject::newInstance")

	if ptr.Pointer() != nil {
		return 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)))
	}
	return nil
}

func QMetaObject_NormalizedSignature(method string) string {
	defer qt.Recovering("QMetaObject::normalizedSignature")

	return C.GoString(C.QMetaObject_QMetaObject_NormalizedSignature(C.CString(method)))
}

func QMetaObject_NormalizedType(ty string) string {
	defer qt.Recovering("QMetaObject::normalizedType")

	return C.GoString(C.QMetaObject_QMetaObject_NormalizedType(C.CString(ty)))
}

func (ptr *QMetaObject) PropertyCount() int {
	defer qt.Recovering("QMetaObject::propertyCount")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_PropertyCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaObject) PropertyOffset() int {
	defer qt.Recovering("QMetaObject::propertyOffset")

	if ptr.Pointer() != nil {
		return int(C.QMetaObject_PropertyOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaObject) SuperClass() *QMetaObject {
	defer qt.Recovering("QMetaObject::superClass")

	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 (p *QMetaProperty) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMetaProperty) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMetaProperty(ptr QMetaProperty_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaProperty_PTR().Pointer()
	}
	return nil
}

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

func newQMetaPropertyFromPointer(ptr unsafe.Pointer) *QMetaProperty {
	var n = NewQMetaPropertyFromPointer(ptr)
	return n
}

func (ptr *QMetaProperty) QMetaProperty_PTR() *QMetaProperty {
	return ptr
}

func (ptr *QMetaProperty) HasNotifySignal() bool {
	defer qt.Recovering("QMetaProperty::hasNotifySignal")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_HasNotifySignal(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsConstant() bool {
	defer qt.Recovering("QMetaProperty::isConstant")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsConstant(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsDesignable(object QObject_ITF) bool {
	defer qt.Recovering("QMetaProperty::isDesignable")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsDesignable(ptr.Pointer(), PointerFromQObject(object)) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsEnumType() bool {
	defer qt.Recovering("QMetaProperty::isEnumType")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsEnumType(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsFinal() bool {
	defer qt.Recovering("QMetaProperty::isFinal")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsFinal(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsFlagType() bool {
	defer qt.Recovering("QMetaProperty::isFlagType")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsFlagType(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsReadable() bool {
	defer qt.Recovering("QMetaProperty::isReadable")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsReadable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsResettable() bool {
	defer qt.Recovering("QMetaProperty::isResettable")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsResettable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsScriptable(object QObject_ITF) bool {
	defer qt.Recovering("QMetaProperty::isScriptable")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsScriptable(ptr.Pointer(), PointerFromQObject(object)) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsStored(object QObject_ITF) bool {
	defer qt.Recovering("QMetaProperty::isStored")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsStored(ptr.Pointer(), PointerFromQObject(object)) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsUser(object QObject_ITF) bool {
	defer qt.Recovering("QMetaProperty::isUser")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsUser(ptr.Pointer(), PointerFromQObject(object)) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsValid() bool {
	defer qt.Recovering("QMetaProperty::isValid")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaProperty) IsWritable() bool {
	defer qt.Recovering("QMetaProperty::isWritable")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_IsWritable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaProperty) NotifySignalIndex() int {
	defer qt.Recovering("QMetaProperty::notifySignalIndex")

	if ptr.Pointer() != nil {
		return int(C.QMetaProperty_NotifySignalIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaProperty) PropertyIndex() int {
	defer qt.Recovering("QMetaProperty::propertyIndex")

	if ptr.Pointer() != nil {
		return int(C.QMetaProperty_PropertyIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaProperty) Read(object QObject_ITF) *QVariant {
	defer qt.Recovering("QMetaProperty::read")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QMetaProperty_Read(ptr.Pointer(), PointerFromQObject(object)))
	}
	return nil
}

func (ptr *QMetaProperty) ReadOnGadget(gadget unsafe.Pointer) *QVariant {
	defer qt.Recovering("QMetaProperty::readOnGadget")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QMetaProperty_ReadOnGadget(ptr.Pointer(), gadget))
	}
	return nil
}

func (ptr *QMetaProperty) Reset(object QObject_ITF) bool {
	defer qt.Recovering("QMetaProperty::reset")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_Reset(ptr.Pointer(), PointerFromQObject(object)) != 0
	}
	return false
}

func (ptr *QMetaProperty) ResetOnGadget(gadget unsafe.Pointer) bool {
	defer qt.Recovering("QMetaProperty::resetOnGadget")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_ResetOnGadget(ptr.Pointer(), gadget) != 0
	}
	return false
}

func (ptr *QMetaProperty) Revision() int {
	defer qt.Recovering("QMetaProperty::revision")

	if ptr.Pointer() != nil {
		return int(C.QMetaProperty_Revision(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaProperty) UserType() int {
	defer qt.Recovering("QMetaProperty::userType")

	if ptr.Pointer() != nil {
		return int(C.QMetaProperty_UserType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMetaProperty) Write(object QObject_ITF, value QVariant_ITF) bool {
	defer qt.Recovering("QMetaProperty::write")

	if ptr.Pointer() != nil {
		return C.QMetaProperty_Write(ptr.Pointer(), PointerFromQObject(object), PointerFromQVariant(value)) != 0
	}
	return false
}

func (ptr *QMetaProperty) WriteOnGadget(gadget unsafe.Pointer, value QVariant_ITF) bool {
	defer qt.Recovering("QMetaProperty::writeOnGadget")

	if ptr.Pointer() != nil {
		return 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 (p *QMetaType) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMetaType) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMetaType(ptr QMetaType_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMetaType_PTR().Pointer()
	}
	return nil
}

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

func newQMetaTypeFromPointer(ptr unsafe.Pointer) *QMetaType {
	var n = NewQMetaTypeFromPointer(ptr)
	return n
}

func (ptr *QMetaType) QMetaType_PTR() *QMetaType {
	return ptr
}

//QMetaType::Type
type QMetaType__Type int64

const (
	QMetaType__UnknownType           = QMetaType__Type(0)
	QMetaType__Bool                  = QMetaType__Type(1)
	QMetaType__Int                   = QMetaType__Type(2)
	QMetaType__UInt                  = QMetaType__Type(3)
	QMetaType__LongLong              = QMetaType__Type(4)
	QMetaType__ULongLong             = QMetaType__Type(5)
	QMetaType__Double                = QMetaType__Type(6)
	QMetaType__Long                  = QMetaType__Type(32)
	QMetaType__Short                 = QMetaType__Type(33)
	QMetaType__Char                  = QMetaType__Type(34)
	QMetaType__ULong                 = QMetaType__Type(35)
	QMetaType__UShort                = QMetaType__Type(36)
	QMetaType__UChar                 = QMetaType__Type(37)
	QMetaType__Float                 = QMetaType__Type(38)
	QMetaType__VoidStar              = QMetaType__Type(31)
	QMetaType__QChar                 = QMetaType__Type(7)
	QMetaType__QString               = QMetaType__Type(10)
	QMetaType__QStringList           = QMetaType__Type(11)
	QMetaType__QByteArray            = QMetaType__Type(12)
	QMetaType__QBitArray             = QMetaType__Type(13)
	QMetaType__QDate                 = QMetaType__Type(14)
	QMetaType__QTime                 = QMetaType__Type(15)
	QMetaType__QDateTime             = QMetaType__Type(16)
	QMetaType__QUrl                  = QMetaType__Type(17)
	QMetaType__QLocale               = QMetaType__Type(18)
	QMetaType__QRect                 = QMetaType__Type(19)
	QMetaType__QRectF                = QMetaType__Type(20)
	QMetaType__QSize                 = QMetaType__Type(21)
	QMetaType__QSizeF                = QMetaType__Type(22)
	QMetaType__QLine                 = QMetaType__Type(23)
	QMetaType__QLineF                = QMetaType__Type(24)
	QMetaType__QPoint                = QMetaType__Type(25)
	QMetaType__QPointF               = QMetaType__Type(26)
	QMetaType__QRegExp               = QMetaType__Type(27)
	QMetaType__QEasingCurve          = QMetaType__Type(29)
	QMetaType__QUuid                 = QMetaType__Type(30)
	QMetaType__QVariant              = QMetaType__Type(41)
	QMetaType__QModelIndex           = QMetaType__Type(42)
	QMetaType__QPersistentModelIndex = QMetaType__Type(50)
	QMetaType__QRegularExpression    = QMetaType__Type(44)
	QMetaType__QJsonValue            = QMetaType__Type(45)
	QMetaType__QJsonObject           = QMetaType__Type(46)
	QMetaType__QJsonArray            = QMetaType__Type(47)
	QMetaType__QJsonDocument         = QMetaType__Type(48)
	QMetaType__QByteArrayList        = QMetaType__Type(49)
	QMetaType__QObjectStar           = QMetaType__Type(39)
	QMetaType__SChar                 = QMetaType__Type(40)
	QMetaType__Void                  = QMetaType__Type(43)
	QMetaType__QVariantMap           = QMetaType__Type(8)
	QMetaType__QVariantList          = QMetaType__Type(9)
	QMetaType__QVariantHash          = QMetaType__Type(28)
	QMetaType__QFont                 = QMetaType__Type(64)
	QMetaType__QPixmap               = QMetaType__Type(65)
	QMetaType__QBrush                = QMetaType__Type(66)
	QMetaType__QColor                = QMetaType__Type(67)
	QMetaType__QPalette              = QMetaType__Type(68)
	QMetaType__QIcon                 = QMetaType__Type(69)
	QMetaType__QImage                = QMetaType__Type(70)
	QMetaType__QPolygon              = QMetaType__Type(71)
	QMetaType__QRegion               = QMetaType__Type(72)
	QMetaType__QBitmap               = QMetaType__Type(73)
	QMetaType__QCursor               = QMetaType__Type(74)
	QMetaType__QKeySequence          = QMetaType__Type(75)
	QMetaType__QPen                  = QMetaType__Type(76)
	QMetaType__QTextLength           = QMetaType__Type(77)
	QMetaType__QTextFormat           = QMetaType__Type(78)
	QMetaType__QMatrix               = QMetaType__Type(79)
	QMetaType__QTransform            = QMetaType__Type(80)
	QMetaType__QMatrix4x4            = QMetaType__Type(81)
	QMetaType__QVector2D             = QMetaType__Type(82)
	QMetaType__QVector3D             = QMetaType__Type(83)
	QMetaType__QVector4D             = QMetaType__Type(84)
	QMetaType__QQuaternion           = QMetaType__Type(85)
	QMetaType__QPolygonF             = QMetaType__Type(86)
	QMetaType__QSizePolicy           = QMetaType__Type(121)
	QMetaType__User                  = QMetaType__Type(1024)
)

//QMetaType::TypeFlag
type QMetaType__TypeFlag int64

const (
	QMetaType__NeedsConstruction        = QMetaType__TypeFlag(0x1)
	QMetaType__NeedsDestruction         = QMetaType__TypeFlag(0x2)
	QMetaType__MovableType              = QMetaType__TypeFlag(0x4)
	QMetaType__PointerToQObject         = QMetaType__TypeFlag(0x8)
	QMetaType__IsEnumeration            = QMetaType__TypeFlag(0x10)
	QMetaType__SharedPointerToQObject   = QMetaType__TypeFlag(0x20)
	QMetaType__WeakPointerToQObject     = QMetaType__TypeFlag(0x40)
	QMetaType__TrackingPointerToQObject = QMetaType__TypeFlag(0x80)
	QMetaType__WasDeclaredAsMetaType    = QMetaType__TypeFlag(0x100)
	QMetaType__IsGadget                 = QMetaType__TypeFlag(0x200)
)

func NewQMetaType(typeId int) *QMetaType {
	defer qt.Recovering("QMetaType::QMetaType")

	return newQMetaTypeFromPointer(C.QMetaType_NewQMetaType(C.int(typeId)))
}

func QMetaType_Compare(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
	defer qt.Recovering("QMetaType::compare")

	return C.QMetaType_QMetaType_Compare(lhs, rhs, C.int(typeId), C.int(result)) != 0
}

func QMetaType_Construct(ty int, where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
	defer qt.Recovering("QMetaType::construct")

	return unsafe.Pointer(C.QMetaType_QMetaType_Construct(C.int(ty), where, copy))
}

func (ptr *QMetaType) Construct3(where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
	defer qt.Recovering("QMetaType::construct")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QMetaType_Construct3(ptr.Pointer(), where, copy))
	}
	return nil
}

func QMetaType_Convert(from unsafe.Pointer, fromTypeId int, to unsafe.Pointer, toTypeId int) bool {
	defer qt.Recovering("QMetaType::convert")

	return C.QMetaType_QMetaType_Convert(from, C.int(fromTypeId), to, C.int(toTypeId)) != 0
}

func QMetaType_Create(ty int, copy unsafe.Pointer) unsafe.Pointer {
	defer qt.Recovering("QMetaType::create")

	return unsafe.Pointer(C.QMetaType_QMetaType_Create(C.int(ty), copy))
}

func (ptr *QMetaType) Create2(copy unsafe.Pointer) unsafe.Pointer {
	defer qt.Recovering("QMetaType::create")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QMetaType_Create2(ptr.Pointer(), copy))
	}
	return nil
}

func QMetaType_DebugStream(dbg QDebug_ITF, rhs unsafe.Pointer, typeId int) bool {
	defer qt.Recovering("QMetaType::debugStream")

	return C.QMetaType_QMetaType_DebugStream(PointerFromQDebug(dbg), rhs, C.int(typeId)) != 0
}

func QMetaType_Destroy(ty int, data unsafe.Pointer) {
	defer qt.Recovering("QMetaType::destroy")

	C.QMetaType_QMetaType_Destroy(C.int(ty), data)
}

func (ptr *QMetaType) Destroy2(data unsafe.Pointer) {
	defer qt.Recovering("QMetaType::destroy")

	if ptr.Pointer() != nil {
		C.QMetaType_Destroy2(ptr.Pointer(), data)
	}
}

func QMetaType_Destruct(ty int, where unsafe.Pointer) {
	defer qt.Recovering("QMetaType::destruct")

	C.QMetaType_QMetaType_Destruct(C.int(ty), where)
}

func (ptr *QMetaType) Destruct2(data unsafe.Pointer) {
	defer qt.Recovering("QMetaType::destruct")

	if ptr.Pointer() != nil {
		C.QMetaType_Destruct2(ptr.Pointer(), data)
	}
}

func QMetaType_Equals(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int, result int) bool {
	defer qt.Recovering("QMetaType::equals")

	return C.QMetaType_QMetaType_Equals(lhs, rhs, C.int(typeId), C.int(result)) != 0
}

func (ptr *QMetaType) Flags() QMetaType__TypeFlag {
	defer qt.Recovering("QMetaType::flags")

	if ptr.Pointer() != nil {
		return QMetaType__TypeFlag(C.QMetaType_Flags(ptr.Pointer()))
	}
	return 0
}

func QMetaType_IsRegistered(ty int) bool {
	defer qt.Recovering("QMetaType::isRegistered")

	return C.QMetaType_QMetaType_IsRegistered(C.int(ty)) != 0
}

func (ptr *QMetaType) IsRegistered2() bool {
	defer qt.Recovering("QMetaType::isRegistered")

	if ptr.Pointer() != nil {
		return C.QMetaType_IsRegistered2(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMetaType) IsValid() bool {
	defer qt.Recovering("QMetaType::isValid")

	if ptr.Pointer() != nil {
		return C.QMetaType_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func QMetaType_Load(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
	defer qt.Recovering("QMetaType::load")

	return C.QMetaType_QMetaType_Load(PointerFromQDataStream(stream), C.int(ty), data) != 0
}

func (ptr *QMetaType) MetaObject() *QMetaObject {
	defer qt.Recovering("QMetaType::metaObject")

	if ptr.Pointer() != nil {
		return NewQMetaObjectFromPointer(C.QMetaType_MetaObject(ptr.Pointer()))
	}
	return nil
}

func QMetaType_MetaObjectForType(ty int) *QMetaObject {
	defer qt.Recovering("QMetaType::metaObjectForType")

	return NewQMetaObjectFromPointer(C.QMetaType_QMetaType_MetaObjectForType(C.int(ty)))
}

func QMetaType_Save(stream QDataStream_ITF, ty int, data unsafe.Pointer) bool {
	defer qt.Recovering("QMetaType::save")

	return C.QMetaType_QMetaType_Save(PointerFromQDataStream(stream), C.int(ty), data) != 0
}

func QMetaType_SizeOf(ty int) int {
	defer qt.Recovering("QMetaType::sizeOf")

	return int(C.QMetaType_QMetaType_SizeOf(C.int(ty)))
}

func (ptr *QMetaType) SizeOf2() int {
	defer qt.Recovering("QMetaType::sizeOf")

	if ptr.Pointer() != nil {
		return int(C.QMetaType_SizeOf2(ptr.Pointer()))
	}
	return 0
}

func QMetaType_Type2(typeName string) int {
	defer qt.Recovering("QMetaType::type")

	return int(C.QMetaType_QMetaType_Type2(C.CString(typeName)))
}

func QMetaType_Type(typeName string) int {
	defer qt.Recovering("QMetaType::type")

	return int(C.QMetaType_QMetaType_Type(C.CString(typeName)))
}

func QMetaType_TypeFlags(ty int) QMetaType__TypeFlag {
	defer qt.Recovering("QMetaType::typeFlags")

	return QMetaType__TypeFlag(C.QMetaType_QMetaType_TypeFlags(C.int(ty)))
}

func (ptr *QMetaType) DestroyQMetaType() {
	defer qt.Recovering("QMetaType::~QMetaType")

	if ptr.Pointer() != nil {
		C.QMetaType_DestroyQMetaType(ptr.Pointer())
	}
}

type QMimeData struct {
	QObject
}

type QMimeData_ITF interface {
	QObject_ITF
	QMimeData_PTR() *QMimeData
}

func PointerFromQMimeData(ptr QMimeData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMimeData_PTR().Pointer()
	}
	return nil
}

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

func newQMimeDataFromPointer(ptr unsafe.Pointer) *QMimeData {
	var n = NewQMimeDataFromPointer(ptr)
	for len(n.ObjectName()) < len("QMimeData_") {
		n.SetObjectName("QMimeData_" + qt.Identifier())
	}
	return n
}

func (ptr *QMimeData) QMimeData_PTR() *QMimeData {
	return ptr
}

func NewQMimeData() *QMimeData {
	defer qt.Recovering("QMimeData::QMimeData")

	return newQMimeDataFromPointer(C.QMimeData_NewQMimeData())
}

func (ptr *QMimeData) Clear() {
	defer qt.Recovering("QMimeData::clear")

	if ptr.Pointer() != nil {
		C.QMimeData_Clear(ptr.Pointer())
	}
}

func (ptr *QMimeData) ColorData() *QVariant {
	defer qt.Recovering("QMimeData::colorData")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QMimeData_ColorData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMimeData) Data(mimeType string) string {
	defer qt.Recovering("QMimeData::data")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeData_Data(ptr.Pointer(), C.CString(mimeType)))
	}
	return ""
}

func (ptr *QMimeData) Formats() []string {
	defer qt.Recovering("QMimeData::formats")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QMimeData_Formats(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QMimeData) HasColor() bool {
	defer qt.Recovering("QMimeData::hasColor")

	if ptr.Pointer() != nil {
		return C.QMimeData_HasColor(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMimeData) HasFormat(mimeType string) bool {
	defer qt.Recovering("QMimeData::hasFormat")

	if ptr.Pointer() != nil {
		return C.QMimeData_HasFormat(ptr.Pointer(), C.CString(mimeType)) != 0
	}
	return false
}

func (ptr *QMimeData) HasHtml() bool {
	defer qt.Recovering("QMimeData::hasHtml")

	if ptr.Pointer() != nil {
		return C.QMimeData_HasHtml(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMimeData) HasImage() bool {
	defer qt.Recovering("QMimeData::hasImage")

	if ptr.Pointer() != nil {
		return C.QMimeData_HasImage(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMimeData) HasText() bool {
	defer qt.Recovering("QMimeData::hasText")

	if ptr.Pointer() != nil {
		return C.QMimeData_HasText(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMimeData) HasUrls() bool {
	defer qt.Recovering("QMimeData::hasUrls")

	if ptr.Pointer() != nil {
		return C.QMimeData_HasUrls(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMimeData) Html() string {
	defer qt.Recovering("QMimeData::html")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeData_Html(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeData) ImageData() *QVariant {
	defer qt.Recovering("QMimeData::imageData")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QMimeData_ImageData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMimeData) RemoveFormat(mimeType string) {
	defer qt.Recovering("QMimeData::removeFormat")

	if ptr.Pointer() != nil {
		C.QMimeData_RemoveFormat(ptr.Pointer(), C.CString(mimeType))
	}
}

func (ptr *QMimeData) SetColorData(color QVariant_ITF) {
	defer qt.Recovering("QMimeData::setColorData")

	if ptr.Pointer() != nil {
		C.QMimeData_SetColorData(ptr.Pointer(), PointerFromQVariant(color))
	}
}

func (ptr *QMimeData) SetData(mimeType string, data string) {
	defer qt.Recovering("QMimeData::setData")

	if ptr.Pointer() != nil {
		C.QMimeData_SetData(ptr.Pointer(), C.CString(mimeType), C.CString(data))
	}
}

func (ptr *QMimeData) SetHtml(html string) {
	defer qt.Recovering("QMimeData::setHtml")

	if ptr.Pointer() != nil {
		C.QMimeData_SetHtml(ptr.Pointer(), C.CString(html))
	}
}

func (ptr *QMimeData) SetImageData(image QVariant_ITF) {
	defer qt.Recovering("QMimeData::setImageData")

	if ptr.Pointer() != nil {
		C.QMimeData_SetImageData(ptr.Pointer(), PointerFromQVariant(image))
	}
}

func (ptr *QMimeData) SetText(text string) {
	defer qt.Recovering("QMimeData::setText")

	if ptr.Pointer() != nil {
		C.QMimeData_SetText(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QMimeData) Text() string {
	defer qt.Recovering("QMimeData::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeData_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeData) DestroyQMimeData() {
	defer qt.Recovering("QMimeData::~QMimeData")

	if ptr.Pointer() != nil {
		C.QMimeData_DestroyQMimeData(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMimeData) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QMimeData::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QMimeData) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QMimeData::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQMimeDataTimerEvent
func callbackQMimeDataTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QMimeData::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQMimeDataFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QMimeData) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QMimeData::timerEvent")

	if ptr.Pointer() != nil {
		C.QMimeData_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QMimeData) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QMimeData::timerEvent")

	if ptr.Pointer() != nil {
		C.QMimeData_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QMimeData) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QMimeData::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QMimeData) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QMimeData::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQMimeDataChildEvent
func callbackQMimeDataChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QMimeData::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQMimeDataFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QMimeData) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QMimeData::childEvent")

	if ptr.Pointer() != nil {
		C.QMimeData_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QMimeData) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QMimeData::childEvent")

	if ptr.Pointer() != nil {
		C.QMimeData_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QMimeData) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QMimeData::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QMimeData) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QMimeData::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQMimeDataCustomEvent
func callbackQMimeDataCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QMimeData::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQMimeDataFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QMimeData) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QMimeData::customEvent")

	if ptr.Pointer() != nil {
		C.QMimeData_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QMimeData) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QMimeData::customEvent")

	if ptr.Pointer() != nil {
		C.QMimeData_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QMimeDatabase struct {
	ptr unsafe.Pointer
}

type QMimeDatabase_ITF interface {
	QMimeDatabase_PTR() *QMimeDatabase
}

func (p *QMimeDatabase) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMimeDatabase) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMimeDatabase(ptr QMimeDatabase_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMimeDatabase_PTR().Pointer()
	}
	return nil
}

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

func newQMimeDatabaseFromPointer(ptr unsafe.Pointer) *QMimeDatabase {
	var n = NewQMimeDatabaseFromPointer(ptr)
	return n
}

func (ptr *QMimeDatabase) QMimeDatabase_PTR() *QMimeDatabase {
	return ptr
}

//QMimeDatabase::MatchMode
type QMimeDatabase__MatchMode int64

const (
	QMimeDatabase__MatchDefault   = QMimeDatabase__MatchMode(0x0)
	QMimeDatabase__MatchExtension = QMimeDatabase__MatchMode(0x1)
	QMimeDatabase__MatchContent   = QMimeDatabase__MatchMode(0x2)
)

func NewQMimeDatabase() *QMimeDatabase {
	defer qt.Recovering("QMimeDatabase::QMimeDatabase")

	return newQMimeDatabaseFromPointer(C.QMimeDatabase_NewQMimeDatabase())
}

func (ptr *QMimeDatabase) MimeTypeForName(nameOrAlias string) *QMimeType {
	defer qt.Recovering("QMimeDatabase::mimeTypeForName")

	if ptr.Pointer() != nil {
		return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForName(ptr.Pointer(), C.CString(nameOrAlias)))
	}
	return nil
}

func (ptr *QMimeDatabase) DestroyQMimeDatabase() {
	defer qt.Recovering("QMimeDatabase::~QMimeDatabase")

	if ptr.Pointer() != nil {
		C.QMimeDatabase_DestroyQMimeDatabase(ptr.Pointer())
	}
}

func (ptr *QMimeDatabase) MimeTypeForData2(device QIODevice_ITF) *QMimeType {
	defer qt.Recovering("QMimeDatabase::mimeTypeForData")

	if ptr.Pointer() != nil {
		return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForData2(ptr.Pointer(), PointerFromQIODevice(device)))
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForData(data string) *QMimeType {
	defer qt.Recovering("QMimeDatabase::mimeTypeForData")

	if ptr.Pointer() != nil {
		return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForData(ptr.Pointer(), C.CString(data)))
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForFile(fileInfo QFileInfo_ITF, mode QMimeDatabase__MatchMode) *QMimeType {
	defer qt.Recovering("QMimeDatabase::mimeTypeForFile")

	if ptr.Pointer() != nil {
		return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFile(ptr.Pointer(), PointerFromQFileInfo(fileInfo), C.int(mode)))
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForFile2(fileName string, mode QMimeDatabase__MatchMode) *QMimeType {
	defer qt.Recovering("QMimeDatabase::mimeTypeForFile")

	if ptr.Pointer() != nil {
		return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFile2(ptr.Pointer(), C.CString(fileName), C.int(mode)))
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForFileNameAndData(fileName string, device QIODevice_ITF) *QMimeType {
	defer qt.Recovering("QMimeDatabase::mimeTypeForFileNameAndData")

	if ptr.Pointer() != nil {
		return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFileNameAndData(ptr.Pointer(), C.CString(fileName), PointerFromQIODevice(device)))
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForFileNameAndData2(fileName string, data string) *QMimeType {
	defer qt.Recovering("QMimeDatabase::mimeTypeForFileNameAndData")

	if ptr.Pointer() != nil {
		return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForFileNameAndData2(ptr.Pointer(), C.CString(fileName), C.CString(data)))
	}
	return nil
}

func (ptr *QMimeDatabase) MimeTypeForUrl(url QUrl_ITF) *QMimeType {
	defer qt.Recovering("QMimeDatabase::mimeTypeForUrl")

	if ptr.Pointer() != nil {
		return NewQMimeTypeFromPointer(C.QMimeDatabase_MimeTypeForUrl(ptr.Pointer(), PointerFromQUrl(url)))
	}
	return nil
}

func (ptr *QMimeDatabase) SuffixForFileName(fileName string) string {
	defer qt.Recovering("QMimeDatabase::suffixForFileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeDatabase_SuffixForFileName(ptr.Pointer(), C.CString(fileName)))
	}
	return ""
}

type QMimeType struct {
	ptr unsafe.Pointer
}

type QMimeType_ITF interface {
	QMimeType_PTR() *QMimeType
}

func (p *QMimeType) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMimeType) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMimeType(ptr QMimeType_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMimeType_PTR().Pointer()
	}
	return nil
}

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

func newQMimeTypeFromPointer(ptr unsafe.Pointer) *QMimeType {
	var n = NewQMimeTypeFromPointer(ptr)
	return n
}

func (ptr *QMimeType) QMimeType_PTR() *QMimeType {
	return ptr
}

func NewQMimeType() *QMimeType {
	defer qt.Recovering("QMimeType::QMimeType")

	return newQMimeTypeFromPointer(C.QMimeType_NewQMimeType())
}

func NewQMimeType2(other QMimeType_ITF) *QMimeType {
	defer qt.Recovering("QMimeType::QMimeType")

	return newQMimeTypeFromPointer(C.QMimeType_NewQMimeType2(PointerFromQMimeType(other)))
}

func (ptr *QMimeType) FilterString() string {
	defer qt.Recovering("QMimeType::filterString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeType_FilterString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) GenericIconName() string {
	defer qt.Recovering("QMimeType::genericIconName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeType_GenericIconName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) GlobPatterns() []string {
	defer qt.Recovering("QMimeType::globPatterns")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QMimeType_GlobPatterns(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QMimeType) IconName() string {
	defer qt.Recovering("QMimeType::iconName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeType_IconName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) Inherits(mimeTypeName string) bool {
	defer qt.Recovering("QMimeType::inherits")

	if ptr.Pointer() != nil {
		return C.QMimeType_Inherits(ptr.Pointer(), C.CString(mimeTypeName)) != 0
	}
	return false
}

func (ptr *QMimeType) IsDefault() bool {
	defer qt.Recovering("QMimeType::isDefault")

	if ptr.Pointer() != nil {
		return C.QMimeType_IsDefault(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMimeType) IsValid() bool {
	defer qt.Recovering("QMimeType::isValid")

	if ptr.Pointer() != nil {
		return C.QMimeType_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QMimeType) Name() string {
	defer qt.Recovering("QMimeType::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeType_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) DestroyQMimeType() {
	defer qt.Recovering("QMimeType::~QMimeType")

	if ptr.Pointer() != nil {
		C.QMimeType_DestroyQMimeType(ptr.Pointer())
	}
}

func (ptr *QMimeType) Aliases() []string {
	defer qt.Recovering("QMimeType::aliases")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QMimeType_Aliases(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QMimeType) AllAncestors() []string {
	defer qt.Recovering("QMimeType::allAncestors")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QMimeType_AllAncestors(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QMimeType) Comment() string {
	defer qt.Recovering("QMimeType::comment")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeType_Comment(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) ParentMimeTypes() []string {
	defer qt.Recovering("QMimeType::parentMimeTypes")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QMimeType_ParentMimeTypes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QMimeType) PreferredSuffix() string {
	defer qt.Recovering("QMimeType::preferredSuffix")

	if ptr.Pointer() != nil {
		return C.GoString(C.QMimeType_PreferredSuffix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMimeType) Suffixes() []string {
	defer qt.Recovering("QMimeType::suffixes")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QMimeType_Suffixes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QMimeType) Swap(other QMimeType_ITF) {
	defer qt.Recovering("QMimeType::swap")

	if ptr.Pointer() != nil {
		C.QMimeType_Swap(ptr.Pointer(), PointerFromQMimeType(other))
	}
}

type QModelIndex struct {
	ptr unsafe.Pointer
}

type QModelIndex_ITF interface {
	QModelIndex_PTR() *QModelIndex
}

func (p *QModelIndex) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QModelIndex) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQModelIndex(ptr QModelIndex_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QModelIndex_PTR().Pointer()
	}
	return nil
}

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

func newQModelIndexFromPointer(ptr unsafe.Pointer) *QModelIndex {
	var n = NewQModelIndexFromPointer(ptr)
	return n
}

func (ptr *QModelIndex) QModelIndex_PTR() *QModelIndex {
	return ptr
}

func NewQModelIndex() *QModelIndex {
	defer qt.Recovering("QModelIndex::QModelIndex")

	return newQModelIndexFromPointer(C.QModelIndex_NewQModelIndex())
}

func (ptr *QModelIndex) Column() int {
	defer qt.Recovering("QModelIndex::column")

	if ptr.Pointer() != nil {
		return int(C.QModelIndex_Column(ptr.Pointer()))
	}
	return 0
}

func (ptr *QModelIndex) Data(role int) *QVariant {
	defer qt.Recovering("QModelIndex::data")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QModelIndex_Data(ptr.Pointer(), C.int(role)))
	}
	return nil
}

func (ptr *QModelIndex) Flags() Qt__ItemFlag {
	defer qt.Recovering("QModelIndex::flags")

	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QModelIndex_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QModelIndex) InternalPointer() unsafe.Pointer {
	defer qt.Recovering("QModelIndex::internalPointer")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QModelIndex_InternalPointer(ptr.Pointer()))
	}
	return nil
}

func (ptr *QModelIndex) IsValid() bool {
	defer qt.Recovering("QModelIndex::isValid")

	if ptr.Pointer() != nil {
		return C.QModelIndex_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QModelIndex) Model() *QAbstractItemModel {
	defer qt.Recovering("QModelIndex::model")

	if ptr.Pointer() != nil {
		return NewQAbstractItemModelFromPointer(C.QModelIndex_Model(ptr.Pointer()))
	}
	return nil
}

func (ptr *QModelIndex) Row() int {
	defer qt.Recovering("QModelIndex::row")

	if ptr.Pointer() != nil {
		return int(C.QModelIndex_Row(ptr.Pointer()))
	}
	return 0
}

type QModulesPrivate struct {
	ptr unsafe.Pointer
}

type QModulesPrivate_ITF interface {
	QModulesPrivate_PTR() *QModulesPrivate
}

func (p *QModulesPrivate) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QModulesPrivate) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQModulesPrivate(ptr QModulesPrivate_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QModulesPrivate_PTR().Pointer()
	}
	return nil
}

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

func newQModulesPrivateFromPointer(ptr unsafe.Pointer) *QModulesPrivate {
	var n = NewQModulesPrivateFromPointer(ptr)
	return n
}

func (ptr *QModulesPrivate) QModulesPrivate_PTR() *QModulesPrivate {
	return ptr
}

//QModulesPrivate::Names
type QModulesPrivate__Names int64

const (
	QModulesPrivate__Core         = QModulesPrivate__Names(0)
	QModulesPrivate__Gui          = QModulesPrivate__Names(1)
	QModulesPrivate__Widgets      = QModulesPrivate__Names(2)
	QModulesPrivate__Unknown      = QModulesPrivate__Names(3)
	QModulesPrivate__ModulesCount = QModulesPrivate__Names(4)
)

type QMultiHash struct {
	QHash
}

type QMultiHash_ITF interface {
	QHash_ITF
	QMultiHash_PTR() *QMultiHash
}

func PointerFromQMultiHash(ptr QMultiHash_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMultiHash_PTR().Pointer()
	}
	return nil
}

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

func newQMultiHashFromPointer(ptr unsafe.Pointer) *QMultiHash {
	var n = NewQMultiHashFromPointer(ptr)
	return n
}

func (ptr *QMultiHash) QMultiHash_PTR() *QMultiHash {
	return ptr
}

type QMultiMap struct {
	QMap
}

type QMultiMap_ITF interface {
	QMap_ITF
	QMultiMap_PTR() *QMultiMap
}

func PointerFromQMultiMap(ptr QMultiMap_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMultiMap_PTR().Pointer()
	}
	return nil
}

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

func newQMultiMapFromPointer(ptr unsafe.Pointer) *QMultiMap {
	var n = NewQMultiMapFromPointer(ptr)
	return n
}

func (ptr *QMultiMap) QMultiMap_PTR() *QMultiMap {
	return ptr
}

type QMutableHashIterator struct {
	ptr unsafe.Pointer
}

type QMutableHashIterator_ITF interface {
	QMutableHashIterator_PTR() *QMutableHashIterator
}

func (p *QMutableHashIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMutableHashIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMutableHashIterator(ptr QMutableHashIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableHashIterator_PTR().Pointer()
	}
	return nil
}

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

func newQMutableHashIteratorFromPointer(ptr unsafe.Pointer) *QMutableHashIterator {
	var n = NewQMutableHashIteratorFromPointer(ptr)
	return n
}

func (ptr *QMutableHashIterator) QMutableHashIterator_PTR() *QMutableHashIterator {
	return ptr
}

type QMutableLinkedListIterator struct {
	ptr unsafe.Pointer
}

type QMutableLinkedListIterator_ITF interface {
	QMutableLinkedListIterator_PTR() *QMutableLinkedListIterator
}

func (p *QMutableLinkedListIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMutableLinkedListIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMutableLinkedListIterator(ptr QMutableLinkedListIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableLinkedListIterator_PTR().Pointer()
	}
	return nil
}

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

func newQMutableLinkedListIteratorFromPointer(ptr unsafe.Pointer) *QMutableLinkedListIterator {
	var n = NewQMutableLinkedListIteratorFromPointer(ptr)
	return n
}

func (ptr *QMutableLinkedListIterator) QMutableLinkedListIterator_PTR() *QMutableLinkedListIterator {
	return ptr
}

type QMutableListIterator struct {
	ptr unsafe.Pointer
}

type QMutableListIterator_ITF interface {
	QMutableListIterator_PTR() *QMutableListIterator
}

func (p *QMutableListIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMutableListIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMutableListIterator(ptr QMutableListIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableListIterator_PTR().Pointer()
	}
	return nil
}

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

func newQMutableListIteratorFromPointer(ptr unsafe.Pointer) *QMutableListIterator {
	var n = NewQMutableListIteratorFromPointer(ptr)
	return n
}

func (ptr *QMutableListIterator) QMutableListIterator_PTR() *QMutableListIterator {
	return ptr
}

type QMutableMapIterator struct {
	ptr unsafe.Pointer
}

type QMutableMapIterator_ITF interface {
	QMutableMapIterator_PTR() *QMutableMapIterator
}

func (p *QMutableMapIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMutableMapIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMutableMapIterator(ptr QMutableMapIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableMapIterator_PTR().Pointer()
	}
	return nil
}

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

func newQMutableMapIteratorFromPointer(ptr unsafe.Pointer) *QMutableMapIterator {
	var n = NewQMutableMapIteratorFromPointer(ptr)
	return n
}

func (ptr *QMutableMapIterator) QMutableMapIterator_PTR() *QMutableMapIterator {
	return ptr
}

type QMutableSetIterator struct {
	ptr unsafe.Pointer
}

type QMutableSetIterator_ITF interface {
	QMutableSetIterator_PTR() *QMutableSetIterator
}

func (p *QMutableSetIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMutableSetIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMutableSetIterator(ptr QMutableSetIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableSetIterator_PTR().Pointer()
	}
	return nil
}

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

func newQMutableSetIteratorFromPointer(ptr unsafe.Pointer) *QMutableSetIterator {
	var n = NewQMutableSetIteratorFromPointer(ptr)
	return n
}

func (ptr *QMutableSetIterator) QMutableSetIterator_PTR() *QMutableSetIterator {
	return ptr
}

type QMutableVectorIterator struct {
	ptr unsafe.Pointer
}

type QMutableVectorIterator_ITF interface {
	QMutableVectorIterator_PTR() *QMutableVectorIterator
}

func (p *QMutableVectorIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMutableVectorIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMutableVectorIterator(ptr QMutableVectorIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutableVectorIterator_PTR().Pointer()
	}
	return nil
}

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

func newQMutableVectorIteratorFromPointer(ptr unsafe.Pointer) *QMutableVectorIterator {
	var n = NewQMutableVectorIteratorFromPointer(ptr)
	return n
}

func (ptr *QMutableVectorIterator) QMutableVectorIterator_PTR() *QMutableVectorIterator {
	return ptr
}

type QMutex struct {
	ptr unsafe.Pointer
}

type QMutex_ITF interface {
	QMutex_PTR() *QMutex
}

func (p *QMutex) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMutex) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMutex(ptr QMutex_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutex_PTR().Pointer()
	}
	return nil
}

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

func newQMutexFromPointer(ptr unsafe.Pointer) *QMutex {
	var n = NewQMutexFromPointer(ptr)
	return n
}

func (ptr *QMutex) QMutex_PTR() *QMutex {
	return ptr
}

//QMutex::RecursionMode
type QMutex__RecursionMode int64

const (
	QMutex__NonRecursive = QMutex__RecursionMode(0)
	QMutex__Recursive    = QMutex__RecursionMode(1)
)

func (ptr *QMutex) Lock() {
	defer qt.Recovering("QMutex::lock")

	if ptr.Pointer() != nil {
		C.QMutex_Lock(ptr.Pointer())
	}
}

func (ptr *QMutex) TryLock(timeout int) bool {
	defer qt.Recovering("QMutex::tryLock")

	if ptr.Pointer() != nil {
		return C.QMutex_TryLock(ptr.Pointer(), C.int(timeout)) != 0
	}
	return false
}

func (ptr *QMutex) Unlock() {
	defer qt.Recovering("QMutex::unlock")

	if ptr.Pointer() != nil {
		C.QMutex_Unlock(ptr.Pointer())
	}
}

func NewQMutex(mode QMutex__RecursionMode) *QMutex {
	defer qt.Recovering("QMutex::QMutex")

	return newQMutexFromPointer(C.QMutex_NewQMutex(C.int(mode)))
}

func (ptr *QMutex) IsRecursive() bool {
	defer qt.Recovering("QMutex::isRecursive")

	if ptr.Pointer() != nil {
		return C.QMutex_IsRecursive(ptr.Pointer()) != 0
	}
	return false
}

type QMutexLocker struct {
	ptr unsafe.Pointer
}

type QMutexLocker_ITF interface {
	QMutexLocker_PTR() *QMutexLocker
}

func (p *QMutexLocker) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QMutexLocker) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQMutexLocker(ptr QMutexLocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMutexLocker_PTR().Pointer()
	}
	return nil
}

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

func newQMutexLockerFromPointer(ptr unsafe.Pointer) *QMutexLocker {
	var n = NewQMutexLockerFromPointer(ptr)
	return n
}

func (ptr *QMutexLocker) QMutexLocker_PTR() *QMutexLocker {
	return ptr
}

func NewQMutexLocker(mutex QMutex_ITF) *QMutexLocker {
	defer qt.Recovering("QMutexLocker::QMutexLocker")

	return newQMutexLockerFromPointer(C.QMutexLocker_NewQMutexLocker(PointerFromQMutex(mutex)))
}

func (ptr *QMutexLocker) Mutex() *QMutex {
	defer qt.Recovering("QMutexLocker::mutex")

	if ptr.Pointer() != nil {
		return NewQMutexFromPointer(C.QMutexLocker_Mutex(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMutexLocker) Relock() {
	defer qt.Recovering("QMutexLocker::relock")

	if ptr.Pointer() != nil {
		C.QMutexLocker_Relock(ptr.Pointer())
	}
}

func (ptr *QMutexLocker) Unlock() {
	defer qt.Recovering("QMutexLocker::unlock")

	if ptr.Pointer() != nil {
		C.QMutexLocker_Unlock(ptr.Pointer())
	}
}

func (ptr *QMutexLocker) DestroyQMutexLocker() {
	defer qt.Recovering("QMutexLocker::~QMutexLocker")

	if ptr.Pointer() != nil {
		C.QMutexLocker_DestroyQMutexLocker(ptr.Pointer())
	}
}

type QObject struct {
	ptr unsafe.Pointer
}

type QObject_ITF interface {
	QObject_PTR() *QObject
}

func (p *QObject) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QObject) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQObject(ptr QObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

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

func newQObjectFromPointer(ptr unsafe.Pointer) *QObject {
	var n = NewQObjectFromPointer(ptr)
	for len(n.ObjectName()) < len("QObject_") {
		n.SetObjectName("QObject_" + qt.Identifier())
	}
	return n
}

func (ptr *QObject) QObject_PTR() *QObject {
	return ptr
}

func (ptr *QObject) InstallEventFilter(filterObj QObject_ITF) {
	defer qt.Recovering("QObject::installEventFilter")

	if ptr.Pointer() != nil {
		C.QObject_InstallEventFilter(ptr.Pointer(), PointerFromQObject(filterObj))
	}
}

func (ptr *QObject) ObjectName() string {
	defer qt.Recovering("QObject::objectName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QObject_ObjectName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QObject) SetObjectName(name string) {
	defer qt.Recovering("QObject::setObjectName")

	if ptr.Pointer() != nil {
		C.QObject_SetObjectName(ptr.Pointer(), C.CString(name))
	}
}

func (ptr *QObject) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QObject::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QObject) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QObject::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQObjectTimerEvent
func callbackQObjectTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QObject::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQObjectFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QObject) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QObject::timerEvent")

	if ptr.Pointer() != nil {
		C.QObject_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QObject) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QObject::timerEvent")

	if ptr.Pointer() != nil {
		C.QObject_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func NewQObject(parent QObject_ITF) *QObject {
	defer qt.Recovering("QObject::QObject")

	return newQObjectFromPointer(C.QObject_NewQObject(PointerFromQObject(parent)))
}

func (ptr *QObject) BlockSignals(block bool) bool {
	defer qt.Recovering("QObject::blockSignals")

	if ptr.Pointer() != nil {
		return C.QObject_BlockSignals(ptr.Pointer(), C.int(qt.GoBoolToInt(block))) != 0
	}
	return false
}

func (ptr *QObject) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QObject::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QObject) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QObject::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQObjectChildEvent
func callbackQObjectChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QObject::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQObjectFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QObject) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QObject::childEvent")

	if ptr.Pointer() != nil {
		C.QObject_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QObject) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QObject::childEvent")

	if ptr.Pointer() != nil {
		C.QObject_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QObject) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QObject::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QObject) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QObject::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQObjectCustomEvent
func callbackQObjectCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QObject::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQObjectFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QObject) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QObject::customEvent")

	if ptr.Pointer() != nil {
		C.QObject_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QObject) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QObject::customEvent")

	if ptr.Pointer() != nil {
		C.QObject_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QObject) DeleteLater() {
	defer qt.Recovering("QObject::deleteLater")

	if ptr.Pointer() != nil {
		C.QObject_DeleteLater(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QObject) ConnectDestroyed(f func(obj *QObject)) {
	defer qt.Recovering("connect QObject::destroyed")

	if ptr.Pointer() != nil {
		C.QObject_ConnectDestroyed(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "destroyed", f)
	}
}

func (ptr *QObject) DisconnectDestroyed() {
	defer qt.Recovering("disconnect QObject::destroyed")

	if ptr.Pointer() != nil {
		C.QObject_DisconnectDestroyed(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "destroyed")
	}
}

//export callbackQObjectDestroyed
func callbackQObjectDestroyed(ptr unsafe.Pointer, ptrName *C.char, obj unsafe.Pointer) {
	defer qt.Recovering("callback QObject::destroyed")

	if signal := qt.GetSignal(C.GoString(ptrName), "destroyed"); signal != nil {
		signal.(func(*QObject))(NewQObjectFromPointer(obj))
	}

}

func (ptr *QObject) Destroyed(obj QObject_ITF) {
	defer qt.Recovering("QObject::destroyed")

	if ptr.Pointer() != nil {
		C.QObject_Destroyed(ptr.Pointer(), PointerFromQObject(obj))
	}
}

func (ptr *QObject) DumpObjectInfo() {
	defer qt.Recovering("QObject::dumpObjectInfo")

	if ptr.Pointer() != nil {
		C.QObject_DumpObjectInfo(ptr.Pointer())
	}
}

func (ptr *QObject) DumpObjectTree() {
	defer qt.Recovering("QObject::dumpObjectTree")

	if ptr.Pointer() != nil {
		C.QObject_DumpObjectTree(ptr.Pointer())
	}
}

func (ptr *QObject) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QObject::event")

	if ptr.Pointer() != nil {
		return C.QObject_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QObject) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
	defer qt.Recovering("QObject::eventFilter")

	if ptr.Pointer() != nil {
		return C.QObject_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QObject) FindChild(name string, options Qt__FindChildOption) unsafe.Pointer {
	defer qt.Recovering("QObject::findChild")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QObject_FindChild(ptr.Pointer(), C.CString(name), C.int(options)))
	}
	return nil
}

func (ptr *QObject) Inherits(className string) bool {
	defer qt.Recovering("QObject::inherits")

	if ptr.Pointer() != nil {
		return C.QObject_Inherits(ptr.Pointer(), C.CString(className)) != 0
	}
	return false
}

func (ptr *QObject) IsWidgetType() bool {
	defer qt.Recovering("QObject::isWidgetType")

	if ptr.Pointer() != nil {
		return C.QObject_IsWidgetType(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QObject) IsWindowType() bool {
	defer qt.Recovering("QObject::isWindowType")

	if ptr.Pointer() != nil {
		return C.QObject_IsWindowType(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QObject) KillTimer(id int) {
	defer qt.Recovering("QObject::killTimer")

	if ptr.Pointer() != nil {
		C.QObject_KillTimer(ptr.Pointer(), C.int(id))
	}
}

func (ptr *QObject) MetaObject() *QMetaObject {
	defer qt.Recovering("QObject::metaObject")

	if ptr.Pointer() != nil {
		return NewQMetaObjectFromPointer(C.QObject_MetaObject(ptr.Pointer()))
	}
	return nil
}

func (ptr *QObject) MoveToThread(targetThread QThread_ITF) {
	defer qt.Recovering("QObject::moveToThread")

	if ptr.Pointer() != nil {
		C.QObject_MoveToThread(ptr.Pointer(), PointerFromQThread(targetThread))
	}
}

func (ptr *QObject) ConnectObjectNameChanged(f func(objectName string)) {
	defer qt.Recovering("connect QObject::objectNameChanged")

	if ptr.Pointer() != nil {
		C.QObject_ConnectObjectNameChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "objectNameChanged", f)
	}
}

func (ptr *QObject) DisconnectObjectNameChanged() {
	defer qt.Recovering("disconnect QObject::objectNameChanged")

	if ptr.Pointer() != nil {
		C.QObject_DisconnectObjectNameChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "objectNameChanged")
	}
}

//export callbackQObjectObjectNameChanged
func callbackQObjectObjectNameChanged(ptr unsafe.Pointer, ptrName *C.char, objectName *C.char) {
	defer qt.Recovering("callback QObject::objectNameChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "objectNameChanged"); signal != nil {
		signal.(func(string))(C.GoString(objectName))
	}

}

func (ptr *QObject) Parent() *QObject {
	defer qt.Recovering("QObject::parent")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QObject_Parent(ptr.Pointer()))
	}
	return nil
}

func (ptr *QObject) Property(name string) *QVariant {
	defer qt.Recovering("QObject::property")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QObject_Property(ptr.Pointer(), C.CString(name)))
	}
	return nil
}

func (ptr *QObject) RemoveEventFilter(obj QObject_ITF) {
	defer qt.Recovering("QObject::removeEventFilter")

	if ptr.Pointer() != nil {
		C.QObject_RemoveEventFilter(ptr.Pointer(), PointerFromQObject(obj))
	}
}

func (ptr *QObject) SetParent(parent QObject_ITF) {
	defer qt.Recovering("QObject::setParent")

	if ptr.Pointer() != nil {
		C.QObject_SetParent(ptr.Pointer(), PointerFromQObject(parent))
	}
}

func (ptr *QObject) SetProperty(name string, value QVariant_ITF) bool {
	defer qt.Recovering("QObject::setProperty")

	if ptr.Pointer() != nil {
		return C.QObject_SetProperty(ptr.Pointer(), C.CString(name), PointerFromQVariant(value)) != 0
	}
	return false
}

func (ptr *QObject) StartTimer(interval int, timerType Qt__TimerType) int {
	defer qt.Recovering("QObject::startTimer")

	if ptr.Pointer() != nil {
		return int(C.QObject_StartTimer(ptr.Pointer(), C.int(interval), C.int(timerType)))
	}
	return 0
}

func (ptr *QObject) SignalsBlocked() bool {
	defer qt.Recovering("QObject::signalsBlocked")

	if ptr.Pointer() != nil {
		return C.QObject_SignalsBlocked(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QObject) Thread() *QThread {
	defer qt.Recovering("QObject::thread")

	if ptr.Pointer() != nil {
		return NewQThreadFromPointer(C.QObject_Thread(ptr.Pointer()))
	}
	return nil
}

func QObject_Tr(sourceText string, disambiguation string, n int) string {
	defer qt.Recovering("QObject::tr")

	return C.GoString(C.QObject_QObject_Tr(C.CString(sourceText), C.CString(disambiguation), C.int(n)))
}

func (ptr *QObject) DestroyQObject() {
	defer qt.Recovering("QObject::~QObject")

	if ptr.Pointer() != nil {
		C.QObject_DestroyQObject(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

type QObjectCleanupHandler struct {
	QObject
}

type QObjectCleanupHandler_ITF interface {
	QObject_ITF
	QObjectCleanupHandler_PTR() *QObjectCleanupHandler
}

func PointerFromQObjectCleanupHandler(ptr QObjectCleanupHandler_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QObjectCleanupHandler_PTR().Pointer()
	}
	return nil
}

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

func newQObjectCleanupHandlerFromPointer(ptr unsafe.Pointer) *QObjectCleanupHandler {
	var n = NewQObjectCleanupHandlerFromPointer(ptr)
	for len(n.ObjectName()) < len("QObjectCleanupHandler_") {
		n.SetObjectName("QObjectCleanupHandler_" + qt.Identifier())
	}
	return n
}

func (ptr *QObjectCleanupHandler) QObjectCleanupHandler_PTR() *QObjectCleanupHandler {
	return ptr
}

func NewQObjectCleanupHandler() *QObjectCleanupHandler {
	defer qt.Recovering("QObjectCleanupHandler::QObjectCleanupHandler")

	return newQObjectCleanupHandlerFromPointer(C.QObjectCleanupHandler_NewQObjectCleanupHandler())
}

func (ptr *QObjectCleanupHandler) Add(object QObject_ITF) *QObject {
	defer qt.Recovering("QObjectCleanupHandler::add")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QObjectCleanupHandler_Add(ptr.Pointer(), PointerFromQObject(object)))
	}
	return nil
}

func (ptr *QObjectCleanupHandler) Clear() {
	defer qt.Recovering("QObjectCleanupHandler::clear")

	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_Clear(ptr.Pointer())
	}
}

func (ptr *QObjectCleanupHandler) IsEmpty() bool {
	defer qt.Recovering("QObjectCleanupHandler::isEmpty")

	if ptr.Pointer() != nil {
		return C.QObjectCleanupHandler_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QObjectCleanupHandler) DestroyQObjectCleanupHandler() {
	defer qt.Recovering("QObjectCleanupHandler::~QObjectCleanupHandler")

	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_DestroyQObjectCleanupHandler(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QObjectCleanupHandler) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QObjectCleanupHandler::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QObjectCleanupHandler) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QObjectCleanupHandler::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQObjectCleanupHandlerTimerEvent
func callbackQObjectCleanupHandlerTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QObjectCleanupHandler::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQObjectCleanupHandlerFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QObjectCleanupHandler) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QObjectCleanupHandler::timerEvent")

	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QObjectCleanupHandler) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QObjectCleanupHandler::timerEvent")

	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QObjectCleanupHandler) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QObjectCleanupHandler::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QObjectCleanupHandler) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QObjectCleanupHandler::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQObjectCleanupHandlerChildEvent
func callbackQObjectCleanupHandlerChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QObjectCleanupHandler::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQObjectCleanupHandlerFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QObjectCleanupHandler) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QObjectCleanupHandler::childEvent")

	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QObjectCleanupHandler) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QObjectCleanupHandler::childEvent")

	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QObjectCleanupHandler) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QObjectCleanupHandler::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QObjectCleanupHandler) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QObjectCleanupHandler::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQObjectCleanupHandlerCustomEvent
func callbackQObjectCleanupHandlerCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QObjectCleanupHandler::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQObjectCleanupHandlerFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QObjectCleanupHandler) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QObjectCleanupHandler::customEvent")

	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QObjectCleanupHandler) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QObjectCleanupHandler::customEvent")

	if ptr.Pointer() != nil {
		C.QObjectCleanupHandler_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QPair struct {
	ptr unsafe.Pointer
}

type QPair_ITF interface {
	QPair_PTR() *QPair
}

func (p *QPair) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPair) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPair(ptr QPair_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPair_PTR().Pointer()
	}
	return nil
}

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

func newQPairFromPointer(ptr unsafe.Pointer) *QPair {
	var n = NewQPairFromPointer(ptr)
	return n
}

func (ptr *QPair) QPair_PTR() *QPair {
	return ptr
}

type QParallelAnimationGroup struct {
	QAnimationGroup
}

type QParallelAnimationGroup_ITF interface {
	QAnimationGroup_ITF
	QParallelAnimationGroup_PTR() *QParallelAnimationGroup
}

func PointerFromQParallelAnimationGroup(ptr QParallelAnimationGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QParallelAnimationGroup_PTR().Pointer()
	}
	return nil
}

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

func newQParallelAnimationGroupFromPointer(ptr unsafe.Pointer) *QParallelAnimationGroup {
	var n = NewQParallelAnimationGroupFromPointer(ptr)
	for len(n.ObjectName()) < len("QParallelAnimationGroup_") {
		n.SetObjectName("QParallelAnimationGroup_" + qt.Identifier())
	}
	return n
}

func (ptr *QParallelAnimationGroup) QParallelAnimationGroup_PTR() *QParallelAnimationGroup {
	return ptr
}

func (ptr *QParallelAnimationGroup) Duration() int {
	defer qt.Recovering("QParallelAnimationGroup::duration")

	if ptr.Pointer() != nil {
		return int(C.QParallelAnimationGroup_Duration(ptr.Pointer()))
	}
	return 0
}

func (ptr *QParallelAnimationGroup) Event(event QEvent_ITF) bool {
	defer qt.Recovering("QParallelAnimationGroup::event")

	if ptr.Pointer() != nil {
		return C.QParallelAnimationGroup_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QParallelAnimationGroup) ConnectUpdateCurrentTime(f func(currentTime int)) {
	defer qt.Recovering("connect QParallelAnimationGroup::updateCurrentTime")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
	}
}

func (ptr *QParallelAnimationGroup) DisconnectUpdateCurrentTime() {
	defer qt.Recovering("disconnect QParallelAnimationGroup::updateCurrentTime")

	if ptr.Pointer() != nil {

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

//export callbackQParallelAnimationGroupUpdateCurrentTime
func callbackQParallelAnimationGroupUpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, currentTime C.int) {
	defer qt.Recovering("callback QParallelAnimationGroup::updateCurrentTime")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
		signal.(func(int))(int(currentTime))
	} else {
		NewQParallelAnimationGroupFromPointer(ptr).UpdateCurrentTimeDefault(int(currentTime))
	}
}

func (ptr *QParallelAnimationGroup) UpdateCurrentTime(currentTime int) {
	defer qt.Recovering("QParallelAnimationGroup::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_UpdateCurrentTime(ptr.Pointer(), C.int(currentTime))
	}
}

func (ptr *QParallelAnimationGroup) UpdateCurrentTimeDefault(currentTime int) {
	defer qt.Recovering("QParallelAnimationGroup::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(currentTime))
	}
}

func (ptr *QParallelAnimationGroup) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
	defer qt.Recovering("connect QParallelAnimationGroup::updateDirection")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
	}
}

func (ptr *QParallelAnimationGroup) DisconnectUpdateDirection() {
	defer qt.Recovering("disconnect QParallelAnimationGroup::updateDirection")

	if ptr.Pointer() != nil {

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

//export callbackQParallelAnimationGroupUpdateDirection
func callbackQParallelAnimationGroupUpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
	defer qt.Recovering("callback QParallelAnimationGroup::updateDirection")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
	} else {
		NewQParallelAnimationGroupFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
	}
}

func (ptr *QParallelAnimationGroup) UpdateDirection(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QParallelAnimationGroup::updateDirection")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_UpdateDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QParallelAnimationGroup) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QParallelAnimationGroup::updateDirection")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QParallelAnimationGroup) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
	defer qt.Recovering("connect QParallelAnimationGroup::updateState")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
	}
}

func (ptr *QParallelAnimationGroup) DisconnectUpdateState() {
	defer qt.Recovering("disconnect QParallelAnimationGroup::updateState")

	if ptr.Pointer() != nil {

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

//export callbackQParallelAnimationGroupUpdateState
func callbackQParallelAnimationGroupUpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
	defer qt.Recovering("callback QParallelAnimationGroup::updateState")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
		signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	} else {
		NewQParallelAnimationGroupFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	}
}

func (ptr *QParallelAnimationGroup) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QParallelAnimationGroup::updateState")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QParallelAnimationGroup) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QParallelAnimationGroup::updateState")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QParallelAnimationGroup) DestroyQParallelAnimationGroup() {
	defer qt.Recovering("QParallelAnimationGroup::~QParallelAnimationGroup")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_DestroyQParallelAnimationGroup(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QParallelAnimationGroup) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QParallelAnimationGroup::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QParallelAnimationGroup) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QParallelAnimationGroup::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQParallelAnimationGroupTimerEvent
func callbackQParallelAnimationGroupTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QParallelAnimationGroup::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQParallelAnimationGroupFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QParallelAnimationGroup) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QParallelAnimationGroup::timerEvent")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QParallelAnimationGroup) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QParallelAnimationGroup::timerEvent")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QParallelAnimationGroup) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QParallelAnimationGroup::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QParallelAnimationGroup) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QParallelAnimationGroup::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQParallelAnimationGroupChildEvent
func callbackQParallelAnimationGroupChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QParallelAnimationGroup::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQParallelAnimationGroupFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QParallelAnimationGroup) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QParallelAnimationGroup::childEvent")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QParallelAnimationGroup) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QParallelAnimationGroup::childEvent")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QParallelAnimationGroup) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QParallelAnimationGroup::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QParallelAnimationGroup) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QParallelAnimationGroup::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQParallelAnimationGroupCustomEvent
func callbackQParallelAnimationGroupCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QParallelAnimationGroup::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQParallelAnimationGroupFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QParallelAnimationGroup) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QParallelAnimationGroup::customEvent")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QParallelAnimationGroup) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QParallelAnimationGroup::customEvent")

	if ptr.Pointer() != nil {
		C.QParallelAnimationGroup_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QPauseAnimation struct {
	QAbstractAnimation
}

type QPauseAnimation_ITF interface {
	QAbstractAnimation_ITF
	QPauseAnimation_PTR() *QPauseAnimation
}

func PointerFromQPauseAnimation(ptr QPauseAnimation_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPauseAnimation_PTR().Pointer()
	}
	return nil
}

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

func newQPauseAnimationFromPointer(ptr unsafe.Pointer) *QPauseAnimation {
	var n = NewQPauseAnimationFromPointer(ptr)
	for len(n.ObjectName()) < len("QPauseAnimation_") {
		n.SetObjectName("QPauseAnimation_" + qt.Identifier())
	}
	return n
}

func (ptr *QPauseAnimation) QPauseAnimation_PTR() *QPauseAnimation {
	return ptr
}

func (ptr *QPauseAnimation) Duration() int {
	defer qt.Recovering("QPauseAnimation::duration")

	if ptr.Pointer() != nil {
		return int(C.QPauseAnimation_Duration(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPauseAnimation) SetDuration(msecs int) {
	defer qt.Recovering("QPauseAnimation::setDuration")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_SetDuration(ptr.Pointer(), C.int(msecs))
	}
}

func NewQPauseAnimation(parent QObject_ITF) *QPauseAnimation {
	defer qt.Recovering("QPauseAnimation::QPauseAnimation")

	return newQPauseAnimationFromPointer(C.QPauseAnimation_NewQPauseAnimation(PointerFromQObject(parent)))
}

func NewQPauseAnimation2(msecs int, parent QObject_ITF) *QPauseAnimation {
	defer qt.Recovering("QPauseAnimation::QPauseAnimation")

	return newQPauseAnimationFromPointer(C.QPauseAnimation_NewQPauseAnimation2(C.int(msecs), PointerFromQObject(parent)))
}

func (ptr *QPauseAnimation) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QPauseAnimation::event")

	if ptr.Pointer() != nil {
		return C.QPauseAnimation_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QPauseAnimation) ConnectUpdateCurrentTime(f func(v int)) {
	defer qt.Recovering("connect QPauseAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
	}
}

func (ptr *QPauseAnimation) DisconnectUpdateCurrentTime() {
	defer qt.Recovering("disconnect QPauseAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {

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

//export callbackQPauseAnimationUpdateCurrentTime
func callbackQPauseAnimationUpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, v C.int) {
	defer qt.Recovering("callback QPauseAnimation::updateCurrentTime")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
		signal.(func(int))(int(v))
	} else {
		NewQPauseAnimationFromPointer(ptr).UpdateCurrentTimeDefault(int(v))
	}
}

func (ptr *QPauseAnimation) UpdateCurrentTime(v int) {
	defer qt.Recovering("QPauseAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QPauseAnimation) UpdateCurrentTimeDefault(v int) {
	defer qt.Recovering("QPauseAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QPauseAnimation) DestroyQPauseAnimation() {
	defer qt.Recovering("QPauseAnimation::~QPauseAnimation")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_DestroyQPauseAnimation(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QPauseAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
	defer qt.Recovering("connect QPauseAnimation::updateDirection")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
	}
}

func (ptr *QPauseAnimation) DisconnectUpdateDirection() {
	defer qt.Recovering("disconnect QPauseAnimation::updateDirection")

	if ptr.Pointer() != nil {

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

//export callbackQPauseAnimationUpdateDirection
func callbackQPauseAnimationUpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
	defer qt.Recovering("callback QPauseAnimation::updateDirection")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
	} else {
		NewQPauseAnimationFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
	}
}

func (ptr *QPauseAnimation) UpdateDirection(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QPauseAnimation::updateDirection")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_UpdateDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QPauseAnimation) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QPauseAnimation::updateDirection")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QPauseAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
	defer qt.Recovering("connect QPauseAnimation::updateState")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
	}
}

func (ptr *QPauseAnimation) DisconnectUpdateState() {
	defer qt.Recovering("disconnect QPauseAnimation::updateState")

	if ptr.Pointer() != nil {

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

//export callbackQPauseAnimationUpdateState
func callbackQPauseAnimationUpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
	defer qt.Recovering("callback QPauseAnimation::updateState")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
		signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	} else {
		NewQPauseAnimationFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	}
}

func (ptr *QPauseAnimation) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QPauseAnimation::updateState")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QPauseAnimation) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QPauseAnimation::updateState")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QPauseAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QPauseAnimation::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QPauseAnimation) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QPauseAnimation::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQPauseAnimationTimerEvent
func callbackQPauseAnimationTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPauseAnimation::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQPauseAnimationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QPauseAnimation) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QPauseAnimation::timerEvent")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QPauseAnimation) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QPauseAnimation::timerEvent")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QPauseAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QPauseAnimation::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QPauseAnimation) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QPauseAnimation::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQPauseAnimationChildEvent
func callbackQPauseAnimationChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPauseAnimation::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQPauseAnimationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QPauseAnimation) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QPauseAnimation::childEvent")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QPauseAnimation) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QPauseAnimation::childEvent")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QPauseAnimation) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QPauseAnimation::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QPauseAnimation) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QPauseAnimation::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQPauseAnimationCustomEvent
func callbackQPauseAnimationCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPauseAnimation::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQPauseAnimationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QPauseAnimation) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QPauseAnimation::customEvent")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QPauseAnimation) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QPauseAnimation::customEvent")

	if ptr.Pointer() != nil {
		C.QPauseAnimation_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QPersistentModelIndex struct {
	ptr unsafe.Pointer
}

type QPersistentModelIndex_ITF interface {
	QPersistentModelIndex_PTR() *QPersistentModelIndex
}

func (p *QPersistentModelIndex) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPersistentModelIndex) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPersistentModelIndex(ptr QPersistentModelIndex_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPersistentModelIndex_PTR().Pointer()
	}
	return nil
}

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

func newQPersistentModelIndexFromPointer(ptr unsafe.Pointer) *QPersistentModelIndex {
	var n = NewQPersistentModelIndexFromPointer(ptr)
	return n
}

func (ptr *QPersistentModelIndex) QPersistentModelIndex_PTR() *QPersistentModelIndex {
	return ptr
}

func NewQPersistentModelIndex3(other QPersistentModelIndex_ITF) *QPersistentModelIndex {
	defer qt.Recovering("QPersistentModelIndex::QPersistentModelIndex")

	return newQPersistentModelIndexFromPointer(C.QPersistentModelIndex_NewQPersistentModelIndex3(PointerFromQPersistentModelIndex(other)))
}

func (ptr *QPersistentModelIndex) Column() int {
	defer qt.Recovering("QPersistentModelIndex::column")

	if ptr.Pointer() != nil {
		return int(C.QPersistentModelIndex_Column(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPersistentModelIndex) IsValid() bool {
	defer qt.Recovering("QPersistentModelIndex::isValid")

	if ptr.Pointer() != nil {
		return C.QPersistentModelIndex_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPersistentModelIndex) Row() int {
	defer qt.Recovering("QPersistentModelIndex::row")

	if ptr.Pointer() != nil {
		return int(C.QPersistentModelIndex_Row(ptr.Pointer()))
	}
	return 0
}

func NewQPersistentModelIndex4(other QPersistentModelIndex_ITF) *QPersistentModelIndex {
	defer qt.Recovering("QPersistentModelIndex::QPersistentModelIndex")

	return newQPersistentModelIndexFromPointer(C.QPersistentModelIndex_NewQPersistentModelIndex4(PointerFromQPersistentModelIndex(other)))
}

func NewQPersistentModelIndex(index QModelIndex_ITF) *QPersistentModelIndex {
	defer qt.Recovering("QPersistentModelIndex::QPersistentModelIndex")

	return newQPersistentModelIndexFromPointer(C.QPersistentModelIndex_NewQPersistentModelIndex(PointerFromQModelIndex(index)))
}

func (ptr *QPersistentModelIndex) Data(role int) *QVariant {
	defer qt.Recovering("QPersistentModelIndex::data")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QPersistentModelIndex_Data(ptr.Pointer(), C.int(role)))
	}
	return nil
}

func (ptr *QPersistentModelIndex) Flags() Qt__ItemFlag {
	defer qt.Recovering("QPersistentModelIndex::flags")

	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QPersistentModelIndex_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPersistentModelIndex) Model() *QAbstractItemModel {
	defer qt.Recovering("QPersistentModelIndex::model")

	if ptr.Pointer() != nil {
		return NewQAbstractItemModelFromPointer(C.QPersistentModelIndex_Model(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPersistentModelIndex) Swap(other QPersistentModelIndex_ITF) {
	defer qt.Recovering("QPersistentModelIndex::swap")

	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 PointerFromQPluginLoader(ptr QPluginLoader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPluginLoader_PTR().Pointer()
	}
	return nil
}

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

func newQPluginLoaderFromPointer(ptr unsafe.Pointer) *QPluginLoader {
	var n = NewQPluginLoaderFromPointer(ptr)
	for len(n.ObjectName()) < len("QPluginLoader_") {
		n.SetObjectName("QPluginLoader_" + qt.Identifier())
	}
	return n
}

func (ptr *QPluginLoader) QPluginLoader_PTR() *QPluginLoader {
	return ptr
}

func (ptr *QPluginLoader) FileName() string {
	defer qt.Recovering("QPluginLoader::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPluginLoader_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPluginLoader) LoadHints() QLibrary__LoadHint {
	defer qt.Recovering("QPluginLoader::loadHints")

	if ptr.Pointer() != nil {
		return QLibrary__LoadHint(C.QPluginLoader_LoadHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPluginLoader) SetFileName(fileName string) {
	defer qt.Recovering("QPluginLoader::setFileName")

	if ptr.Pointer() != nil {
		C.QPluginLoader_SetFileName(ptr.Pointer(), C.CString(fileName))
	}
}

func (ptr *QPluginLoader) SetLoadHints(loadHints QLibrary__LoadHint) {
	defer qt.Recovering("QPluginLoader::setLoadHints")

	if ptr.Pointer() != nil {
		C.QPluginLoader_SetLoadHints(ptr.Pointer(), C.int(loadHints))
	}
}

func NewQPluginLoader(parent QObject_ITF) *QPluginLoader {
	defer qt.Recovering("QPluginLoader::QPluginLoader")

	return newQPluginLoaderFromPointer(C.QPluginLoader_NewQPluginLoader(PointerFromQObject(parent)))
}

func NewQPluginLoader2(fileName string, parent QObject_ITF) *QPluginLoader {
	defer qt.Recovering("QPluginLoader::QPluginLoader")

	return newQPluginLoaderFromPointer(C.QPluginLoader_NewQPluginLoader2(C.CString(fileName), PointerFromQObject(parent)))
}

func (ptr *QPluginLoader) ErrorString() string {
	defer qt.Recovering("QPluginLoader::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPluginLoader_ErrorString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPluginLoader) Instance() *QObject {
	defer qt.Recovering("QPluginLoader::instance")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QPluginLoader_Instance(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPluginLoader) IsLoaded() bool {
	defer qt.Recovering("QPluginLoader::isLoaded")

	if ptr.Pointer() != nil {
		return C.QPluginLoader_IsLoaded(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPluginLoader) Load() bool {
	defer qt.Recovering("QPluginLoader::load")

	if ptr.Pointer() != nil {
		return C.QPluginLoader_Load(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPluginLoader) MetaData() *QJsonObject {
	defer qt.Recovering("QPluginLoader::metaData")

	if ptr.Pointer() != nil {
		return NewQJsonObjectFromPointer(C.QPluginLoader_MetaData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPluginLoader) Unload() bool {
	defer qt.Recovering("QPluginLoader::unload")

	if ptr.Pointer() != nil {
		return C.QPluginLoader_Unload(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPluginLoader) DestroyQPluginLoader() {
	defer qt.Recovering("QPluginLoader::~QPluginLoader")

	if ptr.Pointer() != nil {
		C.QPluginLoader_DestroyQPluginLoader(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QPluginLoader) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QPluginLoader::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QPluginLoader) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QPluginLoader::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQPluginLoaderTimerEvent
func callbackQPluginLoaderTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPluginLoader::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQPluginLoaderFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QPluginLoader) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QPluginLoader::timerEvent")

	if ptr.Pointer() != nil {
		C.QPluginLoader_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QPluginLoader) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QPluginLoader::timerEvent")

	if ptr.Pointer() != nil {
		C.QPluginLoader_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QPluginLoader) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QPluginLoader::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QPluginLoader) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QPluginLoader::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQPluginLoaderChildEvent
func callbackQPluginLoaderChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPluginLoader::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQPluginLoaderFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QPluginLoader) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QPluginLoader::childEvent")

	if ptr.Pointer() != nil {
		C.QPluginLoader_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QPluginLoader) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QPluginLoader::childEvent")

	if ptr.Pointer() != nil {
		C.QPluginLoader_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QPluginLoader) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QPluginLoader::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QPluginLoader) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QPluginLoader::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQPluginLoaderCustomEvent
func callbackQPluginLoaderCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPluginLoader::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQPluginLoaderFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QPluginLoader) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QPluginLoader::customEvent")

	if ptr.Pointer() != nil {
		C.QPluginLoader_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QPluginLoader) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QPluginLoader::customEvent")

	if ptr.Pointer() != nil {
		C.QPluginLoader_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QPoint struct {
	ptr unsafe.Pointer
}

type QPoint_ITF interface {
	QPoint_PTR() *QPoint
}

func (p *QPoint) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPoint) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPoint(ptr QPoint_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPoint_PTR().Pointer()
	}
	return nil
}

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

func newQPointFromPointer(ptr unsafe.Pointer) *QPoint {
	var n = NewQPointFromPointer(ptr)
	return n
}

func (ptr *QPoint) QPoint_PTR() *QPoint {
	return ptr
}

func NewQPoint() *QPoint {
	defer qt.Recovering("QPoint::QPoint")

	return newQPointFromPointer(C.QPoint_NewQPoint())
}

func NewQPoint2(xpos int, ypos int) *QPoint {
	defer qt.Recovering("QPoint::QPoint")

	return newQPointFromPointer(C.QPoint_NewQPoint2(C.int(xpos), C.int(ypos)))
}

func QPoint_DotProduct(p1 QPoint_ITF, p2 QPoint_ITF) int {
	defer qt.Recovering("QPoint::dotProduct")

	return int(C.QPoint_QPoint_DotProduct(PointerFromQPoint(p1), PointerFromQPoint(p2)))
}

func (ptr *QPoint) IsNull() bool {
	defer qt.Recovering("QPoint::isNull")

	if ptr.Pointer() != nil {
		return C.QPoint_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPoint) ManhattanLength() int {
	defer qt.Recovering("QPoint::manhattanLength")

	if ptr.Pointer() != nil {
		return int(C.QPoint_ManhattanLength(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPoint) Rx() int {
	defer qt.Recovering("QPoint::rx")

	if ptr.Pointer() != nil {
		return int(C.QPoint_Rx(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPoint) Ry() int {
	defer qt.Recovering("QPoint::ry")

	if ptr.Pointer() != nil {
		return int(C.QPoint_Ry(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPoint) SetX(x int) {
	defer qt.Recovering("QPoint::setX")

	if ptr.Pointer() != nil {
		C.QPoint_SetX(ptr.Pointer(), C.int(x))
	}
}

func (ptr *QPoint) SetY(y int) {
	defer qt.Recovering("QPoint::setY")

	if ptr.Pointer() != nil {
		C.QPoint_SetY(ptr.Pointer(), C.int(y))
	}
}

func (ptr *QPoint) X() int {
	defer qt.Recovering("QPoint::x")

	if ptr.Pointer() != nil {
		return int(C.QPoint_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPoint) Y() int {
	defer qt.Recovering("QPoint::y")

	if ptr.Pointer() != nil {
		return int(C.QPoint_Y(ptr.Pointer()))
	}
	return 0
}

type QPointF struct {
	ptr unsafe.Pointer
}

type QPointF_ITF interface {
	QPointF_PTR() *QPointF
}

func (p *QPointF) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPointF) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPointF(ptr QPointF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPointF_PTR().Pointer()
	}
	return nil
}

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

func newQPointFFromPointer(ptr unsafe.Pointer) *QPointF {
	var n = NewQPointFFromPointer(ptr)
	return n
}

func (ptr *QPointF) QPointF_PTR() *QPointF {
	return ptr
}

func NewQPointF() *QPointF {
	defer qt.Recovering("QPointF::QPointF")

	return newQPointFFromPointer(C.QPointF_NewQPointF())
}

func NewQPointF2(point QPoint_ITF) *QPointF {
	defer qt.Recovering("QPointF::QPointF")

	return newQPointFFromPointer(C.QPointF_NewQPointF2(PointerFromQPoint(point)))
}

func NewQPointF3(xpos float64, ypos float64) *QPointF {
	defer qt.Recovering("QPointF::QPointF")

	return newQPointFFromPointer(C.QPointF_NewQPointF3(C.double(xpos), C.double(ypos)))
}

func QPointF_DotProduct(p1 QPointF_ITF, p2 QPointF_ITF) float64 {
	defer qt.Recovering("QPointF::dotProduct")

	return float64(C.QPointF_QPointF_DotProduct(PointerFromQPointF(p1), PointerFromQPointF(p2)))
}

func (ptr *QPointF) IsNull() bool {
	defer qt.Recovering("QPointF::isNull")

	if ptr.Pointer() != nil {
		return C.QPointF_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPointF) ManhattanLength() float64 {
	defer qt.Recovering("QPointF::manhattanLength")

	if ptr.Pointer() != nil {
		return float64(C.QPointF_ManhattanLength(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPointF) Rx() float64 {
	defer qt.Recovering("QPointF::rx")

	if ptr.Pointer() != nil {
		return float64(C.QPointF_Rx(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPointF) Ry() float64 {
	defer qt.Recovering("QPointF::ry")

	if ptr.Pointer() != nil {
		return float64(C.QPointF_Ry(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPointF) SetX(x float64) {
	defer qt.Recovering("QPointF::setX")

	if ptr.Pointer() != nil {
		C.QPointF_SetX(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QPointF) SetY(y float64) {
	defer qt.Recovering("QPointF::setY")

	if ptr.Pointer() != nil {
		C.QPointF_SetY(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QPointF) ToPoint() *QPoint {
	defer qt.Recovering("QPointF::toPoint")

	if ptr.Pointer() != nil {
		return NewQPointFromPointer(C.QPointF_ToPoint(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPointF) X() float64 {
	defer qt.Recovering("QPointF::x")

	if ptr.Pointer() != nil {
		return float64(C.QPointF_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPointF) Y() float64 {
	defer qt.Recovering("QPointF::y")

	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 (p *QPointer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPointer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPointer(ptr QPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPointer_PTR().Pointer()
	}
	return nil
}

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

func newQPointerFromPointer(ptr unsafe.Pointer) *QPointer {
	var n = NewQPointerFromPointer(ptr)
	return n
}

func (ptr *QPointer) QPointer_PTR() *QPointer {
	return ptr
}

type QProcess struct {
	QIODevice
}

type QProcess_ITF interface {
	QIODevice_ITF
	QProcess_PTR() *QProcess
}

func PointerFromQProcess(ptr QProcess_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QProcess_PTR().Pointer()
	}
	return nil
}

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

func newQProcessFromPointer(ptr unsafe.Pointer) *QProcess {
	var n = NewQProcessFromPointer(ptr)
	for len(n.ObjectName()) < len("QProcess_") {
		n.SetObjectName("QProcess_" + qt.Identifier())
	}
	return n
}

func (ptr *QProcess) QProcess_PTR() *QProcess {
	return ptr
}

//QProcess::ExitStatus
type QProcess__ExitStatus int64

const (
	QProcess__NormalExit = QProcess__ExitStatus(0)
	QProcess__CrashExit  = QProcess__ExitStatus(1)
)

//QProcess::InputChannelMode
type QProcess__InputChannelMode int64

const (
	QProcess__ManagedInputChannel   = QProcess__InputChannelMode(0)
	QProcess__ForwardedInputChannel = QProcess__InputChannelMode(1)
)

//QProcess::ProcessChannel
type QProcess__ProcessChannel int64

const (
	QProcess__StandardOutput = QProcess__ProcessChannel(0)
	QProcess__StandardError  = QProcess__ProcessChannel(1)
)

//QProcess::ProcessChannelMode
type QProcess__ProcessChannelMode int64

const (
	QProcess__SeparateChannels       = QProcess__ProcessChannelMode(0)
	QProcess__MergedChannels         = QProcess__ProcessChannelMode(1)
	QProcess__ForwardedChannels      = QProcess__ProcessChannelMode(2)
	QProcess__ForwardedOutputChannel = QProcess__ProcessChannelMode(3)
	QProcess__ForwardedErrorChannel  = QProcess__ProcessChannelMode(4)
)

//QProcess::ProcessError
type QProcess__ProcessError int64

const (
	QProcess__FailedToStart = QProcess__ProcessError(0)
	QProcess__Crashed       = QProcess__ProcessError(1)
	QProcess__Timedout      = QProcess__ProcessError(2)
	QProcess__ReadError     = QProcess__ProcessError(3)
	QProcess__WriteError    = QProcess__ProcessError(4)
	QProcess__UnknownError  = QProcess__ProcessError(5)
)

//QProcess::ProcessState
type QProcess__ProcessState int64

const (
	QProcess__NotRunning = QProcess__ProcessState(0)
	QProcess__Starting   = QProcess__ProcessState(1)
	QProcess__Running    = QProcess__ProcessState(2)
)

func NewQProcess(parent QObject_ITF) *QProcess {
	defer qt.Recovering("QProcess::QProcess")

	return newQProcessFromPointer(C.QProcess_NewQProcess(PointerFromQObject(parent)))
}

func (ptr *QProcess) Arguments() []string {
	defer qt.Recovering("QProcess::arguments")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QProcess_Arguments(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QProcess) AtEnd() bool {
	defer qt.Recovering("QProcess::atEnd")

	if ptr.Pointer() != nil {
		return C.QProcess_AtEnd(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QProcess) BytesAvailable() int64 {
	defer qt.Recovering("QProcess::bytesAvailable")

	if ptr.Pointer() != nil {
		return int64(C.QProcess_BytesAvailable(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) BytesToWrite() int64 {
	defer qt.Recovering("QProcess::bytesToWrite")

	if ptr.Pointer() != nil {
		return int64(C.QProcess_BytesToWrite(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) CanReadLine() bool {
	defer qt.Recovering("QProcess::canReadLine")

	if ptr.Pointer() != nil {
		return C.QProcess_CanReadLine(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QProcess) ConnectClose(f func()) {
	defer qt.Recovering("connect QProcess::close")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "close", f)
	}
}

func (ptr *QProcess) DisconnectClose() {
	defer qt.Recovering("disconnect QProcess::close")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "close")
	}
}

//export callbackQProcessClose
func callbackQProcessClose(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QProcess::close")

	if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
		signal.(func())()
	} else {
		NewQProcessFromPointer(ptr).CloseDefault()
	}
}

func (ptr *QProcess) Close() {
	defer qt.Recovering("QProcess::close")

	if ptr.Pointer() != nil {
		C.QProcess_Close(ptr.Pointer())
	}
}

func (ptr *QProcess) CloseDefault() {
	defer qt.Recovering("QProcess::close")

	if ptr.Pointer() != nil {
		C.QProcess_CloseDefault(ptr.Pointer())
	}
}

func (ptr *QProcess) CloseReadChannel(channel QProcess__ProcessChannel) {
	defer qt.Recovering("QProcess::closeReadChannel")

	if ptr.Pointer() != nil {
		C.QProcess_CloseReadChannel(ptr.Pointer(), C.int(channel))
	}
}

func (ptr *QProcess) CloseWriteChannel() {
	defer qt.Recovering("QProcess::closeWriteChannel")

	if ptr.Pointer() != nil {
		C.QProcess_CloseWriteChannel(ptr.Pointer())
	}
}

func (ptr *QProcess) ConnectError2(f func(error QProcess__ProcessError)) {
	defer qt.Recovering("connect QProcess::error")

	if ptr.Pointer() != nil {
		C.QProcess_ConnectError2(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "error2", f)
	}
}

func (ptr *QProcess) DisconnectError2() {
	defer qt.Recovering("disconnect QProcess::error")

	if ptr.Pointer() != nil {
		C.QProcess_DisconnectError2(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "error2")
	}
}

//export callbackQProcessError2
func callbackQProcessError2(ptr unsafe.Pointer, ptrName *C.char, error C.int) {
	defer qt.Recovering("callback QProcess::error")

	if signal := qt.GetSignal(C.GoString(ptrName), "error2"); signal != nil {
		signal.(func(QProcess__ProcessError))(QProcess__ProcessError(error))
	}

}

func (ptr *QProcess) Error2(error QProcess__ProcessError) {
	defer qt.Recovering("QProcess::error")

	if ptr.Pointer() != nil {
		C.QProcess_Error2(ptr.Pointer(), C.int(error))
	}
}

func (ptr *QProcess) Error() QProcess__ProcessError {
	defer qt.Recovering("QProcess::error")

	if ptr.Pointer() != nil {
		return QProcess__ProcessError(C.QProcess_Error(ptr.Pointer()))
	}
	return 0
}

func QProcess_Execute2(command string) int {
	defer qt.Recovering("QProcess::execute")

	return int(C.QProcess_QProcess_Execute2(C.CString(command)))
}

func QProcess_Execute(program string, arguments []string) int {
	defer qt.Recovering("QProcess::execute")

	return int(C.QProcess_QProcess_Execute(C.CString(program), C.CString(strings.Join(arguments, "|"))))
}

func (ptr *QProcess) ExitCode() int {
	defer qt.Recovering("QProcess::exitCode")

	if ptr.Pointer() != nil {
		return int(C.QProcess_ExitCode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) ExitStatus() QProcess__ExitStatus {
	defer qt.Recovering("QProcess::exitStatus")

	if ptr.Pointer() != nil {
		return QProcess__ExitStatus(C.QProcess_ExitStatus(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) ConnectFinished(f func(exitCode int, exitStatus QProcess__ExitStatus)) {
	defer qt.Recovering("connect QProcess::finished")

	if ptr.Pointer() != nil {
		C.QProcess_ConnectFinished(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "finished", f)
	}
}

func (ptr *QProcess) DisconnectFinished() {
	defer qt.Recovering("disconnect QProcess::finished")

	if ptr.Pointer() != nil {
		C.QProcess_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "finished")
	}
}

//export callbackQProcessFinished
func callbackQProcessFinished(ptr unsafe.Pointer, ptrName *C.char, exitCode C.int, exitStatus C.int) {
	defer qt.Recovering("callback QProcess::finished")

	if signal := qt.GetSignal(C.GoString(ptrName), "finished"); signal != nil {
		signal.(func(int, QProcess__ExitStatus))(int(exitCode), QProcess__ExitStatus(exitStatus))
	}

}

func (ptr *QProcess) Finished(exitCode int, exitStatus QProcess__ExitStatus) {
	defer qt.Recovering("QProcess::finished")

	if ptr.Pointer() != nil {
		C.QProcess_Finished(ptr.Pointer(), C.int(exitCode), C.int(exitStatus))
	}
}

func (ptr *QProcess) InputChannelMode() QProcess__InputChannelMode {
	defer qt.Recovering("QProcess::inputChannelMode")

	if ptr.Pointer() != nil {
		return QProcess__InputChannelMode(C.QProcess_InputChannelMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) IsSequential() bool {
	defer qt.Recovering("QProcess::isSequential")

	if ptr.Pointer() != nil {
		return C.QProcess_IsSequential(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QProcess) Kill() {
	defer qt.Recovering("QProcess::kill")

	if ptr.Pointer() != nil {
		C.QProcess_Kill(ptr.Pointer())
	}
}

func QProcess_NullDevice() string {
	defer qt.Recovering("QProcess::nullDevice")

	return C.GoString(C.QProcess_QProcess_NullDevice())
}

func (ptr *QProcess) Open(mode QIODevice__OpenModeFlag) bool {
	defer qt.Recovering("QProcess::open")

	if ptr.Pointer() != nil {
		return C.QProcess_Open(ptr.Pointer(), C.int(mode)) != 0
	}
	return false
}

func (ptr *QProcess) ProcessChannelMode() QProcess__ProcessChannelMode {
	defer qt.Recovering("QProcess::processChannelMode")

	if ptr.Pointer() != nil {
		return QProcess__ProcessChannelMode(C.QProcess_ProcessChannelMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) ProcessEnvironment() *QProcessEnvironment {
	defer qt.Recovering("QProcess::processEnvironment")

	if ptr.Pointer() != nil {
		return NewQProcessEnvironmentFromPointer(C.QProcess_ProcessEnvironment(ptr.Pointer()))
	}
	return nil
}

func (ptr *QProcess) ProcessId() int64 {
	defer qt.Recovering("QProcess::processId")

	if ptr.Pointer() != nil {
		return int64(C.QProcess_ProcessId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) Program() string {
	defer qt.Recovering("QProcess::program")

	if ptr.Pointer() != nil {
		return C.GoString(C.QProcess_Program(ptr.Pointer()))
	}
	return ""
}

func (ptr *QProcess) ReadAllStandardError() string {
	defer qt.Recovering("QProcess::readAllStandardError")

	if ptr.Pointer() != nil {
		return C.GoString(C.QProcess_ReadAllStandardError(ptr.Pointer()))
	}
	return ""
}

func (ptr *QProcess) ReadAllStandardOutput() string {
	defer qt.Recovering("QProcess::readAllStandardOutput")

	if ptr.Pointer() != nil {
		return C.GoString(C.QProcess_ReadAllStandardOutput(ptr.Pointer()))
	}
	return ""
}

func (ptr *QProcess) ReadChannel() QProcess__ProcessChannel {
	defer qt.Recovering("QProcess::readChannel")

	if ptr.Pointer() != nil {
		return QProcess__ProcessChannel(C.QProcess_ReadChannel(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) ReadData(data string, maxlen int64) int64 {
	defer qt.Recovering("QProcess::readData")

	if ptr.Pointer() != nil {
		return int64(C.QProcess_ReadData(ptr.Pointer(), C.CString(data), C.longlong(maxlen)))
	}
	return 0
}

func (ptr *QProcess) ConnectReadyReadStandardError(f func()) {
	defer qt.Recovering("connect QProcess::readyReadStandardError")

	if ptr.Pointer() != nil {
		C.QProcess_ConnectReadyReadStandardError(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "readyReadStandardError", f)
	}
}

func (ptr *QProcess) DisconnectReadyReadStandardError() {
	defer qt.Recovering("disconnect QProcess::readyReadStandardError")

	if ptr.Pointer() != nil {
		C.QProcess_DisconnectReadyReadStandardError(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "readyReadStandardError")
	}
}

//export callbackQProcessReadyReadStandardError
func callbackQProcessReadyReadStandardError(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QProcess::readyReadStandardError")

	if signal := qt.GetSignal(C.GoString(ptrName), "readyReadStandardError"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QProcess) ConnectReadyReadStandardOutput(f func()) {
	defer qt.Recovering("connect QProcess::readyReadStandardOutput")

	if ptr.Pointer() != nil {
		C.QProcess_ConnectReadyReadStandardOutput(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "readyReadStandardOutput", f)
	}
}

func (ptr *QProcess) DisconnectReadyReadStandardOutput() {
	defer qt.Recovering("disconnect QProcess::readyReadStandardOutput")

	if ptr.Pointer() != nil {
		C.QProcess_DisconnectReadyReadStandardOutput(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "readyReadStandardOutput")
	}
}

//export callbackQProcessReadyReadStandardOutput
func callbackQProcessReadyReadStandardOutput(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QProcess::readyReadStandardOutput")

	if signal := qt.GetSignal(C.GoString(ptrName), "readyReadStandardOutput"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QProcess) SetArguments(arguments []string) {
	defer qt.Recovering("QProcess::setArguments")

	if ptr.Pointer() != nil {
		C.QProcess_SetArguments(ptr.Pointer(), C.CString(strings.Join(arguments, "|")))
	}
}

func (ptr *QProcess) SetInputChannelMode(mode QProcess__InputChannelMode) {
	defer qt.Recovering("QProcess::setInputChannelMode")

	if ptr.Pointer() != nil {
		C.QProcess_SetInputChannelMode(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QProcess) SetProcessChannelMode(mode QProcess__ProcessChannelMode) {
	defer qt.Recovering("QProcess::setProcessChannelMode")

	if ptr.Pointer() != nil {
		C.QProcess_SetProcessChannelMode(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QProcess) SetProcessEnvironment(environment QProcessEnvironment_ITF) {
	defer qt.Recovering("QProcess::setProcessEnvironment")

	if ptr.Pointer() != nil {
		C.QProcess_SetProcessEnvironment(ptr.Pointer(), PointerFromQProcessEnvironment(environment))
	}
}

func (ptr *QProcess) SetProgram(program string) {
	defer qt.Recovering("QProcess::setProgram")

	if ptr.Pointer() != nil {
		C.QProcess_SetProgram(ptr.Pointer(), C.CString(program))
	}
}

func (ptr *QProcess) SetReadChannel(channel QProcess__ProcessChannel) {
	defer qt.Recovering("QProcess::setReadChannel")

	if ptr.Pointer() != nil {
		C.QProcess_SetReadChannel(ptr.Pointer(), C.int(channel))
	}
}

func (ptr *QProcess) SetStandardErrorFile(fileName string, mode QIODevice__OpenModeFlag) {
	defer qt.Recovering("QProcess::setStandardErrorFile")

	if ptr.Pointer() != nil {
		C.QProcess_SetStandardErrorFile(ptr.Pointer(), C.CString(fileName), C.int(mode))
	}
}

func (ptr *QProcess) SetStandardInputFile(fileName string) {
	defer qt.Recovering("QProcess::setStandardInputFile")

	if ptr.Pointer() != nil {
		C.QProcess_SetStandardInputFile(ptr.Pointer(), C.CString(fileName))
	}
}

func (ptr *QProcess) SetStandardOutputFile(fileName string, mode QIODevice__OpenModeFlag) {
	defer qt.Recovering("QProcess::setStandardOutputFile")

	if ptr.Pointer() != nil {
		C.QProcess_SetStandardOutputFile(ptr.Pointer(), C.CString(fileName), C.int(mode))
	}
}

func (ptr *QProcess) SetStandardOutputProcess(destination QProcess_ITF) {
	defer qt.Recovering("QProcess::setStandardOutputProcess")

	if ptr.Pointer() != nil {
		C.QProcess_SetStandardOutputProcess(ptr.Pointer(), PointerFromQProcess(destination))
	}
}

func (ptr *QProcess) SetWorkingDirectory(dir string) {
	defer qt.Recovering("QProcess::setWorkingDirectory")

	if ptr.Pointer() != nil {
		C.QProcess_SetWorkingDirectory(ptr.Pointer(), C.CString(dir))
	}
}

func (ptr *QProcess) ConnectSetupChildProcess(f func()) {
	defer qt.Recovering("connect QProcess::setupChildProcess")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "setupChildProcess", f)
	}
}

func (ptr *QProcess) DisconnectSetupChildProcess() {
	defer qt.Recovering("disconnect QProcess::setupChildProcess")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "setupChildProcess")
	}
}

//export callbackQProcessSetupChildProcess
func callbackQProcessSetupChildProcess(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QProcess::setupChildProcess")

	if signal := qt.GetSignal(C.GoString(ptrName), "setupChildProcess"); signal != nil {
		signal.(func())()
	} else {
		NewQProcessFromPointer(ptr).SetupChildProcessDefault()
	}
}

func (ptr *QProcess) SetupChildProcess() {
	defer qt.Recovering("QProcess::setupChildProcess")

	if ptr.Pointer() != nil {
		C.QProcess_SetupChildProcess(ptr.Pointer())
	}
}

func (ptr *QProcess) SetupChildProcessDefault() {
	defer qt.Recovering("QProcess::setupChildProcess")

	if ptr.Pointer() != nil {
		C.QProcess_SetupChildProcessDefault(ptr.Pointer())
	}
}

func (ptr *QProcess) Start2(mode QIODevice__OpenModeFlag) {
	defer qt.Recovering("QProcess::start")

	if ptr.Pointer() != nil {
		C.QProcess_Start2(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QProcess) Start3(command string, mode QIODevice__OpenModeFlag) {
	defer qt.Recovering("QProcess::start")

	if ptr.Pointer() != nil {
		C.QProcess_Start3(ptr.Pointer(), C.CString(command), C.int(mode))
	}
}

func (ptr *QProcess) Start(program string, arguments []string, mode QIODevice__OpenModeFlag) {
	defer qt.Recovering("QProcess::start")

	if ptr.Pointer() != nil {
		C.QProcess_Start(ptr.Pointer(), C.CString(program), C.CString(strings.Join(arguments, "|")), C.int(mode))
	}
}

func QProcess_StartDetached2(command string) bool {
	defer qt.Recovering("QProcess::startDetached")

	return C.QProcess_QProcess_StartDetached2(C.CString(command)) != 0
}

func (ptr *QProcess) ConnectStarted(f func()) {
	defer qt.Recovering("connect QProcess::started")

	if ptr.Pointer() != nil {
		C.QProcess_ConnectStarted(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "started", f)
	}
}

func (ptr *QProcess) DisconnectStarted() {
	defer qt.Recovering("disconnect QProcess::started")

	if ptr.Pointer() != nil {
		C.QProcess_DisconnectStarted(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "started")
	}
}

//export callbackQProcessStarted
func callbackQProcessStarted(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QProcess::started")

	if signal := qt.GetSignal(C.GoString(ptrName), "started"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QProcess) State() QProcess__ProcessState {
	defer qt.Recovering("QProcess::state")

	if ptr.Pointer() != nil {
		return QProcess__ProcessState(C.QProcess_State(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProcess) ConnectStateChanged(f func(newState QProcess__ProcessState)) {
	defer qt.Recovering("connect QProcess::stateChanged")

	if ptr.Pointer() != nil {
		C.QProcess_ConnectStateChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "stateChanged", f)
	}
}

func (ptr *QProcess) DisconnectStateChanged() {
	defer qt.Recovering("disconnect QProcess::stateChanged")

	if ptr.Pointer() != nil {
		C.QProcess_DisconnectStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "stateChanged")
	}
}

//export callbackQProcessStateChanged
func callbackQProcessStateChanged(ptr unsafe.Pointer, ptrName *C.char, newState C.int) {
	defer qt.Recovering("callback QProcess::stateChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "stateChanged"); signal != nil {
		signal.(func(QProcess__ProcessState))(QProcess__ProcessState(newState))
	}

}

func QProcess_SystemEnvironment() []string {
	defer qt.Recovering("QProcess::systemEnvironment")

	return strings.Split(C.GoString(C.QProcess_QProcess_SystemEnvironment()), "|")
}

func (ptr *QProcess) Terminate() {
	defer qt.Recovering("QProcess::terminate")

	if ptr.Pointer() != nil {
		C.QProcess_Terminate(ptr.Pointer())
	}
}

func (ptr *QProcess) WaitForBytesWritten(msecs int) bool {
	defer qt.Recovering("QProcess::waitForBytesWritten")

	if ptr.Pointer() != nil {
		return C.QProcess_WaitForBytesWritten(ptr.Pointer(), C.int(msecs)) != 0
	}
	return false
}

func (ptr *QProcess) WaitForFinished(msecs int) bool {
	defer qt.Recovering("QProcess::waitForFinished")

	if ptr.Pointer() != nil {
		return C.QProcess_WaitForFinished(ptr.Pointer(), C.int(msecs)) != 0
	}
	return false
}

func (ptr *QProcess) WaitForReadyRead(msecs int) bool {
	defer qt.Recovering("QProcess::waitForReadyRead")

	if ptr.Pointer() != nil {
		return C.QProcess_WaitForReadyRead(ptr.Pointer(), C.int(msecs)) != 0
	}
	return false
}

func (ptr *QProcess) WaitForStarted(msecs int) bool {
	defer qt.Recovering("QProcess::waitForStarted")

	if ptr.Pointer() != nil {
		return C.QProcess_WaitForStarted(ptr.Pointer(), C.int(msecs)) != 0
	}
	return false
}

func (ptr *QProcess) WorkingDirectory() string {
	defer qt.Recovering("QProcess::workingDirectory")

	if ptr.Pointer() != nil {
		return C.GoString(C.QProcess_WorkingDirectory(ptr.Pointer()))
	}
	return ""
}

func (ptr *QProcess) WriteData(data string, len int64) int64 {
	defer qt.Recovering("QProcess::writeData")

	if ptr.Pointer() != nil {
		return int64(C.QProcess_WriteData(ptr.Pointer(), C.CString(data), C.longlong(len)))
	}
	return 0
}

func (ptr *QProcess) DestroyQProcess() {
	defer qt.Recovering("QProcess::~QProcess")

	if ptr.Pointer() != nil {
		C.QProcess_DestroyQProcess(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QProcess) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QProcess::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QProcess) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QProcess::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQProcessTimerEvent
func callbackQProcessTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QProcess::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQProcessFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QProcess) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QProcess::timerEvent")

	if ptr.Pointer() != nil {
		C.QProcess_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QProcess) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QProcess::timerEvent")

	if ptr.Pointer() != nil {
		C.QProcess_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QProcess) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QProcess::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QProcess) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QProcess::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQProcessChildEvent
func callbackQProcessChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QProcess::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQProcessFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QProcess) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QProcess::childEvent")

	if ptr.Pointer() != nil {
		C.QProcess_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QProcess) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QProcess::childEvent")

	if ptr.Pointer() != nil {
		C.QProcess_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QProcess) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QProcess::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QProcess) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QProcess::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQProcessCustomEvent
func callbackQProcessCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QProcess::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQProcessFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QProcess) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QProcess::customEvent")

	if ptr.Pointer() != nil {
		C.QProcess_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QProcess) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QProcess::customEvent")

	if ptr.Pointer() != nil {
		C.QProcess_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QProcessEnvironment struct {
	ptr unsafe.Pointer
}

type QProcessEnvironment_ITF interface {
	QProcessEnvironment_PTR() *QProcessEnvironment
}

func (p *QProcessEnvironment) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QProcessEnvironment) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQProcessEnvironment(ptr QProcessEnvironment_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QProcessEnvironment_PTR().Pointer()
	}
	return nil
}

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

func newQProcessEnvironmentFromPointer(ptr unsafe.Pointer) *QProcessEnvironment {
	var n = NewQProcessEnvironmentFromPointer(ptr)
	return n
}

func (ptr *QProcessEnvironment) QProcessEnvironment_PTR() *QProcessEnvironment {
	return ptr
}

func NewQProcessEnvironment() *QProcessEnvironment {
	defer qt.Recovering("QProcessEnvironment::QProcessEnvironment")

	return newQProcessEnvironmentFromPointer(C.QProcessEnvironment_NewQProcessEnvironment())
}

func NewQProcessEnvironment2(other QProcessEnvironment_ITF) *QProcessEnvironment {
	defer qt.Recovering("QProcessEnvironment::QProcessEnvironment")

	return newQProcessEnvironmentFromPointer(C.QProcessEnvironment_NewQProcessEnvironment2(PointerFromQProcessEnvironment(other)))
}

func (ptr *QProcessEnvironment) Clear() {
	defer qt.Recovering("QProcessEnvironment::clear")

	if ptr.Pointer() != nil {
		C.QProcessEnvironment_Clear(ptr.Pointer())
	}
}

func (ptr *QProcessEnvironment) Contains(name string) bool {
	defer qt.Recovering("QProcessEnvironment::contains")

	if ptr.Pointer() != nil {
		return C.QProcessEnvironment_Contains(ptr.Pointer(), C.CString(name)) != 0
	}
	return false
}

func (ptr *QProcessEnvironment) IsEmpty() bool {
	defer qt.Recovering("QProcessEnvironment::isEmpty")

	if ptr.Pointer() != nil {
		return C.QProcessEnvironment_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QProcessEnvironment) Keys() []string {
	defer qt.Recovering("QProcessEnvironment::keys")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QProcessEnvironment_Keys(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QProcessEnvironment) Swap(other QProcessEnvironment_ITF) {
	defer qt.Recovering("QProcessEnvironment::swap")

	if ptr.Pointer() != nil {
		C.QProcessEnvironment_Swap(ptr.Pointer(), PointerFromQProcessEnvironment(other))
	}
}

func (ptr *QProcessEnvironment) ToStringList() []string {
	defer qt.Recovering("QProcessEnvironment::toStringList")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QProcessEnvironment_ToStringList(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QProcessEnvironment) Value(name string, defaultValue string) string {
	defer qt.Recovering("QProcessEnvironment::value")

	if ptr.Pointer() != nil {
		return C.GoString(C.QProcessEnvironment_Value(ptr.Pointer(), C.CString(name), C.CString(defaultValue)))
	}
	return ""
}

func (ptr *QProcessEnvironment) DestroyQProcessEnvironment() {
	defer qt.Recovering("QProcessEnvironment::~QProcessEnvironment")

	if ptr.Pointer() != nil {
		C.QProcessEnvironment_DestroyQProcessEnvironment(ptr.Pointer())
	}
}

func QProcessEnvironment_SystemEnvironment() *QProcessEnvironment {
	defer qt.Recovering("QProcessEnvironment::systemEnvironment")

	return NewQProcessEnvironmentFromPointer(C.QProcessEnvironment_QProcessEnvironment_SystemEnvironment())
}

type QPropertyAnimation struct {
	QVariantAnimation
}

type QPropertyAnimation_ITF interface {
	QVariantAnimation_ITF
	QPropertyAnimation_PTR() *QPropertyAnimation
}

func PointerFromQPropertyAnimation(ptr QPropertyAnimation_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPropertyAnimation_PTR().Pointer()
	}
	return nil
}

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

func newQPropertyAnimationFromPointer(ptr unsafe.Pointer) *QPropertyAnimation {
	var n = NewQPropertyAnimationFromPointer(ptr)
	for len(n.ObjectName()) < len("QPropertyAnimation_") {
		n.SetObjectName("QPropertyAnimation_" + qt.Identifier())
	}
	return n
}

func (ptr *QPropertyAnimation) QPropertyAnimation_PTR() *QPropertyAnimation {
	return ptr
}

func (ptr *QPropertyAnimation) PropertyName() string {
	defer qt.Recovering("QPropertyAnimation::propertyName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPropertyAnimation_PropertyName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPropertyAnimation) SetPropertyName(propertyName string) {
	defer qt.Recovering("QPropertyAnimation::setPropertyName")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_SetPropertyName(ptr.Pointer(), C.CString(propertyName))
	}
}

func (ptr *QPropertyAnimation) SetTargetObject(target QObject_ITF) {
	defer qt.Recovering("QPropertyAnimation::setTargetObject")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_SetTargetObject(ptr.Pointer(), PointerFromQObject(target))
	}
}

func (ptr *QPropertyAnimation) TargetObject() *QObject {
	defer qt.Recovering("QPropertyAnimation::targetObject")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QPropertyAnimation_TargetObject(ptr.Pointer()))
	}
	return nil
}

func NewQPropertyAnimation(parent QObject_ITF) *QPropertyAnimation {
	defer qt.Recovering("QPropertyAnimation::QPropertyAnimation")

	return newQPropertyAnimationFromPointer(C.QPropertyAnimation_NewQPropertyAnimation(PointerFromQObject(parent)))
}

func NewQPropertyAnimation2(target QObject_ITF, propertyName string, parent QObject_ITF) *QPropertyAnimation {
	defer qt.Recovering("QPropertyAnimation::QPropertyAnimation")

	return newQPropertyAnimationFromPointer(C.QPropertyAnimation_NewQPropertyAnimation2(PointerFromQObject(target), C.CString(propertyName), PointerFromQObject(parent)))
}

func (ptr *QPropertyAnimation) Event(event QEvent_ITF) bool {
	defer qt.Recovering("QPropertyAnimation::event")

	if ptr.Pointer() != nil {
		return C.QPropertyAnimation_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QPropertyAnimation) ConnectUpdateCurrentValue(f func(value *QVariant)) {
	defer qt.Recovering("connect QPropertyAnimation::updateCurrentValue")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateCurrentValue", f)
	}
}

func (ptr *QPropertyAnimation) DisconnectUpdateCurrentValue() {
	defer qt.Recovering("disconnect QPropertyAnimation::updateCurrentValue")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentValue")
	}
}

//export callbackQPropertyAnimationUpdateCurrentValue
func callbackQPropertyAnimationUpdateCurrentValue(ptr unsafe.Pointer, ptrName *C.char, value unsafe.Pointer) {
	defer qt.Recovering("callback QPropertyAnimation::updateCurrentValue")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentValue"); signal != nil {
		signal.(func(*QVariant))(NewQVariantFromPointer(value))
	} else {
		NewQPropertyAnimationFromPointer(ptr).UpdateCurrentValueDefault(NewQVariantFromPointer(value))
	}
}

func (ptr *QPropertyAnimation) UpdateCurrentValue(value QVariant_ITF) {
	defer qt.Recovering("QPropertyAnimation::updateCurrentValue")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_UpdateCurrentValue(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QPropertyAnimation) UpdateCurrentValueDefault(value QVariant_ITF) {
	defer qt.Recovering("QPropertyAnimation::updateCurrentValue")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_UpdateCurrentValueDefault(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QPropertyAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
	defer qt.Recovering("connect QPropertyAnimation::updateState")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
	}
}

func (ptr *QPropertyAnimation) DisconnectUpdateState() {
	defer qt.Recovering("disconnect QPropertyAnimation::updateState")

	if ptr.Pointer() != nil {

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

//export callbackQPropertyAnimationUpdateState
func callbackQPropertyAnimationUpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
	defer qt.Recovering("callback QPropertyAnimation::updateState")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
		signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	} else {
		NewQPropertyAnimationFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	}
}

func (ptr *QPropertyAnimation) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QPropertyAnimation::updateState")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QPropertyAnimation) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QPropertyAnimation::updateState")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QPropertyAnimation) DestroyQPropertyAnimation() {
	defer qt.Recovering("QPropertyAnimation::~QPropertyAnimation")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_DestroyQPropertyAnimation(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QPropertyAnimation) ConnectUpdateCurrentTime(f func(v int)) {
	defer qt.Recovering("connect QPropertyAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
	}
}

func (ptr *QPropertyAnimation) DisconnectUpdateCurrentTime() {
	defer qt.Recovering("disconnect QPropertyAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {

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

//export callbackQPropertyAnimationUpdateCurrentTime
func callbackQPropertyAnimationUpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, v C.int) {
	defer qt.Recovering("callback QPropertyAnimation::updateCurrentTime")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
		signal.(func(int))(int(v))
	} else {
		NewQPropertyAnimationFromPointer(ptr).UpdateCurrentTimeDefault(int(v))
	}
}

func (ptr *QPropertyAnimation) UpdateCurrentTime(v int) {
	defer qt.Recovering("QPropertyAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QPropertyAnimation) UpdateCurrentTimeDefault(v int) {
	defer qt.Recovering("QPropertyAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QPropertyAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
	defer qt.Recovering("connect QPropertyAnimation::updateDirection")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
	}
}

func (ptr *QPropertyAnimation) DisconnectUpdateDirection() {
	defer qt.Recovering("disconnect QPropertyAnimation::updateDirection")

	if ptr.Pointer() != nil {

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

//export callbackQPropertyAnimationUpdateDirection
func callbackQPropertyAnimationUpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
	defer qt.Recovering("callback QPropertyAnimation::updateDirection")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
	} else {
		NewQPropertyAnimationFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
	}
}

func (ptr *QPropertyAnimation) UpdateDirection(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QPropertyAnimation::updateDirection")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_UpdateDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QPropertyAnimation) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QPropertyAnimation::updateDirection")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QPropertyAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QPropertyAnimation::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QPropertyAnimation) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QPropertyAnimation::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQPropertyAnimationTimerEvent
func callbackQPropertyAnimationTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPropertyAnimation::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQPropertyAnimationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QPropertyAnimation) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QPropertyAnimation::timerEvent")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QPropertyAnimation) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QPropertyAnimation::timerEvent")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QPropertyAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QPropertyAnimation::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QPropertyAnimation) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QPropertyAnimation::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQPropertyAnimationChildEvent
func callbackQPropertyAnimationChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPropertyAnimation::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQPropertyAnimationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QPropertyAnimation) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QPropertyAnimation::childEvent")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QPropertyAnimation) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QPropertyAnimation::childEvent")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QPropertyAnimation) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QPropertyAnimation::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QPropertyAnimation) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QPropertyAnimation::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQPropertyAnimationCustomEvent
func callbackQPropertyAnimationCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPropertyAnimation::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQPropertyAnimationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QPropertyAnimation) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QPropertyAnimation::customEvent")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QPropertyAnimation) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QPropertyAnimation::customEvent")

	if ptr.Pointer() != nil {
		C.QPropertyAnimation_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QQueue struct {
	QList
}

type QQueue_ITF interface {
	QList_ITF
	QQueue_PTR() *QQueue
}

func PointerFromQQueue(ptr QQueue_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQueue_PTR().Pointer()
	}
	return nil
}

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

func newQQueueFromPointer(ptr unsafe.Pointer) *QQueue {
	var n = NewQQueueFromPointer(ptr)
	return n
}

func (ptr *QQueue) QQueue_PTR() *QQueue {
	return ptr
}

type QReadLocker struct {
	ptr unsafe.Pointer
}

type QReadLocker_ITF interface {
	QReadLocker_PTR() *QReadLocker
}

func (p *QReadLocker) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QReadLocker) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQReadLocker(ptr QReadLocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QReadLocker_PTR().Pointer()
	}
	return nil
}

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

func newQReadLockerFromPointer(ptr unsafe.Pointer) *QReadLocker {
	var n = NewQReadLockerFromPointer(ptr)
	return n
}

func (ptr *QReadLocker) QReadLocker_PTR() *QReadLocker {
	return ptr
}

func NewQReadLocker(lock QReadWriteLock_ITF) *QReadLocker {
	defer qt.Recovering("QReadLocker::QReadLocker")

	return newQReadLockerFromPointer(C.QReadLocker_NewQReadLocker(PointerFromQReadWriteLock(lock)))
}

func (ptr *QReadLocker) ReadWriteLock() *QReadWriteLock {
	defer qt.Recovering("QReadLocker::readWriteLock")

	if ptr.Pointer() != nil {
		return NewQReadWriteLockFromPointer(C.QReadLocker_ReadWriteLock(ptr.Pointer()))
	}
	return nil
}

func (ptr *QReadLocker) Relock() {
	defer qt.Recovering("QReadLocker::relock")

	if ptr.Pointer() != nil {
		C.QReadLocker_Relock(ptr.Pointer())
	}
}

func (ptr *QReadLocker) Unlock() {
	defer qt.Recovering("QReadLocker::unlock")

	if ptr.Pointer() != nil {
		C.QReadLocker_Unlock(ptr.Pointer())
	}
}

func (ptr *QReadLocker) DestroyQReadLocker() {
	defer qt.Recovering("QReadLocker::~QReadLocker")

	if ptr.Pointer() != nil {
		C.QReadLocker_DestroyQReadLocker(ptr.Pointer())
	}
}

type QReadWriteLock struct {
	ptr unsafe.Pointer
}

type QReadWriteLock_ITF interface {
	QReadWriteLock_PTR() *QReadWriteLock
}

func (p *QReadWriteLock) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QReadWriteLock) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQReadWriteLock(ptr QReadWriteLock_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QReadWriteLock_PTR().Pointer()
	}
	return nil
}

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

func newQReadWriteLockFromPointer(ptr unsafe.Pointer) *QReadWriteLock {
	var n = NewQReadWriteLockFromPointer(ptr)
	return n
}

func (ptr *QReadWriteLock) QReadWriteLock_PTR() *QReadWriteLock {
	return ptr
}

//QReadWriteLock::RecursionMode
type QReadWriteLock__RecursionMode int64

const (
	QReadWriteLock__NonRecursive = QReadWriteLock__RecursionMode(0)
	QReadWriteLock__Recursive    = QReadWriteLock__RecursionMode(1)
)

func NewQReadWriteLock(recursionMode QReadWriteLock__RecursionMode) *QReadWriteLock {
	defer qt.Recovering("QReadWriteLock::QReadWriteLock")

	return newQReadWriteLockFromPointer(C.QReadWriteLock_NewQReadWriteLock(C.int(recursionMode)))
}

func (ptr *QReadWriteLock) LockForRead() {
	defer qt.Recovering("QReadWriteLock::lockForRead")

	if ptr.Pointer() != nil {
		C.QReadWriteLock_LockForRead(ptr.Pointer())
	}
}

func (ptr *QReadWriteLock) LockForWrite() {
	defer qt.Recovering("QReadWriteLock::lockForWrite")

	if ptr.Pointer() != nil {
		C.QReadWriteLock_LockForWrite(ptr.Pointer())
	}
}

func (ptr *QReadWriteLock) TryLockForRead() bool {
	defer qt.Recovering("QReadWriteLock::tryLockForRead")

	if ptr.Pointer() != nil {
		return C.QReadWriteLock_TryLockForRead(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QReadWriteLock) TryLockForRead2(timeout int) bool {
	defer qt.Recovering("QReadWriteLock::tryLockForRead")

	if ptr.Pointer() != nil {
		return C.QReadWriteLock_TryLockForRead2(ptr.Pointer(), C.int(timeout)) != 0
	}
	return false
}

func (ptr *QReadWriteLock) TryLockForWrite() bool {
	defer qt.Recovering("QReadWriteLock::tryLockForWrite")

	if ptr.Pointer() != nil {
		return C.QReadWriteLock_TryLockForWrite(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QReadWriteLock) TryLockForWrite2(timeout int) bool {
	defer qt.Recovering("QReadWriteLock::tryLockForWrite")

	if ptr.Pointer() != nil {
		return C.QReadWriteLock_TryLockForWrite2(ptr.Pointer(), C.int(timeout)) != 0
	}
	return false
}

func (ptr *QReadWriteLock) Unlock() {
	defer qt.Recovering("QReadWriteLock::unlock")

	if ptr.Pointer() != nil {
		C.QReadWriteLock_Unlock(ptr.Pointer())
	}
}

func (ptr *QReadWriteLock) DestroyQReadWriteLock() {
	defer qt.Recovering("QReadWriteLock::~QReadWriteLock")

	if ptr.Pointer() != nil {
		C.QReadWriteLock_DestroyQReadWriteLock(ptr.Pointer())
	}
}

type QRect struct {
	ptr unsafe.Pointer
}

type QRect_ITF interface {
	QRect_PTR() *QRect
}

func (p *QRect) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QRect) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQRect(ptr QRect_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRect_PTR().Pointer()
	}
	return nil
}

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

func newQRectFromPointer(ptr unsafe.Pointer) *QRect {
	var n = NewQRectFromPointer(ptr)
	return n
}

func (ptr *QRect) QRect_PTR() *QRect {
	return ptr
}

func (ptr *QRect) Contains(point QPoint_ITF, proper bool) bool {
	defer qt.Recovering("QRect::contains")

	if ptr.Pointer() != nil {
		return C.QRect_Contains(ptr.Pointer(), PointerFromQPoint(point), C.int(qt.GoBoolToInt(proper))) != 0
	}
	return false
}

func (ptr *QRect) Contains4(rectangle QRect_ITF, proper bool) bool {
	defer qt.Recovering("QRect::contains")

	if ptr.Pointer() != nil {
		return C.QRect_Contains4(ptr.Pointer(), PointerFromQRect(rectangle), C.int(qt.GoBoolToInt(proper))) != 0
	}
	return false
}

func (ptr *QRect) Intersects(rectangle QRect_ITF) bool {
	defer qt.Recovering("QRect::intersects")

	if ptr.Pointer() != nil {
		return C.QRect_Intersects(ptr.Pointer(), PointerFromQRect(rectangle)) != 0
	}
	return false
}

func NewQRect() *QRect {
	defer qt.Recovering("QRect::QRect")

	return newQRectFromPointer(C.QRect_NewQRect())
}

func NewQRect2(topLeft QPoint_ITF, bottomRight QPoint_ITF) *QRect {
	defer qt.Recovering("QRect::QRect")

	return newQRectFromPointer(C.QRect_NewQRect2(PointerFromQPoint(topLeft), PointerFromQPoint(bottomRight)))
}

func NewQRect3(topLeft QPoint_ITF, size QSize_ITF) *QRect {
	defer qt.Recovering("QRect::QRect")

	return newQRectFromPointer(C.QRect_NewQRect3(PointerFromQPoint(topLeft), PointerFromQSize(size)))
}

func NewQRect4(x int, y int, width int, height int) *QRect {
	defer qt.Recovering("QRect::QRect")

	return newQRectFromPointer(C.QRect_NewQRect4(C.int(x), C.int(y), C.int(width), C.int(height)))
}

func (ptr *QRect) Adjust(dx1 int, dy1 int, dx2 int, dy2 int) {
	defer qt.Recovering("QRect::adjust")

	if ptr.Pointer() != nil {
		C.QRect_Adjust(ptr.Pointer(), C.int(dx1), C.int(dy1), C.int(dx2), C.int(dy2))
	}
}

func (ptr *QRect) Adjusted(dx1 int, dy1 int, dx2 int, dy2 int) *QRect {
	defer qt.Recovering("QRect::adjusted")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRect_Adjusted(ptr.Pointer(), C.int(dx1), C.int(dy1), C.int(dx2), C.int(dy2)))
	}
	return nil
}

func (ptr *QRect) Bottom() int {
	defer qt.Recovering("QRect::bottom")

	if ptr.Pointer() != nil {
		return int(C.QRect_Bottom(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRect) BottomLeft() *QPoint {
	defer qt.Recovering("QRect::bottomLeft")

	if ptr.Pointer() != nil {
		return NewQPointFromPointer(C.QRect_BottomLeft(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRect) BottomRight() *QPoint {
	defer qt.Recovering("QRect::bottomRight")

	if ptr.Pointer() != nil {
		return NewQPointFromPointer(C.QRect_BottomRight(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRect) Center() *QPoint {
	defer qt.Recovering("QRect::center")

	if ptr.Pointer() != nil {
		return NewQPointFromPointer(C.QRect_Center(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRect) Contains3(x int, y int) bool {
	defer qt.Recovering("QRect::contains")

	if ptr.Pointer() != nil {
		return C.QRect_Contains3(ptr.Pointer(), C.int(x), C.int(y)) != 0
	}
	return false
}

func (ptr *QRect) Contains2(x int, y int, proper bool) bool {
	defer qt.Recovering("QRect::contains")

	if ptr.Pointer() != nil {
		return C.QRect_Contains2(ptr.Pointer(), C.int(x), C.int(y), C.int(qt.GoBoolToInt(proper))) != 0
	}
	return false
}

func (ptr *QRect) GetCoords(x1 int, y1 int, x2 int, y2 int) {
	defer qt.Recovering("QRect::getCoords")

	if ptr.Pointer() != nil {
		C.QRect_GetCoords(ptr.Pointer(), C.int(x1), C.int(y1), C.int(x2), C.int(y2))
	}
}

func (ptr *QRect) GetRect(x int, y int, width int, height int) {
	defer qt.Recovering("QRect::getRect")

	if ptr.Pointer() != nil {
		C.QRect_GetRect(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height))
	}
}

func (ptr *QRect) Height() int {
	defer qt.Recovering("QRect::height")

	if ptr.Pointer() != nil {
		return int(C.QRect_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRect) Intersected(rectangle QRect_ITF) *QRect {
	defer qt.Recovering("QRect::intersected")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRect_Intersected(ptr.Pointer(), PointerFromQRect(rectangle)))
	}
	return nil
}

func (ptr *QRect) IsEmpty() bool {
	defer qt.Recovering("QRect::isEmpty")

	if ptr.Pointer() != nil {
		return C.QRect_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRect) IsNull() bool {
	defer qt.Recovering("QRect::isNull")

	if ptr.Pointer() != nil {
		return C.QRect_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRect) IsValid() bool {
	defer qt.Recovering("QRect::isValid")

	if ptr.Pointer() != nil {
		return C.QRect_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRect) Left() int {
	defer qt.Recovering("QRect::left")

	if ptr.Pointer() != nil {
		return int(C.QRect_Left(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRect) MarginsAdded(margins QMargins_ITF) *QRect {
	defer qt.Recovering("QRect::marginsAdded")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRect_MarginsAdded(ptr.Pointer(), PointerFromQMargins(margins)))
	}
	return nil
}

func (ptr *QRect) MarginsRemoved(margins QMargins_ITF) *QRect {
	defer qt.Recovering("QRect::marginsRemoved")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRect_MarginsRemoved(ptr.Pointer(), PointerFromQMargins(margins)))
	}
	return nil
}

func (ptr *QRect) MoveBottom(y int) {
	defer qt.Recovering("QRect::moveBottom")

	if ptr.Pointer() != nil {
		C.QRect_MoveBottom(ptr.Pointer(), C.int(y))
	}
}

func (ptr *QRect) MoveBottomLeft(position QPoint_ITF) {
	defer qt.Recovering("QRect::moveBottomLeft")

	if ptr.Pointer() != nil {
		C.QRect_MoveBottomLeft(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveBottomRight(position QPoint_ITF) {
	defer qt.Recovering("QRect::moveBottomRight")

	if ptr.Pointer() != nil {
		C.QRect_MoveBottomRight(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveCenter(position QPoint_ITF) {
	defer qt.Recovering("QRect::moveCenter")

	if ptr.Pointer() != nil {
		C.QRect_MoveCenter(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveLeft(x int) {
	defer qt.Recovering("QRect::moveLeft")

	if ptr.Pointer() != nil {
		C.QRect_MoveLeft(ptr.Pointer(), C.int(x))
	}
}

func (ptr *QRect) MoveRight(x int) {
	defer qt.Recovering("QRect::moveRight")

	if ptr.Pointer() != nil {
		C.QRect_MoveRight(ptr.Pointer(), C.int(x))
	}
}

func (ptr *QRect) MoveTo2(position QPoint_ITF) {
	defer qt.Recovering("QRect::moveTo")

	if ptr.Pointer() != nil {
		C.QRect_MoveTo2(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveTo(x int, y int) {
	defer qt.Recovering("QRect::moveTo")

	if ptr.Pointer() != nil {
		C.QRect_MoveTo(ptr.Pointer(), C.int(x), C.int(y))
	}
}

func (ptr *QRect) MoveTop(y int) {
	defer qt.Recovering("QRect::moveTop")

	if ptr.Pointer() != nil {
		C.QRect_MoveTop(ptr.Pointer(), C.int(y))
	}
}

func (ptr *QRect) MoveTopLeft(position QPoint_ITF) {
	defer qt.Recovering("QRect::moveTopLeft")

	if ptr.Pointer() != nil {
		C.QRect_MoveTopLeft(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) MoveTopRight(position QPoint_ITF) {
	defer qt.Recovering("QRect::moveTopRight")

	if ptr.Pointer() != nil {
		C.QRect_MoveTopRight(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) Normalized() *QRect {
	defer qt.Recovering("QRect::normalized")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRect_Normalized(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRect) Right() int {
	defer qt.Recovering("QRect::right")

	if ptr.Pointer() != nil {
		return int(C.QRect_Right(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRect) SetBottom(y int) {
	defer qt.Recovering("QRect::setBottom")

	if ptr.Pointer() != nil {
		C.QRect_SetBottom(ptr.Pointer(), C.int(y))
	}
}

func (ptr *QRect) SetBottomLeft(position QPoint_ITF) {
	defer qt.Recovering("QRect::setBottomLeft")

	if ptr.Pointer() != nil {
		C.QRect_SetBottomLeft(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) SetBottomRight(position QPoint_ITF) {
	defer qt.Recovering("QRect::setBottomRight")

	if ptr.Pointer() != nil {
		C.QRect_SetBottomRight(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) SetCoords(x1 int, y1 int, x2 int, y2 int) {
	defer qt.Recovering("QRect::setCoords")

	if ptr.Pointer() != nil {
		C.QRect_SetCoords(ptr.Pointer(), C.int(x1), C.int(y1), C.int(x2), C.int(y2))
	}
}

func (ptr *QRect) SetHeight(height int) {
	defer qt.Recovering("QRect::setHeight")

	if ptr.Pointer() != nil {
		C.QRect_SetHeight(ptr.Pointer(), C.int(height))
	}
}

func (ptr *QRect) SetLeft(x int) {
	defer qt.Recovering("QRect::setLeft")

	if ptr.Pointer() != nil {
		C.QRect_SetLeft(ptr.Pointer(), C.int(x))
	}
}

func (ptr *QRect) SetRect(x int, y int, width int, height int) {
	defer qt.Recovering("QRect::setRect")

	if ptr.Pointer() != nil {
		C.QRect_SetRect(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height))
	}
}

func (ptr *QRect) SetRight(x int) {
	defer qt.Recovering("QRect::setRight")

	if ptr.Pointer() != nil {
		C.QRect_SetRight(ptr.Pointer(), C.int(x))
	}
}

func (ptr *QRect) SetSize(size QSize_ITF) {
	defer qt.Recovering("QRect::setSize")

	if ptr.Pointer() != nil {
		C.QRect_SetSize(ptr.Pointer(), PointerFromQSize(size))
	}
}

func (ptr *QRect) SetTop(y int) {
	defer qt.Recovering("QRect::setTop")

	if ptr.Pointer() != nil {
		C.QRect_SetTop(ptr.Pointer(), C.int(y))
	}
}

func (ptr *QRect) SetTopLeft(position QPoint_ITF) {
	defer qt.Recovering("QRect::setTopLeft")

	if ptr.Pointer() != nil {
		C.QRect_SetTopLeft(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) SetTopRight(position QPoint_ITF) {
	defer qt.Recovering("QRect::setTopRight")

	if ptr.Pointer() != nil {
		C.QRect_SetTopRight(ptr.Pointer(), PointerFromQPoint(position))
	}
}

func (ptr *QRect) SetWidth(width int) {
	defer qt.Recovering("QRect::setWidth")

	if ptr.Pointer() != nil {
		C.QRect_SetWidth(ptr.Pointer(), C.int(width))
	}
}

func (ptr *QRect) SetX(x int) {
	defer qt.Recovering("QRect::setX")

	if ptr.Pointer() != nil {
		C.QRect_SetX(ptr.Pointer(), C.int(x))
	}
}

func (ptr *QRect) SetY(y int) {
	defer qt.Recovering("QRect::setY")

	if ptr.Pointer() != nil {
		C.QRect_SetY(ptr.Pointer(), C.int(y))
	}
}

func (ptr *QRect) Size() *QSize {
	defer qt.Recovering("QRect::size")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QRect_Size(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRect) Top() int {
	defer qt.Recovering("QRect::top")

	if ptr.Pointer() != nil {
		return int(C.QRect_Top(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRect) TopLeft() *QPoint {
	defer qt.Recovering("QRect::topLeft")

	if ptr.Pointer() != nil {
		return NewQPointFromPointer(C.QRect_TopLeft(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRect) TopRight() *QPoint {
	defer qt.Recovering("QRect::topRight")

	if ptr.Pointer() != nil {
		return NewQPointFromPointer(C.QRect_TopRight(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRect) Translate2(offset QPoint_ITF) {
	defer qt.Recovering("QRect::translate")

	if ptr.Pointer() != nil {
		C.QRect_Translate2(ptr.Pointer(), PointerFromQPoint(offset))
	}
}

func (ptr *QRect) Translate(dx int, dy int) {
	defer qt.Recovering("QRect::translate")

	if ptr.Pointer() != nil {
		C.QRect_Translate(ptr.Pointer(), C.int(dx), C.int(dy))
	}
}

func (ptr *QRect) Translated2(offset QPoint_ITF) *QRect {
	defer qt.Recovering("QRect::translated")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRect_Translated2(ptr.Pointer(), PointerFromQPoint(offset)))
	}
	return nil
}

func (ptr *QRect) Translated(dx int, dy int) *QRect {
	defer qt.Recovering("QRect::translated")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRect_Translated(ptr.Pointer(), C.int(dx), C.int(dy)))
	}
	return nil
}

func (ptr *QRect) United(rectangle QRect_ITF) *QRect {
	defer qt.Recovering("QRect::united")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRect_United(ptr.Pointer(), PointerFromQRect(rectangle)))
	}
	return nil
}

func (ptr *QRect) Width() int {
	defer qt.Recovering("QRect::width")

	if ptr.Pointer() != nil {
		return int(C.QRect_Width(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRect) X() int {
	defer qt.Recovering("QRect::x")

	if ptr.Pointer() != nil {
		return int(C.QRect_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRect) Y() int {
	defer qt.Recovering("QRect::y")

	if ptr.Pointer() != nil {
		return int(C.QRect_Y(ptr.Pointer()))
	}
	return 0
}

type QRectF struct {
	ptr unsafe.Pointer
}

type QRectF_ITF interface {
	QRectF_PTR() *QRectF
}

func (p *QRectF) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QRectF) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQRectF(ptr QRectF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRectF_PTR().Pointer()
	}
	return nil
}

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

func newQRectFFromPointer(ptr unsafe.Pointer) *QRectF {
	var n = NewQRectFFromPointer(ptr)
	return n
}

func (ptr *QRectF) QRectF_PTR() *QRectF {
	return ptr
}

func (ptr *QRectF) Contains(point QPointF_ITF) bool {
	defer qt.Recovering("QRectF::contains")

	if ptr.Pointer() != nil {
		return C.QRectF_Contains(ptr.Pointer(), PointerFromQPointF(point)) != 0
	}
	return false
}

func (ptr *QRectF) Contains3(rectangle QRectF_ITF) bool {
	defer qt.Recovering("QRectF::contains")

	if ptr.Pointer() != nil {
		return C.QRectF_Contains3(ptr.Pointer(), PointerFromQRectF(rectangle)) != 0
	}
	return false
}

func (ptr *QRectF) Intersects(rectangle QRectF_ITF) bool {
	defer qt.Recovering("QRectF::intersects")

	if ptr.Pointer() != nil {
		return C.QRectF_Intersects(ptr.Pointer(), PointerFromQRectF(rectangle)) != 0
	}
	return false
}

func (ptr *QRectF) ToAlignedRect() *QRect {
	defer qt.Recovering("QRectF::toAlignedRect")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRectF_ToAlignedRect(ptr.Pointer()))
	}
	return nil
}

func NewQRectF() *QRectF {
	defer qt.Recovering("QRectF::QRectF")

	return newQRectFFromPointer(C.QRectF_NewQRectF())
}

func NewQRectF3(topLeft QPointF_ITF, bottomRight QPointF_ITF) *QRectF {
	defer qt.Recovering("QRectF::QRectF")

	return newQRectFFromPointer(C.QRectF_NewQRectF3(PointerFromQPointF(topLeft), PointerFromQPointF(bottomRight)))
}

func NewQRectF2(topLeft QPointF_ITF, size QSizeF_ITF) *QRectF {
	defer qt.Recovering("QRectF::QRectF")

	return newQRectFFromPointer(C.QRectF_NewQRectF2(PointerFromQPointF(topLeft), PointerFromQSizeF(size)))
}

func NewQRectF5(rectangle QRect_ITF) *QRectF {
	defer qt.Recovering("QRectF::QRectF")

	return newQRectFFromPointer(C.QRectF_NewQRectF5(PointerFromQRect(rectangle)))
}

func NewQRectF4(x float64, y float64, width float64, height float64) *QRectF {
	defer qt.Recovering("QRectF::QRectF")

	return newQRectFFromPointer(C.QRectF_NewQRectF4(C.double(x), C.double(y), C.double(width), C.double(height)))
}

func (ptr *QRectF) Adjust(dx1 float64, dy1 float64, dx2 float64, dy2 float64) {
	defer qt.Recovering("QRectF::adjust")

	if ptr.Pointer() != nil {
		C.QRectF_Adjust(ptr.Pointer(), C.double(dx1), C.double(dy1), C.double(dx2), C.double(dy2))
	}
}

func (ptr *QRectF) Bottom() float64 {
	defer qt.Recovering("QRectF::bottom")

	if ptr.Pointer() != nil {
		return float64(C.QRectF_Bottom(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) Contains2(x float64, y float64) bool {
	defer qt.Recovering("QRectF::contains")

	if ptr.Pointer() != nil {
		return C.QRectF_Contains2(ptr.Pointer(), C.double(x), C.double(y)) != 0
	}
	return false
}

func (ptr *QRectF) Height() float64 {
	defer qt.Recovering("QRectF::height")

	if ptr.Pointer() != nil {
		return float64(C.QRectF_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) IsEmpty() bool {
	defer qt.Recovering("QRectF::isEmpty")

	if ptr.Pointer() != nil {
		return C.QRectF_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRectF) IsNull() bool {
	defer qt.Recovering("QRectF::isNull")

	if ptr.Pointer() != nil {
		return C.QRectF_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRectF) IsValid() bool {
	defer qt.Recovering("QRectF::isValid")

	if ptr.Pointer() != nil {
		return C.QRectF_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRectF) Left() float64 {
	defer qt.Recovering("QRectF::left")

	if ptr.Pointer() != nil {
		return float64(C.QRectF_Left(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) MoveBottom(y float64) {
	defer qt.Recovering("QRectF::moveBottom")

	if ptr.Pointer() != nil {
		C.QRectF_MoveBottom(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) MoveBottomLeft(position QPointF_ITF) {
	defer qt.Recovering("QRectF::moveBottomLeft")

	if ptr.Pointer() != nil {
		C.QRectF_MoveBottomLeft(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveBottomRight(position QPointF_ITF) {
	defer qt.Recovering("QRectF::moveBottomRight")

	if ptr.Pointer() != nil {
		C.QRectF_MoveBottomRight(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveCenter(position QPointF_ITF) {
	defer qt.Recovering("QRectF::moveCenter")

	if ptr.Pointer() != nil {
		C.QRectF_MoveCenter(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveLeft(x float64) {
	defer qt.Recovering("QRectF::moveLeft")

	if ptr.Pointer() != nil {
		C.QRectF_MoveLeft(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) MoveRight(x float64) {
	defer qt.Recovering("QRectF::moveRight")

	if ptr.Pointer() != nil {
		C.QRectF_MoveRight(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) MoveTo2(position QPointF_ITF) {
	defer qt.Recovering("QRectF::moveTo")

	if ptr.Pointer() != nil {
		C.QRectF_MoveTo2(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveTo(x float64, y float64) {
	defer qt.Recovering("QRectF::moveTo")

	if ptr.Pointer() != nil {
		C.QRectF_MoveTo(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QRectF) MoveTop(y float64) {
	defer qt.Recovering("QRectF::moveTop")

	if ptr.Pointer() != nil {
		C.QRectF_MoveTop(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) MoveTopLeft(position QPointF_ITF) {
	defer qt.Recovering("QRectF::moveTopLeft")

	if ptr.Pointer() != nil {
		C.QRectF_MoveTopLeft(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) MoveTopRight(position QPointF_ITF) {
	defer qt.Recovering("QRectF::moveTopRight")

	if ptr.Pointer() != nil {
		C.QRectF_MoveTopRight(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) Right() float64 {
	defer qt.Recovering("QRectF::right")

	if ptr.Pointer() != nil {
		return float64(C.QRectF_Right(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) SetBottom(y float64) {
	defer qt.Recovering("QRectF::setBottom")

	if ptr.Pointer() != nil {
		C.QRectF_SetBottom(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) SetBottomLeft(position QPointF_ITF) {
	defer qt.Recovering("QRectF::setBottomLeft")

	if ptr.Pointer() != nil {
		C.QRectF_SetBottomLeft(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) SetBottomRight(position QPointF_ITF) {
	defer qt.Recovering("QRectF::setBottomRight")

	if ptr.Pointer() != nil {
		C.QRectF_SetBottomRight(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) SetCoords(x1 float64, y1 float64, x2 float64, y2 float64) {
	defer qt.Recovering("QRectF::setCoords")

	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) {
	defer qt.Recovering("QRectF::setHeight")

	if ptr.Pointer() != nil {
		C.QRectF_SetHeight(ptr.Pointer(), C.double(height))
	}
}

func (ptr *QRectF) SetLeft(x float64) {
	defer qt.Recovering("QRectF::setLeft")

	if ptr.Pointer() != nil {
		C.QRectF_SetLeft(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) SetRect(x float64, y float64, width float64, height float64) {
	defer qt.Recovering("QRectF::setRect")

	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) {
	defer qt.Recovering("QRectF::setRight")

	if ptr.Pointer() != nil {
		C.QRectF_SetRight(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) SetSize(size QSizeF_ITF) {
	defer qt.Recovering("QRectF::setSize")

	if ptr.Pointer() != nil {
		C.QRectF_SetSize(ptr.Pointer(), PointerFromQSizeF(size))
	}
}

func (ptr *QRectF) SetTop(y float64) {
	defer qt.Recovering("QRectF::setTop")

	if ptr.Pointer() != nil {
		C.QRectF_SetTop(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) SetTopLeft(position QPointF_ITF) {
	defer qt.Recovering("QRectF::setTopLeft")

	if ptr.Pointer() != nil {
		C.QRectF_SetTopLeft(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) SetTopRight(position QPointF_ITF) {
	defer qt.Recovering("QRectF::setTopRight")

	if ptr.Pointer() != nil {
		C.QRectF_SetTopRight(ptr.Pointer(), PointerFromQPointF(position))
	}
}

func (ptr *QRectF) SetWidth(width float64) {
	defer qt.Recovering("QRectF::setWidth")

	if ptr.Pointer() != nil {
		C.QRectF_SetWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QRectF) SetX(x float64) {
	defer qt.Recovering("QRectF::setX")

	if ptr.Pointer() != nil {
		C.QRectF_SetX(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QRectF) SetY(y float64) {
	defer qt.Recovering("QRectF::setY")

	if ptr.Pointer() != nil {
		C.QRectF_SetY(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QRectF) ToRect() *QRect {
	defer qt.Recovering("QRectF::toRect")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QRectF_ToRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRectF) Top() float64 {
	defer qt.Recovering("QRectF::top")

	if ptr.Pointer() != nil {
		return float64(C.QRectF_Top(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) Translate2(offset QPointF_ITF) {
	defer qt.Recovering("QRectF::translate")

	if ptr.Pointer() != nil {
		C.QRectF_Translate2(ptr.Pointer(), PointerFromQPointF(offset))
	}
}

func (ptr *QRectF) Translate(dx float64, dy float64) {
	defer qt.Recovering("QRectF::translate")

	if ptr.Pointer() != nil {
		C.QRectF_Translate(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

func (ptr *QRectF) Width() float64 {
	defer qt.Recovering("QRectF::width")

	if ptr.Pointer() != nil {
		return float64(C.QRectF_Width(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) X() float64 {
	defer qt.Recovering("QRectF::x")

	if ptr.Pointer() != nil {
		return float64(C.QRectF_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRectF) Y() float64 {
	defer qt.Recovering("QRectF::y")

	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 (p *QRegExp) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QRegExp) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQRegExp(ptr QRegExp_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegExp_PTR().Pointer()
	}
	return nil
}

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

func newQRegExpFromPointer(ptr unsafe.Pointer) *QRegExp {
	var n = NewQRegExpFromPointer(ptr)
	return n
}

func (ptr *QRegExp) QRegExp_PTR() *QRegExp {
	return ptr
}

//QRegExp::CaretMode
type QRegExp__CaretMode int64

const (
	QRegExp__CaretAtZero    = QRegExp__CaretMode(0)
	QRegExp__CaretAtOffset  = QRegExp__CaretMode(1)
	QRegExp__CaretWontMatch = QRegExp__CaretMode(2)
)

//QRegExp::PatternSyntax
type QRegExp__PatternSyntax int64

const (
	QRegExp__RegExp         = QRegExp__PatternSyntax(0)
	QRegExp__Wildcard       = QRegExp__PatternSyntax(1)
	QRegExp__FixedString    = QRegExp__PatternSyntax(2)
	QRegExp__RegExp2        = QRegExp__PatternSyntax(3)
	QRegExp__WildcardUnix   = QRegExp__PatternSyntax(4)
	QRegExp__W3CXmlSchema11 = QRegExp__PatternSyntax(5)
)

func NewQRegExp() *QRegExp {
	defer qt.Recovering("QRegExp::QRegExp")

	return newQRegExpFromPointer(C.QRegExp_NewQRegExp())
}

func NewQRegExp3(rx QRegExp_ITF) *QRegExp {
	defer qt.Recovering("QRegExp::QRegExp")

	return newQRegExpFromPointer(C.QRegExp_NewQRegExp3(PointerFromQRegExp(rx)))
}

func NewQRegExp2(pattern string, cs Qt__CaseSensitivity, syntax QRegExp__PatternSyntax) *QRegExp {
	defer qt.Recovering("QRegExp::QRegExp")

	return newQRegExpFromPointer(C.QRegExp_NewQRegExp2(C.CString(pattern), C.int(cs), C.int(syntax)))
}

func (ptr *QRegExp) Cap(nth int) string {
	defer qt.Recovering("QRegExp::cap")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRegExp_Cap(ptr.Pointer(), C.int(nth)))
	}
	return ""
}

func (ptr *QRegExp) ErrorString() string {
	defer qt.Recovering("QRegExp::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRegExp_ErrorString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QRegExp) CaptureCount() int {
	defer qt.Recovering("QRegExp::captureCount")

	if ptr.Pointer() != nil {
		return int(C.QRegExp_CaptureCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegExp) CapturedTexts() []string {
	defer qt.Recovering("QRegExp::capturedTexts")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QRegExp_CapturedTexts(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QRegExp) CaseSensitivity() Qt__CaseSensitivity {
	defer qt.Recovering("QRegExp::caseSensitivity")

	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QRegExp_CaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func QRegExp_Escape(str string) string {
	defer qt.Recovering("QRegExp::escape")

	return C.GoString(C.QRegExp_QRegExp_Escape(C.CString(str)))
}

func (ptr *QRegExp) ExactMatch(str string) bool {
	defer qt.Recovering("QRegExp::exactMatch")

	if ptr.Pointer() != nil {
		return C.QRegExp_ExactMatch(ptr.Pointer(), C.CString(str)) != 0
	}
	return false
}

func (ptr *QRegExp) IndexIn(str string, offset int, caretMode QRegExp__CaretMode) int {
	defer qt.Recovering("QRegExp::indexIn")

	if ptr.Pointer() != nil {
		return int(C.QRegExp_IndexIn(ptr.Pointer(), C.CString(str), C.int(offset), C.int(caretMode)))
	}
	return 0
}

func (ptr *QRegExp) IsEmpty() bool {
	defer qt.Recovering("QRegExp::isEmpty")

	if ptr.Pointer() != nil {
		return C.QRegExp_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRegExp) IsMinimal() bool {
	defer qt.Recovering("QRegExp::isMinimal")

	if ptr.Pointer() != nil {
		return C.QRegExp_IsMinimal(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRegExp) IsValid() bool {
	defer qt.Recovering("QRegExp::isValid")

	if ptr.Pointer() != nil {
		return C.QRegExp_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRegExp) LastIndexIn(str string, offset int, caretMode QRegExp__CaretMode) int {
	defer qt.Recovering("QRegExp::lastIndexIn")

	if ptr.Pointer() != nil {
		return int(C.QRegExp_LastIndexIn(ptr.Pointer(), C.CString(str), C.int(offset), C.int(caretMode)))
	}
	return 0
}

func (ptr *QRegExp) MatchedLength() int {
	defer qt.Recovering("QRegExp::matchedLength")

	if ptr.Pointer() != nil {
		return int(C.QRegExp_MatchedLength(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegExp) Pattern() string {
	defer qt.Recovering("QRegExp::pattern")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRegExp_Pattern(ptr.Pointer()))
	}
	return ""
}

func (ptr *QRegExp) PatternSyntax() QRegExp__PatternSyntax {
	defer qt.Recovering("QRegExp::patternSyntax")

	if ptr.Pointer() != nil {
		return QRegExp__PatternSyntax(C.QRegExp_PatternSyntax(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegExp) Pos(nth int) int {
	defer qt.Recovering("QRegExp::pos")

	if ptr.Pointer() != nil {
		return int(C.QRegExp_Pos(ptr.Pointer(), C.int(nth)))
	}
	return 0
}

func (ptr *QRegExp) SetCaseSensitivity(cs Qt__CaseSensitivity) {
	defer qt.Recovering("QRegExp::setCaseSensitivity")

	if ptr.Pointer() != nil {
		C.QRegExp_SetCaseSensitivity(ptr.Pointer(), C.int(cs))
	}
}

func (ptr *QRegExp) SetMinimal(minimal bool) {
	defer qt.Recovering("QRegExp::setMinimal")

	if ptr.Pointer() != nil {
		C.QRegExp_SetMinimal(ptr.Pointer(), C.int(qt.GoBoolToInt(minimal)))
	}
}

func (ptr *QRegExp) SetPattern(pattern string) {
	defer qt.Recovering("QRegExp::setPattern")

	if ptr.Pointer() != nil {
		C.QRegExp_SetPattern(ptr.Pointer(), C.CString(pattern))
	}
}

func (ptr *QRegExp) SetPatternSyntax(syntax QRegExp__PatternSyntax) {
	defer qt.Recovering("QRegExp::setPatternSyntax")

	if ptr.Pointer() != nil {
		C.QRegExp_SetPatternSyntax(ptr.Pointer(), C.int(syntax))
	}
}

func (ptr *QRegExp) Swap(other QRegExp_ITF) {
	defer qt.Recovering("QRegExp::swap")

	if ptr.Pointer() != nil {
		C.QRegExp_Swap(ptr.Pointer(), PointerFromQRegExp(other))
	}
}

func (ptr *QRegExp) DestroyQRegExp() {
	defer qt.Recovering("QRegExp::~QRegExp")

	if ptr.Pointer() != nil {
		C.QRegExp_DestroyQRegExp(ptr.Pointer())
	}
}

type QRegularExpression struct {
	ptr unsafe.Pointer
}

type QRegularExpression_ITF interface {
	QRegularExpression_PTR() *QRegularExpression
}

func (p *QRegularExpression) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QRegularExpression) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQRegularExpression(ptr QRegularExpression_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegularExpression_PTR().Pointer()
	}
	return nil
}

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

func newQRegularExpressionFromPointer(ptr unsafe.Pointer) *QRegularExpression {
	var n = NewQRegularExpressionFromPointer(ptr)
	return n
}

func (ptr *QRegularExpression) QRegularExpression_PTR() *QRegularExpression {
	return ptr
}

//QRegularExpression::MatchOption
type QRegularExpression__MatchOption int64

const (
	QRegularExpression__NoMatchOption                     = QRegularExpression__MatchOption(0x0000)
	QRegularExpression__AnchoredMatchOption               = QRegularExpression__MatchOption(0x0001)
	QRegularExpression__DontCheckSubjectStringMatchOption = QRegularExpression__MatchOption(0x0002)
)

//QRegularExpression::MatchType
type QRegularExpression__MatchType int64

const (
	QRegularExpression__NormalMatch                = QRegularExpression__MatchType(0)
	QRegularExpression__PartialPreferCompleteMatch = QRegularExpression__MatchType(1)
	QRegularExpression__PartialPreferFirstMatch    = QRegularExpression__MatchType(2)
	QRegularExpression__NoMatch                    = QRegularExpression__MatchType(3)
)

//QRegularExpression::PatternOption
type QRegularExpression__PatternOption int64

const (
	QRegularExpression__NoPatternOption                 = QRegularExpression__PatternOption(0x0000)
	QRegularExpression__CaseInsensitiveOption           = QRegularExpression__PatternOption(0x0001)
	QRegularExpression__DotMatchesEverythingOption      = QRegularExpression__PatternOption(0x0002)
	QRegularExpression__MultilineOption                 = QRegularExpression__PatternOption(0x0004)
	QRegularExpression__ExtendedPatternSyntaxOption     = QRegularExpression__PatternOption(0x0008)
	QRegularExpression__InvertedGreedinessOption        = QRegularExpression__PatternOption(0x0010)
	QRegularExpression__DontCaptureOption               = QRegularExpression__PatternOption(0x0020)
	QRegularExpression__UseUnicodePropertiesOption      = QRegularExpression__PatternOption(0x0040)
	QRegularExpression__OptimizeOnFirstUsageOption      = QRegularExpression__PatternOption(0x0080)
	QRegularExpression__DontAutomaticallyOptimizeOption = QRegularExpression__PatternOption(0x0100)
)

func NewQRegularExpression() *QRegularExpression {
	defer qt.Recovering("QRegularExpression::QRegularExpression")

	return newQRegularExpressionFromPointer(C.QRegularExpression_NewQRegularExpression())
}

func NewQRegularExpression3(re QRegularExpression_ITF) *QRegularExpression {
	defer qt.Recovering("QRegularExpression::QRegularExpression")

	return newQRegularExpressionFromPointer(C.QRegularExpression_NewQRegularExpression3(PointerFromQRegularExpression(re)))
}

func NewQRegularExpression2(pattern string, options QRegularExpression__PatternOption) *QRegularExpression {
	defer qt.Recovering("QRegularExpression::QRegularExpression")

	return newQRegularExpressionFromPointer(C.QRegularExpression_NewQRegularExpression2(C.CString(pattern), C.int(options)))
}

func (ptr *QRegularExpression) CaptureCount() int {
	defer qt.Recovering("QRegularExpression::captureCount")

	if ptr.Pointer() != nil {
		return int(C.QRegularExpression_CaptureCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegularExpression) ErrorString() string {
	defer qt.Recovering("QRegularExpression::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRegularExpression_ErrorString(ptr.Pointer()))
	}
	return ""
}

func QRegularExpression_Escape(str string) string {
	defer qt.Recovering("QRegularExpression::escape")

	return C.GoString(C.QRegularExpression_QRegularExpression_Escape(C.CString(str)))
}

func (ptr *QRegularExpression) GlobalMatch(subject string, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatchIterator {
	defer qt.Recovering("QRegularExpression::globalMatch")

	if ptr.Pointer() != nil {
		return NewQRegularExpressionMatchIteratorFromPointer(C.QRegularExpression_GlobalMatch(ptr.Pointer(), C.CString(subject), C.int(offset), C.int(matchType), C.int(matchOptions)))
	}
	return nil
}

func (ptr *QRegularExpression) GlobalMatch2(subjectRef QStringRef_ITF, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatchIterator {
	defer qt.Recovering("QRegularExpression::globalMatch")

	if ptr.Pointer() != nil {
		return NewQRegularExpressionMatchIteratorFromPointer(C.QRegularExpression_GlobalMatch2(ptr.Pointer(), PointerFromQStringRef(subjectRef), C.int(offset), C.int(matchType), C.int(matchOptions)))
	}
	return nil
}

func (ptr *QRegularExpression) IsValid() bool {
	defer qt.Recovering("QRegularExpression::isValid")

	if ptr.Pointer() != nil {
		return C.QRegularExpression_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRegularExpression) Match(subject string, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatch {
	defer qt.Recovering("QRegularExpression::match")

	if ptr.Pointer() != nil {
		return NewQRegularExpressionMatchFromPointer(C.QRegularExpression_Match(ptr.Pointer(), C.CString(subject), C.int(offset), C.int(matchType), C.int(matchOptions)))
	}
	return nil
}

func (ptr *QRegularExpression) Match2(subjectRef QStringRef_ITF, offset int, matchType QRegularExpression__MatchType, matchOptions QRegularExpression__MatchOption) *QRegularExpressionMatch {
	defer qt.Recovering("QRegularExpression::match")

	if ptr.Pointer() != nil {
		return NewQRegularExpressionMatchFromPointer(C.QRegularExpression_Match2(ptr.Pointer(), PointerFromQStringRef(subjectRef), C.int(offset), C.int(matchType), C.int(matchOptions)))
	}
	return nil
}

func (ptr *QRegularExpression) NamedCaptureGroups() []string {
	defer qt.Recovering("QRegularExpression::namedCaptureGroups")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QRegularExpression_NamedCaptureGroups(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QRegularExpression) Optimize() {
	defer qt.Recovering("QRegularExpression::optimize")

	if ptr.Pointer() != nil {
		C.QRegularExpression_Optimize(ptr.Pointer())
	}
}

func (ptr *QRegularExpression) Pattern() string {
	defer qt.Recovering("QRegularExpression::pattern")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRegularExpression_Pattern(ptr.Pointer()))
	}
	return ""
}

func (ptr *QRegularExpression) PatternErrorOffset() int {
	defer qt.Recovering("QRegularExpression::patternErrorOffset")

	if ptr.Pointer() != nil {
		return int(C.QRegularExpression_PatternErrorOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegularExpression) PatternOptions() QRegularExpression__PatternOption {
	defer qt.Recovering("QRegularExpression::patternOptions")

	if ptr.Pointer() != nil {
		return QRegularExpression__PatternOption(C.QRegularExpression_PatternOptions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegularExpression) SetPattern(pattern string) {
	defer qt.Recovering("QRegularExpression::setPattern")

	if ptr.Pointer() != nil {
		C.QRegularExpression_SetPattern(ptr.Pointer(), C.CString(pattern))
	}
}

func (ptr *QRegularExpression) SetPatternOptions(options QRegularExpression__PatternOption) {
	defer qt.Recovering("QRegularExpression::setPatternOptions")

	if ptr.Pointer() != nil {
		C.QRegularExpression_SetPatternOptions(ptr.Pointer(), C.int(options))
	}
}

func (ptr *QRegularExpression) Swap(other QRegularExpression_ITF) {
	defer qt.Recovering("QRegularExpression::swap")

	if ptr.Pointer() != nil {
		C.QRegularExpression_Swap(ptr.Pointer(), PointerFromQRegularExpression(other))
	}
}

func (ptr *QRegularExpression) DestroyQRegularExpression() {
	defer qt.Recovering("QRegularExpression::~QRegularExpression")

	if ptr.Pointer() != nil {
		C.QRegularExpression_DestroyQRegularExpression(ptr.Pointer())
	}
}

type QRegularExpressionMatch struct {
	ptr unsafe.Pointer
}

type QRegularExpressionMatch_ITF interface {
	QRegularExpressionMatch_PTR() *QRegularExpressionMatch
}

func (p *QRegularExpressionMatch) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QRegularExpressionMatch) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQRegularExpressionMatch(ptr QRegularExpressionMatch_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegularExpressionMatch_PTR().Pointer()
	}
	return nil
}

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

func newQRegularExpressionMatchFromPointer(ptr unsafe.Pointer) *QRegularExpressionMatch {
	var n = NewQRegularExpressionMatchFromPointer(ptr)
	return n
}

func (ptr *QRegularExpressionMatch) QRegularExpressionMatch_PTR() *QRegularExpressionMatch {
	return ptr
}

func NewQRegularExpressionMatch() *QRegularExpressionMatch {
	defer qt.Recovering("QRegularExpressionMatch::QRegularExpressionMatch")

	return newQRegularExpressionMatchFromPointer(C.QRegularExpressionMatch_NewQRegularExpressionMatch())
}

func NewQRegularExpressionMatch2(match QRegularExpressionMatch_ITF) *QRegularExpressionMatch {
	defer qt.Recovering("QRegularExpressionMatch::QRegularExpressionMatch")

	return newQRegularExpressionMatchFromPointer(C.QRegularExpressionMatch_NewQRegularExpressionMatch2(PointerFromQRegularExpressionMatch(match)))
}

func (ptr *QRegularExpressionMatch) Captured2(name string) string {
	defer qt.Recovering("QRegularExpressionMatch::captured")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRegularExpressionMatch_Captured2(ptr.Pointer(), C.CString(name)))
	}
	return ""
}

func (ptr *QRegularExpressionMatch) Captured(nth int) string {
	defer qt.Recovering("QRegularExpressionMatch::captured")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRegularExpressionMatch_Captured(ptr.Pointer(), C.int(nth)))
	}
	return ""
}

func (ptr *QRegularExpressionMatch) CapturedEnd2(name string) int {
	defer qt.Recovering("QRegularExpressionMatch::capturedEnd")

	if ptr.Pointer() != nil {
		return int(C.QRegularExpressionMatch_CapturedEnd2(ptr.Pointer(), C.CString(name)))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedEnd(nth int) int {
	defer qt.Recovering("QRegularExpressionMatch::capturedEnd")

	if ptr.Pointer() != nil {
		return int(C.QRegularExpressionMatch_CapturedEnd(ptr.Pointer(), C.int(nth)))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedLength2(name string) int {
	defer qt.Recovering("QRegularExpressionMatch::capturedLength")

	if ptr.Pointer() != nil {
		return int(C.QRegularExpressionMatch_CapturedLength2(ptr.Pointer(), C.CString(name)))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedLength(nth int) int {
	defer qt.Recovering("QRegularExpressionMatch::capturedLength")

	if ptr.Pointer() != nil {
		return int(C.QRegularExpressionMatch_CapturedLength(ptr.Pointer(), C.int(nth)))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedRef2(name string) *QStringRef {
	defer qt.Recovering("QRegularExpressionMatch::capturedRef")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QRegularExpressionMatch_CapturedRef2(ptr.Pointer(), C.CString(name)))
	}
	return nil
}

func (ptr *QRegularExpressionMatch) CapturedRef(nth int) *QStringRef {
	defer qt.Recovering("QRegularExpressionMatch::capturedRef")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QRegularExpressionMatch_CapturedRef(ptr.Pointer(), C.int(nth)))
	}
	return nil
}

func (ptr *QRegularExpressionMatch) CapturedStart2(name string) int {
	defer qt.Recovering("QRegularExpressionMatch::capturedStart")

	if ptr.Pointer() != nil {
		return int(C.QRegularExpressionMatch_CapturedStart2(ptr.Pointer(), C.CString(name)))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedStart(nth int) int {
	defer qt.Recovering("QRegularExpressionMatch::capturedStart")

	if ptr.Pointer() != nil {
		return int(C.QRegularExpressionMatch_CapturedStart(ptr.Pointer(), C.int(nth)))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) CapturedTexts() []string {
	defer qt.Recovering("QRegularExpressionMatch::capturedTexts")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QRegularExpressionMatch_CapturedTexts(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QRegularExpressionMatch) HasMatch() bool {
	defer qt.Recovering("QRegularExpressionMatch::hasMatch")

	if ptr.Pointer() != nil {
		return C.QRegularExpressionMatch_HasMatch(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRegularExpressionMatch) HasPartialMatch() bool {
	defer qt.Recovering("QRegularExpressionMatch::hasPartialMatch")

	if ptr.Pointer() != nil {
		return C.QRegularExpressionMatch_HasPartialMatch(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRegularExpressionMatch) IsValid() bool {
	defer qt.Recovering("QRegularExpressionMatch::isValid")

	if ptr.Pointer() != nil {
		return C.QRegularExpressionMatch_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRegularExpressionMatch) LastCapturedIndex() int {
	defer qt.Recovering("QRegularExpressionMatch::lastCapturedIndex")

	if ptr.Pointer() != nil {
		return int(C.QRegularExpressionMatch_LastCapturedIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) MatchOptions() QRegularExpression__MatchOption {
	defer qt.Recovering("QRegularExpressionMatch::matchOptions")

	if ptr.Pointer() != nil {
		return QRegularExpression__MatchOption(C.QRegularExpressionMatch_MatchOptions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) MatchType() QRegularExpression__MatchType {
	defer qt.Recovering("QRegularExpressionMatch::matchType")

	if ptr.Pointer() != nil {
		return QRegularExpression__MatchType(C.QRegularExpressionMatch_MatchType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegularExpressionMatch) RegularExpression() *QRegularExpression {
	defer qt.Recovering("QRegularExpressionMatch::regularExpression")

	if ptr.Pointer() != nil {
		return NewQRegularExpressionFromPointer(C.QRegularExpressionMatch_RegularExpression(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRegularExpressionMatch) Swap(other QRegularExpressionMatch_ITF) {
	defer qt.Recovering("QRegularExpressionMatch::swap")

	if ptr.Pointer() != nil {
		C.QRegularExpressionMatch_Swap(ptr.Pointer(), PointerFromQRegularExpressionMatch(other))
	}
}

func (ptr *QRegularExpressionMatch) DestroyQRegularExpressionMatch() {
	defer qt.Recovering("QRegularExpressionMatch::~QRegularExpressionMatch")

	if ptr.Pointer() != nil {
		C.QRegularExpressionMatch_DestroyQRegularExpressionMatch(ptr.Pointer())
	}
}

type QRegularExpressionMatchIterator struct {
	ptr unsafe.Pointer
}

type QRegularExpressionMatchIterator_ITF interface {
	QRegularExpressionMatchIterator_PTR() *QRegularExpressionMatchIterator
}

func (p *QRegularExpressionMatchIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QRegularExpressionMatchIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQRegularExpressionMatchIterator(ptr QRegularExpressionMatchIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegularExpressionMatchIterator_PTR().Pointer()
	}
	return nil
}

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

func newQRegularExpressionMatchIteratorFromPointer(ptr unsafe.Pointer) *QRegularExpressionMatchIterator {
	var n = NewQRegularExpressionMatchIteratorFromPointer(ptr)
	return n
}

func (ptr *QRegularExpressionMatchIterator) QRegularExpressionMatchIterator_PTR() *QRegularExpressionMatchIterator {
	return ptr
}

type QResource struct {
	ptr unsafe.Pointer
}

type QResource_ITF interface {
	QResource_PTR() *QResource
}

func (p *QResource) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QResource) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQResource(ptr QResource_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QResource_PTR().Pointer()
	}
	return nil
}

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

func newQResourceFromPointer(ptr unsafe.Pointer) *QResource {
	var n = NewQResourceFromPointer(ptr)
	return n
}

func (ptr *QResource) QResource_PTR() *QResource {
	return ptr
}

func QResource_RegisterResource(rccFileName string, mapRoot string) bool {
	defer qt.Recovering("QResource::registerResource")

	return C.QResource_QResource_RegisterResource(C.CString(rccFileName), C.CString(mapRoot)) != 0
}

func QResource_UnregisterResource(rccFileName string, mapRoot string) bool {
	defer qt.Recovering("QResource::unregisterResource")

	return C.QResource_QResource_UnregisterResource(C.CString(rccFileName), C.CString(mapRoot)) != 0
}

func NewQResource(file string, locale QLocale_ITF) *QResource {
	defer qt.Recovering("QResource::QResource")

	return newQResourceFromPointer(C.QResource_NewQResource(C.CString(file), PointerFromQLocale(locale)))
}

func (ptr *QResource) AbsoluteFilePath() string {
	defer qt.Recovering("QResource::absoluteFilePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QResource_AbsoluteFilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QResource) FileName() string {
	defer qt.Recovering("QResource::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QResource_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QResource) IsCompressed() bool {
	defer qt.Recovering("QResource::isCompressed")

	if ptr.Pointer() != nil {
		return C.QResource_IsCompressed(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QResource) IsValid() bool {
	defer qt.Recovering("QResource::isValid")

	if ptr.Pointer() != nil {
		return C.QResource_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QResource) Locale() *QLocale {
	defer qt.Recovering("QResource::locale")

	if ptr.Pointer() != nil {
		return NewQLocaleFromPointer(C.QResource_Locale(ptr.Pointer()))
	}
	return nil
}

func (ptr *QResource) SetFileName(file string) {
	defer qt.Recovering("QResource::setFileName")

	if ptr.Pointer() != nil {
		C.QResource_SetFileName(ptr.Pointer(), C.CString(file))
	}
}

func (ptr *QResource) SetLocale(locale QLocale_ITF) {
	defer qt.Recovering("QResource::setLocale")

	if ptr.Pointer() != nil {
		C.QResource_SetLocale(ptr.Pointer(), PointerFromQLocale(locale))
	}
}

func (ptr *QResource) Size() int64 {
	defer qt.Recovering("QResource::size")

	if ptr.Pointer() != nil {
		return int64(C.QResource_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QResource) DestroyQResource() {
	defer qt.Recovering("QResource::~QResource")

	if ptr.Pointer() != nil {
		C.QResource_DestroyQResource(ptr.Pointer())
	}
}

type QRunnable struct {
	ptr unsafe.Pointer
}

type QRunnable_ITF interface {
	QRunnable_PTR() *QRunnable
}

func (p *QRunnable) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QRunnable) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQRunnable(ptr QRunnable_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRunnable_PTR().Pointer()
	}
	return nil
}

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

func newQRunnableFromPointer(ptr unsafe.Pointer) *QRunnable {
	var n = NewQRunnableFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QRunnable_") {
		n.SetObjectNameAbs("QRunnable_" + qt.Identifier())
	}
	return n
}

func (ptr *QRunnable) QRunnable_PTR() *QRunnable {
	return ptr
}

func (ptr *QRunnable) AutoDelete() bool {
	defer qt.Recovering("QRunnable::autoDelete")

	if ptr.Pointer() != nil {
		return C.QRunnable_AutoDelete(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRunnable) Run() {
	defer qt.Recovering("QRunnable::run")

	if ptr.Pointer() != nil {
		C.QRunnable_Run(ptr.Pointer())
	}
}

func (ptr *QRunnable) SetAutoDelete(autoDelete bool) {
	defer qt.Recovering("QRunnable::setAutoDelete")

	if ptr.Pointer() != nil {
		C.QRunnable_SetAutoDelete(ptr.Pointer(), C.int(qt.GoBoolToInt(autoDelete)))
	}
}

func (ptr *QRunnable) DestroyQRunnable() {
	defer qt.Recovering("QRunnable::~QRunnable")

	if ptr.Pointer() != nil {
		C.QRunnable_DestroyQRunnable(ptr.Pointer())
	}
}

func (ptr *QRunnable) ObjectNameAbs() string {
	defer qt.Recovering("QRunnable::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRunnable_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QRunnable) SetObjectNameAbs(name string) {
	defer qt.Recovering("QRunnable::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QRunnable_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QSaveFile struct {
	QFileDevice
}

type QSaveFile_ITF interface {
	QFileDevice_ITF
	QSaveFile_PTR() *QSaveFile
}

func PointerFromQSaveFile(ptr QSaveFile_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSaveFile_PTR().Pointer()
	}
	return nil
}

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

func newQSaveFileFromPointer(ptr unsafe.Pointer) *QSaveFile {
	var n = NewQSaveFileFromPointer(ptr)
	for len(n.ObjectName()) < len("QSaveFile_") {
		n.SetObjectName("QSaveFile_" + qt.Identifier())
	}
	return n
}

func (ptr *QSaveFile) QSaveFile_PTR() *QSaveFile {
	return ptr
}

func NewQSaveFile2(parent QObject_ITF) *QSaveFile {
	defer qt.Recovering("QSaveFile::QSaveFile")

	return newQSaveFileFromPointer(C.QSaveFile_NewQSaveFile2(PointerFromQObject(parent)))
}

func NewQSaveFile(name string) *QSaveFile {
	defer qt.Recovering("QSaveFile::QSaveFile")

	return newQSaveFileFromPointer(C.QSaveFile_NewQSaveFile(C.CString(name)))
}

func NewQSaveFile3(name string, parent QObject_ITF) *QSaveFile {
	defer qt.Recovering("QSaveFile::QSaveFile")

	return newQSaveFileFromPointer(C.QSaveFile_NewQSaveFile3(C.CString(name), PointerFromQObject(parent)))
}

func (ptr *QSaveFile) CancelWriting() {
	defer qt.Recovering("QSaveFile::cancelWriting")

	if ptr.Pointer() != nil {
		C.QSaveFile_CancelWriting(ptr.Pointer())
	}
}

func (ptr *QSaveFile) Commit() bool {
	defer qt.Recovering("QSaveFile::commit")

	if ptr.Pointer() != nil {
		return C.QSaveFile_Commit(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSaveFile) DirectWriteFallback() bool {
	defer qt.Recovering("QSaveFile::directWriteFallback")

	if ptr.Pointer() != nil {
		return C.QSaveFile_DirectWriteFallback(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSaveFile) FileName() string {
	defer qt.Recovering("QSaveFile::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSaveFile_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSaveFile) Open(mode QIODevice__OpenModeFlag) bool {
	defer qt.Recovering("QSaveFile::open")

	if ptr.Pointer() != nil {
		return C.QSaveFile_Open(ptr.Pointer(), C.int(mode)) != 0
	}
	return false
}

func (ptr *QSaveFile) SetDirectWriteFallback(enabled bool) {
	defer qt.Recovering("QSaveFile::setDirectWriteFallback")

	if ptr.Pointer() != nil {
		C.QSaveFile_SetDirectWriteFallback(ptr.Pointer(), C.int(qt.GoBoolToInt(enabled)))
	}
}

func (ptr *QSaveFile) SetFileName(name string) {
	defer qt.Recovering("QSaveFile::setFileName")

	if ptr.Pointer() != nil {
		C.QSaveFile_SetFileName(ptr.Pointer(), C.CString(name))
	}
}

func (ptr *QSaveFile) WriteData(data string, len int64) int64 {
	defer qt.Recovering("QSaveFile::writeData")

	if ptr.Pointer() != nil {
		return int64(C.QSaveFile_WriteData(ptr.Pointer(), C.CString(data), C.longlong(len)))
	}
	return 0
}

func (ptr *QSaveFile) DestroyQSaveFile() {
	defer qt.Recovering("QSaveFile::~QSaveFile")

	if ptr.Pointer() != nil {
		C.QSaveFile_DestroyQSaveFile(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSaveFile) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QSaveFile::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSaveFile) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSaveFile::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSaveFileTimerEvent
func callbackQSaveFileTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSaveFile::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQSaveFileFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSaveFile) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QSaveFile::timerEvent")

	if ptr.Pointer() != nil {
		C.QSaveFile_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSaveFile) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QSaveFile::timerEvent")

	if ptr.Pointer() != nil {
		C.QSaveFile_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSaveFile) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QSaveFile::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSaveFile) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSaveFile::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSaveFileChildEvent
func callbackQSaveFileChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSaveFile::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQSaveFileFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QSaveFile) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QSaveFile::childEvent")

	if ptr.Pointer() != nil {
		C.QSaveFile_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSaveFile) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QSaveFile::childEvent")

	if ptr.Pointer() != nil {
		C.QSaveFile_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSaveFile) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QSaveFile::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSaveFile) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSaveFile::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSaveFileCustomEvent
func callbackQSaveFileCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSaveFile::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQSaveFileFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSaveFile) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QSaveFile::customEvent")

	if ptr.Pointer() != nil {
		C.QSaveFile_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSaveFile) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QSaveFile::customEvent")

	if ptr.Pointer() != nil {
		C.QSaveFile_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QScopedArrayPointer struct {
	QScopedPointer
}

type QScopedArrayPointer_ITF interface {
	QScopedPointer_ITF
	QScopedArrayPointer_PTR() *QScopedArrayPointer
}

func PointerFromQScopedArrayPointer(ptr QScopedArrayPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedArrayPointer_PTR().Pointer()
	}
	return nil
}

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

func newQScopedArrayPointerFromPointer(ptr unsafe.Pointer) *QScopedArrayPointer {
	var n = NewQScopedArrayPointerFromPointer(ptr)
	return n
}

func (ptr *QScopedArrayPointer) QScopedArrayPointer_PTR() *QScopedArrayPointer {
	return ptr
}

type QScopedPointer struct {
	ptr unsafe.Pointer
}

type QScopedPointer_ITF interface {
	QScopedPointer_PTR() *QScopedPointer
}

func (p *QScopedPointer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QScopedPointer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQScopedPointer(ptr QScopedPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedPointer_PTR().Pointer()
	}
	return nil
}

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

func newQScopedPointerFromPointer(ptr unsafe.Pointer) *QScopedPointer {
	var n = NewQScopedPointerFromPointer(ptr)
	return n
}

func (ptr *QScopedPointer) QScopedPointer_PTR() *QScopedPointer {
	return ptr
}

type QScopedValueRollback struct {
	ptr unsafe.Pointer
}

type QScopedValueRollback_ITF interface {
	QScopedValueRollback_PTR() *QScopedValueRollback
}

func (p *QScopedValueRollback) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QScopedValueRollback) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQScopedValueRollback(ptr QScopedValueRollback_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScopedValueRollback_PTR().Pointer()
	}
	return nil
}

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

func newQScopedValueRollbackFromPointer(ptr unsafe.Pointer) *QScopedValueRollback {
	var n = NewQScopedValueRollbackFromPointer(ptr)
	return n
}

func (ptr *QScopedValueRollback) QScopedValueRollback_PTR() *QScopedValueRollback {
	return ptr
}

type QSemaphore struct {
	ptr unsafe.Pointer
}

type QSemaphore_ITF interface {
	QSemaphore_PTR() *QSemaphore
}

func (p *QSemaphore) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSemaphore) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSemaphore(ptr QSemaphore_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSemaphore_PTR().Pointer()
	}
	return nil
}

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

func newQSemaphoreFromPointer(ptr unsafe.Pointer) *QSemaphore {
	var n = NewQSemaphoreFromPointer(ptr)
	return n
}

func (ptr *QSemaphore) QSemaphore_PTR() *QSemaphore {
	return ptr
}

func NewQSemaphore(n int) *QSemaphore {
	defer qt.Recovering("QSemaphore::QSemaphore")

	return newQSemaphoreFromPointer(C.QSemaphore_NewQSemaphore(C.int(n)))
}

func (ptr *QSemaphore) Acquire(n int) {
	defer qt.Recovering("QSemaphore::acquire")

	if ptr.Pointer() != nil {
		C.QSemaphore_Acquire(ptr.Pointer(), C.int(n))
	}
}

func (ptr *QSemaphore) Available() int {
	defer qt.Recovering("QSemaphore::available")

	if ptr.Pointer() != nil {
		return int(C.QSemaphore_Available(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSemaphore) Release(n int) {
	defer qt.Recovering("QSemaphore::release")

	if ptr.Pointer() != nil {
		C.QSemaphore_Release(ptr.Pointer(), C.int(n))
	}
}

func (ptr *QSemaphore) TryAcquire(n int) bool {
	defer qt.Recovering("QSemaphore::tryAcquire")

	if ptr.Pointer() != nil {
		return C.QSemaphore_TryAcquire(ptr.Pointer(), C.int(n)) != 0
	}
	return false
}

func (ptr *QSemaphore) TryAcquire2(n int, timeout int) bool {
	defer qt.Recovering("QSemaphore::tryAcquire")

	if ptr.Pointer() != nil {
		return C.QSemaphore_TryAcquire2(ptr.Pointer(), C.int(n), C.int(timeout)) != 0
	}
	return false
}

func (ptr *QSemaphore) DestroyQSemaphore() {
	defer qt.Recovering("QSemaphore::~QSemaphore")

	if ptr.Pointer() != nil {
		C.QSemaphore_DestroyQSemaphore(ptr.Pointer())
	}
}

type QSequentialAnimationGroup struct {
	QAnimationGroup
}

type QSequentialAnimationGroup_ITF interface {
	QAnimationGroup_ITF
	QSequentialAnimationGroup_PTR() *QSequentialAnimationGroup
}

func PointerFromQSequentialAnimationGroup(ptr QSequentialAnimationGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSequentialAnimationGroup_PTR().Pointer()
	}
	return nil
}

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

func newQSequentialAnimationGroupFromPointer(ptr unsafe.Pointer) *QSequentialAnimationGroup {
	var n = NewQSequentialAnimationGroupFromPointer(ptr)
	for len(n.ObjectName()) < len("QSequentialAnimationGroup_") {
		n.SetObjectName("QSequentialAnimationGroup_" + qt.Identifier())
	}
	return n
}

func (ptr *QSequentialAnimationGroup) QSequentialAnimationGroup_PTR() *QSequentialAnimationGroup {
	return ptr
}

func (ptr *QSequentialAnimationGroup) CurrentAnimation() *QAbstractAnimation {
	defer qt.Recovering("QSequentialAnimationGroup::currentAnimation")

	if ptr.Pointer() != nil {
		return NewQAbstractAnimationFromPointer(C.QSequentialAnimationGroup_CurrentAnimation(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSequentialAnimationGroup) AddPause(msecs int) *QPauseAnimation {
	defer qt.Recovering("QSequentialAnimationGroup::addPause")

	if ptr.Pointer() != nil {
		return NewQPauseAnimationFromPointer(C.QSequentialAnimationGroup_AddPause(ptr.Pointer(), C.int(msecs)))
	}
	return nil
}

func (ptr *QSequentialAnimationGroup) ConnectCurrentAnimationChanged(f func(current *QAbstractAnimation)) {
	defer qt.Recovering("connect QSequentialAnimationGroup::currentAnimationChanged")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_ConnectCurrentAnimationChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "currentAnimationChanged", f)
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectCurrentAnimationChanged() {
	defer qt.Recovering("disconnect QSequentialAnimationGroup::currentAnimationChanged")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_DisconnectCurrentAnimationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "currentAnimationChanged")
	}
}

//export callbackQSequentialAnimationGroupCurrentAnimationChanged
func callbackQSequentialAnimationGroupCurrentAnimationChanged(ptr unsafe.Pointer, ptrName *C.char, current unsafe.Pointer) {
	defer qt.Recovering("callback QSequentialAnimationGroup::currentAnimationChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "currentAnimationChanged"); signal != nil {
		signal.(func(*QAbstractAnimation))(NewQAbstractAnimationFromPointer(current))
	}

}

func (ptr *QSequentialAnimationGroup) CurrentAnimationChanged(current QAbstractAnimation_ITF) {
	defer qt.Recovering("QSequentialAnimationGroup::currentAnimationChanged")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_CurrentAnimationChanged(ptr.Pointer(), PointerFromQAbstractAnimation(current))
	}
}

func (ptr *QSequentialAnimationGroup) Duration() int {
	defer qt.Recovering("QSequentialAnimationGroup::duration")

	if ptr.Pointer() != nil {
		return int(C.QSequentialAnimationGroup_Duration(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSequentialAnimationGroup) Event(event QEvent_ITF) bool {
	defer qt.Recovering("QSequentialAnimationGroup::event")

	if ptr.Pointer() != nil {
		return C.QSequentialAnimationGroup_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QSequentialAnimationGroup) InsertPause(index int, msecs int) *QPauseAnimation {
	defer qt.Recovering("QSequentialAnimationGroup::insertPause")

	if ptr.Pointer() != nil {
		return NewQPauseAnimationFromPointer(C.QSequentialAnimationGroup_InsertPause(ptr.Pointer(), C.int(index), C.int(msecs)))
	}
	return nil
}

func (ptr *QSequentialAnimationGroup) ConnectUpdateCurrentTime(f func(currentTime int)) {
	defer qt.Recovering("connect QSequentialAnimationGroup::updateCurrentTime")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectUpdateCurrentTime() {
	defer qt.Recovering("disconnect QSequentialAnimationGroup::updateCurrentTime")

	if ptr.Pointer() != nil {

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

//export callbackQSequentialAnimationGroupUpdateCurrentTime
func callbackQSequentialAnimationGroupUpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, currentTime C.int) {
	defer qt.Recovering("callback QSequentialAnimationGroup::updateCurrentTime")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
		signal.(func(int))(int(currentTime))
	} else {
		NewQSequentialAnimationGroupFromPointer(ptr).UpdateCurrentTimeDefault(int(currentTime))
	}
}

func (ptr *QSequentialAnimationGroup) UpdateCurrentTime(currentTime int) {
	defer qt.Recovering("QSequentialAnimationGroup::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_UpdateCurrentTime(ptr.Pointer(), C.int(currentTime))
	}
}

func (ptr *QSequentialAnimationGroup) UpdateCurrentTimeDefault(currentTime int) {
	defer qt.Recovering("QSequentialAnimationGroup::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(currentTime))
	}
}

func (ptr *QSequentialAnimationGroup) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
	defer qt.Recovering("connect QSequentialAnimationGroup::updateDirection")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectUpdateDirection() {
	defer qt.Recovering("disconnect QSequentialAnimationGroup::updateDirection")

	if ptr.Pointer() != nil {

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

//export callbackQSequentialAnimationGroupUpdateDirection
func callbackQSequentialAnimationGroupUpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
	defer qt.Recovering("callback QSequentialAnimationGroup::updateDirection")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
	} else {
		NewQSequentialAnimationGroupFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
	}
}

func (ptr *QSequentialAnimationGroup) UpdateDirection(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QSequentialAnimationGroup::updateDirection")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_UpdateDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QSequentialAnimationGroup) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QSequentialAnimationGroup::updateDirection")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QSequentialAnimationGroup) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
	defer qt.Recovering("connect QSequentialAnimationGroup::updateState")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectUpdateState() {
	defer qt.Recovering("disconnect QSequentialAnimationGroup::updateState")

	if ptr.Pointer() != nil {

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

//export callbackQSequentialAnimationGroupUpdateState
func callbackQSequentialAnimationGroupUpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
	defer qt.Recovering("callback QSequentialAnimationGroup::updateState")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
		signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	} else {
		NewQSequentialAnimationGroupFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	}
}

func (ptr *QSequentialAnimationGroup) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QSequentialAnimationGroup::updateState")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QSequentialAnimationGroup) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QSequentialAnimationGroup::updateState")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QSequentialAnimationGroup) DestroyQSequentialAnimationGroup() {
	defer qt.Recovering("QSequentialAnimationGroup::~QSequentialAnimationGroup")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_DestroyQSequentialAnimationGroup(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSequentialAnimationGroup) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QSequentialAnimationGroup::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSequentialAnimationGroup::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSequentialAnimationGroupTimerEvent
func callbackQSequentialAnimationGroupTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSequentialAnimationGroup::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQSequentialAnimationGroupFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSequentialAnimationGroup) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QSequentialAnimationGroup::timerEvent")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSequentialAnimationGroup) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QSequentialAnimationGroup::timerEvent")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSequentialAnimationGroup) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QSequentialAnimationGroup::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSequentialAnimationGroup::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSequentialAnimationGroupChildEvent
func callbackQSequentialAnimationGroupChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSequentialAnimationGroup::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQSequentialAnimationGroupFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QSequentialAnimationGroup) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QSequentialAnimationGroup::childEvent")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSequentialAnimationGroup) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QSequentialAnimationGroup::childEvent")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSequentialAnimationGroup) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QSequentialAnimationGroup::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSequentialAnimationGroup) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSequentialAnimationGroup::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSequentialAnimationGroupCustomEvent
func callbackQSequentialAnimationGroupCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSequentialAnimationGroup::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQSequentialAnimationGroupFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSequentialAnimationGroup) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QSequentialAnimationGroup::customEvent")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSequentialAnimationGroup) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QSequentialAnimationGroup::customEvent")

	if ptr.Pointer() != nil {
		C.QSequentialAnimationGroup_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QSequentialIterable struct {
	ptr unsafe.Pointer
}

type QSequentialIterable_ITF interface {
	QSequentialIterable_PTR() *QSequentialIterable
}

func (p *QSequentialIterable) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSequentialIterable) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSequentialIterable(ptr QSequentialIterable_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSequentialIterable_PTR().Pointer()
	}
	return nil
}

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

func newQSequentialIterableFromPointer(ptr unsafe.Pointer) *QSequentialIterable {
	var n = NewQSequentialIterableFromPointer(ptr)
	return n
}

func (ptr *QSequentialIterable) QSequentialIterable_PTR() *QSequentialIterable {
	return ptr
}

func (ptr *QSequentialIterable) At(idx int) *QVariant {
	defer qt.Recovering("QSequentialIterable::at")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QSequentialIterable_At(ptr.Pointer(), C.int(idx)))
	}
	return nil
}

func (ptr *QSequentialIterable) CanReverseIterate() bool {
	defer qt.Recovering("QSequentialIterable::canReverseIterate")

	if ptr.Pointer() != nil {
		return C.QSequentialIterable_CanReverseIterate(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSequentialIterable) Size() int {
	defer qt.Recovering("QSequentialIterable::size")

	if ptr.Pointer() != nil {
		return int(C.QSequentialIterable_Size(ptr.Pointer()))
	}
	return 0
}

type QSet struct {
	ptr unsafe.Pointer
}

type QSet_ITF interface {
	QSet_PTR() *QSet
}

func (p *QSet) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSet) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSet(ptr QSet_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSet_PTR().Pointer()
	}
	return nil
}

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

func newQSetFromPointer(ptr unsafe.Pointer) *QSet {
	var n = NewQSetFromPointer(ptr)
	return n
}

func (ptr *QSet) QSet_PTR() *QSet {
	return ptr
}

type QSetIterator struct {
	ptr unsafe.Pointer
}

type QSetIterator_ITF interface {
	QSetIterator_PTR() *QSetIterator
}

func (p *QSetIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSetIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSetIterator(ptr QSetIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSetIterator_PTR().Pointer()
	}
	return nil
}

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

func newQSetIteratorFromPointer(ptr unsafe.Pointer) *QSetIterator {
	var n = NewQSetIteratorFromPointer(ptr)
	return n
}

func (ptr *QSetIterator) QSetIterator_PTR() *QSetIterator {
	return ptr
}

type QSettings struct {
	QObject
}

type QSettings_ITF interface {
	QObject_ITF
	QSettings_PTR() *QSettings
}

func PointerFromQSettings(ptr QSettings_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSettings_PTR().Pointer()
	}
	return nil
}

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

func newQSettingsFromPointer(ptr unsafe.Pointer) *QSettings {
	var n = NewQSettingsFromPointer(ptr)
	for len(n.ObjectName()) < len("QSettings_") {
		n.SetObjectName("QSettings_" + qt.Identifier())
	}
	return n
}

func (ptr *QSettings) QSettings_PTR() *QSettings {
	return ptr
}

//QSettings::Format
type QSettings__Format int64

const (
	QSettings__NativeFormat   = QSettings__Format(0)
	QSettings__IniFormat      = QSettings__Format(1)
	QSettings__InvalidFormat  = QSettings__Format(16)
	QSettings__CustomFormat1  = QSettings__Format(17)
	QSettings__CustomFormat2  = QSettings__Format(18)
	QSettings__CustomFormat3  = QSettings__Format(19)
	QSettings__CustomFormat4  = QSettings__Format(20)
	QSettings__CustomFormat5  = QSettings__Format(21)
	QSettings__CustomFormat6  = QSettings__Format(22)
	QSettings__CustomFormat7  = QSettings__Format(23)
	QSettings__CustomFormat8  = QSettings__Format(24)
	QSettings__CustomFormat9  = QSettings__Format(25)
	QSettings__CustomFormat10 = QSettings__Format(26)
	QSettings__CustomFormat11 = QSettings__Format(27)
	QSettings__CustomFormat12 = QSettings__Format(28)
	QSettings__CustomFormat13 = QSettings__Format(29)
	QSettings__CustomFormat14 = QSettings__Format(30)
	QSettings__CustomFormat15 = QSettings__Format(31)
	QSettings__CustomFormat16 = QSettings__Format(32)
)

//QSettings::Scope
type QSettings__Scope int64

const (
	QSettings__UserScope   = QSettings__Scope(0)
	QSettings__SystemScope = QSettings__Scope(1)
)

//QSettings::Status
type QSettings__Status int64

const (
	QSettings__NoError     = QSettings__Status(0)
	QSettings__AccessError = QSettings__Status(1)
	QSettings__FormatError = QSettings__Status(2)
)

func NewQSettings3(format QSettings__Format, scope QSettings__Scope, organization string, application string, parent QObject_ITF) *QSettings {
	defer qt.Recovering("QSettings::QSettings")

	return newQSettingsFromPointer(C.QSettings_NewQSettings3(C.int(format), C.int(scope), C.CString(organization), C.CString(application), PointerFromQObject(parent)))
}

func NewQSettings5(parent QObject_ITF) *QSettings {
	defer qt.Recovering("QSettings::QSettings")

	return newQSettingsFromPointer(C.QSettings_NewQSettings5(PointerFromQObject(parent)))
}

func NewQSettings2(scope QSettings__Scope, organization string, application string, parent QObject_ITF) *QSettings {
	defer qt.Recovering("QSettings::QSettings")

	return newQSettingsFromPointer(C.QSettings_NewQSettings2(C.int(scope), C.CString(organization), C.CString(application), PointerFromQObject(parent)))
}

func NewQSettings4(fileName string, format QSettings__Format, parent QObject_ITF) *QSettings {
	defer qt.Recovering("QSettings::QSettings")

	return newQSettingsFromPointer(C.QSettings_NewQSettings4(C.CString(fileName), C.int(format), PointerFromQObject(parent)))
}

func NewQSettings(organization string, application string, parent QObject_ITF) *QSettings {
	defer qt.Recovering("QSettings::QSettings")

	return newQSettingsFromPointer(C.QSettings_NewQSettings(C.CString(organization), C.CString(application), PointerFromQObject(parent)))
}

func (ptr *QSettings) AllKeys() []string {
	defer qt.Recovering("QSettings::allKeys")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QSettings_AllKeys(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QSettings) ApplicationName() string {
	defer qt.Recovering("QSettings::applicationName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSettings_ApplicationName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSettings) BeginGroup(prefix string) {
	defer qt.Recovering("QSettings::beginGroup")

	if ptr.Pointer() != nil {
		C.QSettings_BeginGroup(ptr.Pointer(), C.CString(prefix))
	}
}

func (ptr *QSettings) BeginReadArray(prefix string) int {
	defer qt.Recovering("QSettings::beginReadArray")

	if ptr.Pointer() != nil {
		return int(C.QSettings_BeginReadArray(ptr.Pointer(), C.CString(prefix)))
	}
	return 0
}

func (ptr *QSettings) BeginWriteArray(prefix string, size int) {
	defer qt.Recovering("QSettings::beginWriteArray")

	if ptr.Pointer() != nil {
		C.QSettings_BeginWriteArray(ptr.Pointer(), C.CString(prefix), C.int(size))
	}
}

func (ptr *QSettings) ChildGroups() []string {
	defer qt.Recovering("QSettings::childGroups")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QSettings_ChildGroups(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QSettings) ChildKeys() []string {
	defer qt.Recovering("QSettings::childKeys")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QSettings_ChildKeys(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QSettings) Clear() {
	defer qt.Recovering("QSettings::clear")

	if ptr.Pointer() != nil {
		C.QSettings_Clear(ptr.Pointer())
	}
}

func (ptr *QSettings) Contains(key string) bool {
	defer qt.Recovering("QSettings::contains")

	if ptr.Pointer() != nil {
		return C.QSettings_Contains(ptr.Pointer(), C.CString(key)) != 0
	}
	return false
}

func QSettings_DefaultFormat() QSettings__Format {
	defer qt.Recovering("QSettings::defaultFormat")

	return QSettings__Format(C.QSettings_QSettings_DefaultFormat())
}

func (ptr *QSettings) EndArray() {
	defer qt.Recovering("QSettings::endArray")

	if ptr.Pointer() != nil {
		C.QSettings_EndArray(ptr.Pointer())
	}
}

func (ptr *QSettings) EndGroup() {
	defer qt.Recovering("QSettings::endGroup")

	if ptr.Pointer() != nil {
		C.QSettings_EndGroup(ptr.Pointer())
	}
}

func (ptr *QSettings) Event(event QEvent_ITF) bool {
	defer qt.Recovering("QSettings::event")

	if ptr.Pointer() != nil {
		return C.QSettings_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QSettings) FallbacksEnabled() bool {
	defer qt.Recovering("QSettings::fallbacksEnabled")

	if ptr.Pointer() != nil {
		return C.QSettings_FallbacksEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSettings) FileName() string {
	defer qt.Recovering("QSettings::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSettings_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSettings) Format() QSettings__Format {
	defer qt.Recovering("QSettings::format")

	if ptr.Pointer() != nil {
		return QSettings__Format(C.QSettings_Format(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSettings) Group() string {
	defer qt.Recovering("QSettings::group")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSettings_Group(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSettings) IniCodec() *QTextCodec {
	defer qt.Recovering("QSettings::iniCodec")

	if ptr.Pointer() != nil {
		return NewQTextCodecFromPointer(C.QSettings_IniCodec(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSettings) IsWritable() bool {
	defer qt.Recovering("QSettings::isWritable")

	if ptr.Pointer() != nil {
		return C.QSettings_IsWritable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSettings) OrganizationName() string {
	defer qt.Recovering("QSettings::organizationName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSettings_OrganizationName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSettings) Scope() QSettings__Scope {
	defer qt.Recovering("QSettings::scope")

	if ptr.Pointer() != nil {
		return QSettings__Scope(C.QSettings_Scope(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSettings) SetArrayIndex(i int) {
	defer qt.Recovering("QSettings::setArrayIndex")

	if ptr.Pointer() != nil {
		C.QSettings_SetArrayIndex(ptr.Pointer(), C.int(i))
	}
}

func QSettings_SetDefaultFormat(format QSettings__Format) {
	defer qt.Recovering("QSettings::setDefaultFormat")

	C.QSettings_QSettings_SetDefaultFormat(C.int(format))
}

func (ptr *QSettings) SetFallbacksEnabled(b bool) {
	defer qt.Recovering("QSettings::setFallbacksEnabled")

	if ptr.Pointer() != nil {
		C.QSettings_SetFallbacksEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
	}
}

func (ptr *QSettings) SetIniCodec(codec QTextCodec_ITF) {
	defer qt.Recovering("QSettings::setIniCodec")

	if ptr.Pointer() != nil {
		C.QSettings_SetIniCodec(ptr.Pointer(), PointerFromQTextCodec(codec))
	}
}

func (ptr *QSettings) SetIniCodec2(codecName string) {
	defer qt.Recovering("QSettings::setIniCodec")

	if ptr.Pointer() != nil {
		C.QSettings_SetIniCodec2(ptr.Pointer(), C.CString(codecName))
	}
}

func QSettings_SetPath(format QSettings__Format, scope QSettings__Scope, path string) {
	defer qt.Recovering("QSettings::setPath")

	C.QSettings_QSettings_SetPath(C.int(format), C.int(scope), C.CString(path))
}

func (ptr *QSettings) SetValue(key string, value QVariant_ITF) {
	defer qt.Recovering("QSettings::setValue")

	if ptr.Pointer() != nil {
		C.QSettings_SetValue(ptr.Pointer(), C.CString(key), PointerFromQVariant(value))
	}
}

func (ptr *QSettings) Status() QSettings__Status {
	defer qt.Recovering("QSettings::status")

	if ptr.Pointer() != nil {
		return QSettings__Status(C.QSettings_Status(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSettings) Sync() {
	defer qt.Recovering("QSettings::sync")

	if ptr.Pointer() != nil {
		C.QSettings_Sync(ptr.Pointer())
	}
}

func (ptr *QSettings) Value(key string, defaultValue QVariant_ITF) *QVariant {
	defer qt.Recovering("QSettings::value")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QSettings_Value(ptr.Pointer(), C.CString(key), PointerFromQVariant(defaultValue)))
	}
	return nil
}

func (ptr *QSettings) DestroyQSettings() {
	defer qt.Recovering("QSettings::~QSettings")

	if ptr.Pointer() != nil {
		C.QSettings_DestroyQSettings(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSettings) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QSettings::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSettings) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSettings::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSettingsTimerEvent
func callbackQSettingsTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSettings::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQSettingsFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSettings) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QSettings::timerEvent")

	if ptr.Pointer() != nil {
		C.QSettings_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSettings) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QSettings::timerEvent")

	if ptr.Pointer() != nil {
		C.QSettings_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSettings) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QSettings::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSettings) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSettings::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSettingsChildEvent
func callbackQSettingsChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSettings::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQSettingsFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QSettings) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QSettings::childEvent")

	if ptr.Pointer() != nil {
		C.QSettings_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSettings) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QSettings::childEvent")

	if ptr.Pointer() != nil {
		C.QSettings_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSettings) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QSettings::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSettings) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSettings::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSettingsCustomEvent
func callbackQSettingsCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSettings::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQSettingsFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSettings) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QSettings::customEvent")

	if ptr.Pointer() != nil {
		C.QSettings_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSettings) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QSettings::customEvent")

	if ptr.Pointer() != nil {
		C.QSettings_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QSharedData struct {
	ptr unsafe.Pointer
}

type QSharedData_ITF interface {
	QSharedData_PTR() *QSharedData
}

func (p *QSharedData) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSharedData) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSharedData(ptr QSharedData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSharedData_PTR().Pointer()
	}
	return nil
}

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

func newQSharedDataFromPointer(ptr unsafe.Pointer) *QSharedData {
	var n = NewQSharedDataFromPointer(ptr)
	return n
}

func (ptr *QSharedData) QSharedData_PTR() *QSharedData {
	return ptr
}

func NewQSharedData() *QSharedData {
	defer qt.Recovering("QSharedData::QSharedData")

	return newQSharedDataFromPointer(C.QSharedData_NewQSharedData())
}

func NewQSharedData2(other QSharedData_ITF) *QSharedData {
	defer qt.Recovering("QSharedData::QSharedData")

	return newQSharedDataFromPointer(C.QSharedData_NewQSharedData2(PointerFromQSharedData(other)))
}

type QSharedDataPointer struct {
	ptr unsafe.Pointer
}

type QSharedDataPointer_ITF interface {
	QSharedDataPointer_PTR() *QSharedDataPointer
}

func (p *QSharedDataPointer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSharedDataPointer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSharedDataPointer(ptr QSharedDataPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSharedDataPointer_PTR().Pointer()
	}
	return nil
}

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

func newQSharedDataPointerFromPointer(ptr unsafe.Pointer) *QSharedDataPointer {
	var n = NewQSharedDataPointerFromPointer(ptr)
	return n
}

func (ptr *QSharedDataPointer) QSharedDataPointer_PTR() *QSharedDataPointer {
	return ptr
}

type QSharedMemory struct {
	QObject
}

type QSharedMemory_ITF interface {
	QObject_ITF
	QSharedMemory_PTR() *QSharedMemory
}

func PointerFromQSharedMemory(ptr QSharedMemory_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSharedMemory_PTR().Pointer()
	}
	return nil
}

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

func newQSharedMemoryFromPointer(ptr unsafe.Pointer) *QSharedMemory {
	var n = NewQSharedMemoryFromPointer(ptr)
	for len(n.ObjectName()) < len("QSharedMemory_") {
		n.SetObjectName("QSharedMemory_" + qt.Identifier())
	}
	return n
}

func (ptr *QSharedMemory) QSharedMemory_PTR() *QSharedMemory {
	return ptr
}

//QSharedMemory::AccessMode
type QSharedMemory__AccessMode int64

const (
	QSharedMemory__ReadOnly  = QSharedMemory__AccessMode(0)
	QSharedMemory__ReadWrite = QSharedMemory__AccessMode(1)
)

//QSharedMemory::SharedMemoryError
type QSharedMemory__SharedMemoryError int64

const (
	QSharedMemory__NoError          = QSharedMemory__SharedMemoryError(0)
	QSharedMemory__PermissionDenied = QSharedMemory__SharedMemoryError(1)
	QSharedMemory__InvalidSize      = QSharedMemory__SharedMemoryError(2)
	QSharedMemory__KeyError         = QSharedMemory__SharedMemoryError(3)
	QSharedMemory__AlreadyExists    = QSharedMemory__SharedMemoryError(4)
	QSharedMemory__NotFound         = QSharedMemory__SharedMemoryError(5)
	QSharedMemory__LockError        = QSharedMemory__SharedMemoryError(6)
	QSharedMemory__OutOfResources   = QSharedMemory__SharedMemoryError(7)
	QSharedMemory__UnknownError     = QSharedMemory__SharedMemoryError(8)
)

func NewQSharedMemory2(parent QObject_ITF) *QSharedMemory {
	defer qt.Recovering("QSharedMemory::QSharedMemory")

	return newQSharedMemoryFromPointer(C.QSharedMemory_NewQSharedMemory2(PointerFromQObject(parent)))
}

func NewQSharedMemory(key string, parent QObject_ITF) *QSharedMemory {
	defer qt.Recovering("QSharedMemory::QSharedMemory")

	return newQSharedMemoryFromPointer(C.QSharedMemory_NewQSharedMemory(C.CString(key), PointerFromQObject(parent)))
}

func (ptr *QSharedMemory) Attach(mode QSharedMemory__AccessMode) bool {
	defer qt.Recovering("QSharedMemory::attach")

	if ptr.Pointer() != nil {
		return C.QSharedMemory_Attach(ptr.Pointer(), C.int(mode)) != 0
	}
	return false
}

func (ptr *QSharedMemory) ConstData() unsafe.Pointer {
	defer qt.Recovering("QSharedMemory::constData")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QSharedMemory_ConstData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSharedMemory) Create(size int, mode QSharedMemory__AccessMode) bool {
	defer qt.Recovering("QSharedMemory::create")

	if ptr.Pointer() != nil {
		return C.QSharedMemory_Create(ptr.Pointer(), C.int(size), C.int(mode)) != 0
	}
	return false
}

func (ptr *QSharedMemory) Data() unsafe.Pointer {
	defer qt.Recovering("QSharedMemory::data")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QSharedMemory_Data(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSharedMemory) Data2() unsafe.Pointer {
	defer qt.Recovering("QSharedMemory::data")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QSharedMemory_Data2(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSharedMemory) Detach() bool {
	defer qt.Recovering("QSharedMemory::detach")

	if ptr.Pointer() != nil {
		return C.QSharedMemory_Detach(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSharedMemory) Error() QSharedMemory__SharedMemoryError {
	defer qt.Recovering("QSharedMemory::error")

	if ptr.Pointer() != nil {
		return QSharedMemory__SharedMemoryError(C.QSharedMemory_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSharedMemory) ErrorString() string {
	defer qt.Recovering("QSharedMemory::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSharedMemory_ErrorString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSharedMemory) IsAttached() bool {
	defer qt.Recovering("QSharedMemory::isAttached")

	if ptr.Pointer() != nil {
		return C.QSharedMemory_IsAttached(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSharedMemory) Key() string {
	defer qt.Recovering("QSharedMemory::key")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSharedMemory_Key(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSharedMemory) Lock() bool {
	defer qt.Recovering("QSharedMemory::lock")

	if ptr.Pointer() != nil {
		return C.QSharedMemory_Lock(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSharedMemory) NativeKey() string {
	defer qt.Recovering("QSharedMemory::nativeKey")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSharedMemory_NativeKey(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSharedMemory) SetKey(key string) {
	defer qt.Recovering("QSharedMemory::setKey")

	if ptr.Pointer() != nil {
		C.QSharedMemory_SetKey(ptr.Pointer(), C.CString(key))
	}
}

func (ptr *QSharedMemory) SetNativeKey(key string) {
	defer qt.Recovering("QSharedMemory::setNativeKey")

	if ptr.Pointer() != nil {
		C.QSharedMemory_SetNativeKey(ptr.Pointer(), C.CString(key))
	}
}

func (ptr *QSharedMemory) Size() int {
	defer qt.Recovering("QSharedMemory::size")

	if ptr.Pointer() != nil {
		return int(C.QSharedMemory_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSharedMemory) Unlock() bool {
	defer qt.Recovering("QSharedMemory::unlock")

	if ptr.Pointer() != nil {
		return C.QSharedMemory_Unlock(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSharedMemory) DestroyQSharedMemory() {
	defer qt.Recovering("QSharedMemory::~QSharedMemory")

	if ptr.Pointer() != nil {
		C.QSharedMemory_DestroyQSharedMemory(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSharedMemory) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QSharedMemory::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSharedMemory) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSharedMemory::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSharedMemoryTimerEvent
func callbackQSharedMemoryTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSharedMemory::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQSharedMemoryFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSharedMemory) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QSharedMemory::timerEvent")

	if ptr.Pointer() != nil {
		C.QSharedMemory_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSharedMemory) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QSharedMemory::timerEvent")

	if ptr.Pointer() != nil {
		C.QSharedMemory_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSharedMemory) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QSharedMemory::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSharedMemory) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSharedMemory::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSharedMemoryChildEvent
func callbackQSharedMemoryChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSharedMemory::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQSharedMemoryFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QSharedMemory) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QSharedMemory::childEvent")

	if ptr.Pointer() != nil {
		C.QSharedMemory_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSharedMemory) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QSharedMemory::childEvent")

	if ptr.Pointer() != nil {
		C.QSharedMemory_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSharedMemory) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QSharedMemory::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSharedMemory) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSharedMemory::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSharedMemoryCustomEvent
func callbackQSharedMemoryCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSharedMemory::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQSharedMemoryFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSharedMemory) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QSharedMemory::customEvent")

	if ptr.Pointer() != nil {
		C.QSharedMemory_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSharedMemory) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QSharedMemory::customEvent")

	if ptr.Pointer() != nil {
		C.QSharedMemory_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QSharedPointer struct {
	ptr unsafe.Pointer
}

type QSharedPointer_ITF interface {
	QSharedPointer_PTR() *QSharedPointer
}

func (p *QSharedPointer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSharedPointer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSharedPointer(ptr QSharedPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSharedPointer_PTR().Pointer()
	}
	return nil
}

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

func newQSharedPointerFromPointer(ptr unsafe.Pointer) *QSharedPointer {
	var n = NewQSharedPointerFromPointer(ptr)
	return n
}

func (ptr *QSharedPointer) QSharedPointer_PTR() *QSharedPointer {
	return ptr
}

type QSignalBlocker struct {
	ptr unsafe.Pointer
}

type QSignalBlocker_ITF interface {
	QSignalBlocker_PTR() *QSignalBlocker
}

func (p *QSignalBlocker) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSignalBlocker) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSignalBlocker(ptr QSignalBlocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSignalBlocker_PTR().Pointer()
	}
	return nil
}

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

func newQSignalBlockerFromPointer(ptr unsafe.Pointer) *QSignalBlocker {
	var n = NewQSignalBlockerFromPointer(ptr)
	return n
}

func (ptr *QSignalBlocker) QSignalBlocker_PTR() *QSignalBlocker {
	return ptr
}

func (ptr *QSignalBlocker) Reblock() {
	defer qt.Recovering("QSignalBlocker::reblock")

	if ptr.Pointer() != nil {
		C.QSignalBlocker_Reblock(ptr.Pointer())
	}
}

func (ptr *QSignalBlocker) Unblock() {
	defer qt.Recovering("QSignalBlocker::unblock")

	if ptr.Pointer() != nil {
		C.QSignalBlocker_Unblock(ptr.Pointer())
	}
}

func (ptr *QSignalBlocker) DestroyQSignalBlocker() {
	defer qt.Recovering("QSignalBlocker::~QSignalBlocker")

	if ptr.Pointer() != nil {
		C.QSignalBlocker_DestroyQSignalBlocker(ptr.Pointer())
	}
}

type QSignalMapper struct {
	QObject
}

type QSignalMapper_ITF interface {
	QObject_ITF
	QSignalMapper_PTR() *QSignalMapper
}

func PointerFromQSignalMapper(ptr QSignalMapper_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSignalMapper_PTR().Pointer()
	}
	return nil
}

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

func newQSignalMapperFromPointer(ptr unsafe.Pointer) *QSignalMapper {
	var n = NewQSignalMapperFromPointer(ptr)
	for len(n.ObjectName()) < len("QSignalMapper_") {
		n.SetObjectName("QSignalMapper_" + qt.Identifier())
	}
	return n
}

func (ptr *QSignalMapper) QSignalMapper_PTR() *QSignalMapper {
	return ptr
}

func NewQSignalMapper(parent QObject_ITF) *QSignalMapper {
	defer qt.Recovering("QSignalMapper::QSignalMapper")

	return newQSignalMapperFromPointer(C.QSignalMapper_NewQSignalMapper(PointerFromQObject(parent)))
}

func (ptr *QSignalMapper) Map() {
	defer qt.Recovering("QSignalMapper::map")

	if ptr.Pointer() != nil {
		C.QSignalMapper_Map(ptr.Pointer())
	}
}

func (ptr *QSignalMapper) Map2(sender QObject_ITF) {
	defer qt.Recovering("QSignalMapper::map")

	if ptr.Pointer() != nil {
		C.QSignalMapper_Map2(ptr.Pointer(), PointerFromQObject(sender))
	}
}

func (ptr *QSignalMapper) ConnectMapped4(f func(object *QObject)) {
	defer qt.Recovering("connect QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_ConnectMapped4(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "mapped4", f)
	}
}

func (ptr *QSignalMapper) DisconnectMapped4() {
	defer qt.Recovering("disconnect QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_DisconnectMapped4(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "mapped4")
	}
}

//export callbackQSignalMapperMapped4
func callbackQSignalMapperMapped4(ptr unsafe.Pointer, ptrName *C.char, object unsafe.Pointer) {
	defer qt.Recovering("callback QSignalMapper::mapped")

	if signal := qt.GetSignal(C.GoString(ptrName), "mapped4"); signal != nil {
		signal.(func(*QObject))(NewQObjectFromPointer(object))
	}

}

func (ptr *QSignalMapper) Mapped4(object QObject_ITF) {
	defer qt.Recovering("QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_Mapped4(ptr.Pointer(), PointerFromQObject(object))
	}
}

func (ptr *QSignalMapper) ConnectMapped3(f func(widget unsafe.Pointer)) {
	defer qt.Recovering("connect QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_ConnectMapped3(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "mapped3", f)
	}
}

func (ptr *QSignalMapper) DisconnectMapped3() {
	defer qt.Recovering("disconnect QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_DisconnectMapped3(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "mapped3")
	}
}

//export callbackQSignalMapperMapped3
func callbackQSignalMapperMapped3(ptr unsafe.Pointer, ptrName *C.char, widget unsafe.Pointer) {
	defer qt.Recovering("callback QSignalMapper::mapped")

	if signal := qt.GetSignal(C.GoString(ptrName), "mapped3"); signal != nil {
		signal.(func(unsafe.Pointer))(unsafe.Pointer(widget))
	}

}

func (ptr *QSignalMapper) Mapped3(widget unsafe.Pointer) {
	defer qt.Recovering("QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_Mapped3(ptr.Pointer(), widget)
	}
}

func (ptr *QSignalMapper) ConnectMapped2(f func(text string)) {
	defer qt.Recovering("connect QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_ConnectMapped2(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "mapped2", f)
	}
}

func (ptr *QSignalMapper) DisconnectMapped2() {
	defer qt.Recovering("disconnect QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_DisconnectMapped2(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "mapped2")
	}
}

//export callbackQSignalMapperMapped2
func callbackQSignalMapperMapped2(ptr unsafe.Pointer, ptrName *C.char, text *C.char) {
	defer qt.Recovering("callback QSignalMapper::mapped")

	if signal := qt.GetSignal(C.GoString(ptrName), "mapped2"); signal != nil {
		signal.(func(string))(C.GoString(text))
	}

}

func (ptr *QSignalMapper) Mapped2(text string) {
	defer qt.Recovering("QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_Mapped2(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QSignalMapper) ConnectMapped(f func(i int)) {
	defer qt.Recovering("connect QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_ConnectMapped(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "mapped", f)
	}
}

func (ptr *QSignalMapper) DisconnectMapped() {
	defer qt.Recovering("disconnect QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_DisconnectMapped(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "mapped")
	}
}

//export callbackQSignalMapperMapped
func callbackQSignalMapperMapped(ptr unsafe.Pointer, ptrName *C.char, i C.int) {
	defer qt.Recovering("callback QSignalMapper::mapped")

	if signal := qt.GetSignal(C.GoString(ptrName), "mapped"); signal != nil {
		signal.(func(int))(int(i))
	}

}

func (ptr *QSignalMapper) Mapped(i int) {
	defer qt.Recovering("QSignalMapper::mapped")

	if ptr.Pointer() != nil {
		C.QSignalMapper_Mapped(ptr.Pointer(), C.int(i))
	}
}

func (ptr *QSignalMapper) Mapping4(object QObject_ITF) *QObject {
	defer qt.Recovering("QSignalMapper::mapping")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QSignalMapper_Mapping4(ptr.Pointer(), PointerFromQObject(object)))
	}
	return nil
}

func (ptr *QSignalMapper) Mapping3(widget unsafe.Pointer) *QObject {
	defer qt.Recovering("QSignalMapper::mapping")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QSignalMapper_Mapping3(ptr.Pointer(), widget))
	}
	return nil
}

func (ptr *QSignalMapper) Mapping2(id string) *QObject {
	defer qt.Recovering("QSignalMapper::mapping")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QSignalMapper_Mapping2(ptr.Pointer(), C.CString(id)))
	}
	return nil
}

func (ptr *QSignalMapper) Mapping(id int) *QObject {
	defer qt.Recovering("QSignalMapper::mapping")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QSignalMapper_Mapping(ptr.Pointer(), C.int(id)))
	}
	return nil
}

func (ptr *QSignalMapper) RemoveMappings(sender QObject_ITF) {
	defer qt.Recovering("QSignalMapper::removeMappings")

	if ptr.Pointer() != nil {
		C.QSignalMapper_RemoveMappings(ptr.Pointer(), PointerFromQObject(sender))
	}
}

func (ptr *QSignalMapper) SetMapping4(sender QObject_ITF, object QObject_ITF) {
	defer qt.Recovering("QSignalMapper::setMapping")

	if ptr.Pointer() != nil {
		C.QSignalMapper_SetMapping4(ptr.Pointer(), PointerFromQObject(sender), PointerFromQObject(object))
	}
}

func (ptr *QSignalMapper) SetMapping3(sender QObject_ITF, widget unsafe.Pointer) {
	defer qt.Recovering("QSignalMapper::setMapping")

	if ptr.Pointer() != nil {
		C.QSignalMapper_SetMapping3(ptr.Pointer(), PointerFromQObject(sender), widget)
	}
}

func (ptr *QSignalMapper) SetMapping2(sender QObject_ITF, text string) {
	defer qt.Recovering("QSignalMapper::setMapping")

	if ptr.Pointer() != nil {
		C.QSignalMapper_SetMapping2(ptr.Pointer(), PointerFromQObject(sender), C.CString(text))
	}
}

func (ptr *QSignalMapper) SetMapping(sender QObject_ITF, id int) {
	defer qt.Recovering("QSignalMapper::setMapping")

	if ptr.Pointer() != nil {
		C.QSignalMapper_SetMapping(ptr.Pointer(), PointerFromQObject(sender), C.int(id))
	}
}

func (ptr *QSignalMapper) DestroyQSignalMapper() {
	defer qt.Recovering("QSignalMapper::~QSignalMapper")

	if ptr.Pointer() != nil {
		C.QSignalMapper_DestroyQSignalMapper(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSignalMapper) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QSignalMapper::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSignalMapper) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSignalMapper::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSignalMapperTimerEvent
func callbackQSignalMapperTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSignalMapper::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQSignalMapperFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSignalMapper) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QSignalMapper::timerEvent")

	if ptr.Pointer() != nil {
		C.QSignalMapper_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSignalMapper) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QSignalMapper::timerEvent")

	if ptr.Pointer() != nil {
		C.QSignalMapper_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSignalMapper) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QSignalMapper::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSignalMapper) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSignalMapper::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSignalMapperChildEvent
func callbackQSignalMapperChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSignalMapper::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQSignalMapperFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QSignalMapper) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QSignalMapper::childEvent")

	if ptr.Pointer() != nil {
		C.QSignalMapper_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSignalMapper) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QSignalMapper::childEvent")

	if ptr.Pointer() != nil {
		C.QSignalMapper_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSignalMapper) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QSignalMapper::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSignalMapper) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSignalMapper::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSignalMapperCustomEvent
func callbackQSignalMapperCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSignalMapper::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQSignalMapperFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSignalMapper) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QSignalMapper::customEvent")

	if ptr.Pointer() != nil {
		C.QSignalMapper_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSignalMapper) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QSignalMapper::customEvent")

	if ptr.Pointer() != nil {
		C.QSignalMapper_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QSignalTransition struct {
	QAbstractTransition
}

type QSignalTransition_ITF interface {
	QAbstractTransition_ITF
	QSignalTransition_PTR() *QSignalTransition
}

func PointerFromQSignalTransition(ptr QSignalTransition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSignalTransition_PTR().Pointer()
	}
	return nil
}

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

func newQSignalTransitionFromPointer(ptr unsafe.Pointer) *QSignalTransition {
	var n = NewQSignalTransitionFromPointer(ptr)
	for len(n.ObjectName()) < len("QSignalTransition_") {
		n.SetObjectName("QSignalTransition_" + qt.Identifier())
	}
	return n
}

func (ptr *QSignalTransition) QSignalTransition_PTR() *QSignalTransition {
	return ptr
}

func NewQSignalTransition(sourceState QState_ITF) *QSignalTransition {
	defer qt.Recovering("QSignalTransition::QSignalTransition")

	return newQSignalTransitionFromPointer(C.QSignalTransition_NewQSignalTransition(PointerFromQState(sourceState)))
}

func NewQSignalTransition2(sender QObject_ITF, signal string, sourceState QState_ITF) *QSignalTransition {
	defer qt.Recovering("QSignalTransition::QSignalTransition")

	return newQSignalTransitionFromPointer(C.QSignalTransition_NewQSignalTransition2(PointerFromQObject(sender), C.CString(signal), PointerFromQState(sourceState)))
}

func (ptr *QSignalTransition) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QSignalTransition::event")

	if ptr.Pointer() != nil {
		return C.QSignalTransition_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QSignalTransition) EventTest(event QEvent_ITF) bool {
	defer qt.Recovering("QSignalTransition::eventTest")

	if ptr.Pointer() != nil {
		return C.QSignalTransition_EventTest(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QSignalTransition) ConnectOnTransition(f func(event *QEvent)) {
	defer qt.Recovering("connect QSignalTransition::onTransition")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onTransition", f)
	}
}

func (ptr *QSignalTransition) DisconnectOnTransition() {
	defer qt.Recovering("disconnect QSignalTransition::onTransition")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onTransition")
	}
}

//export callbackQSignalTransitionOnTransition
func callbackQSignalTransitionOnTransition(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSignalTransition::onTransition")

	if signal := qt.GetSignal(C.GoString(ptrName), "onTransition"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQSignalTransitionFromPointer(ptr).OnTransitionDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSignalTransition) OnTransition(event QEvent_ITF) {
	defer qt.Recovering("QSignalTransition::onTransition")

	if ptr.Pointer() != nil {
		C.QSignalTransition_OnTransition(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSignalTransition) OnTransitionDefault(event QEvent_ITF) {
	defer qt.Recovering("QSignalTransition::onTransition")

	if ptr.Pointer() != nil {
		C.QSignalTransition_OnTransitionDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSignalTransition) SenderObject() *QObject {
	defer qt.Recovering("QSignalTransition::senderObject")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QSignalTransition_SenderObject(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSignalTransition) ConnectSenderObjectChanged(f func()) {
	defer qt.Recovering("connect QSignalTransition::senderObjectChanged")

	if ptr.Pointer() != nil {
		C.QSignalTransition_ConnectSenderObjectChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "senderObjectChanged", f)
	}
}

func (ptr *QSignalTransition) DisconnectSenderObjectChanged() {
	defer qt.Recovering("disconnect QSignalTransition::senderObjectChanged")

	if ptr.Pointer() != nil {
		C.QSignalTransition_DisconnectSenderObjectChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "senderObjectChanged")
	}
}

//export callbackQSignalTransitionSenderObjectChanged
func callbackQSignalTransitionSenderObjectChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QSignalTransition::senderObjectChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "senderObjectChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QSignalTransition) SetSenderObject(sender QObject_ITF) {
	defer qt.Recovering("QSignalTransition::setSenderObject")

	if ptr.Pointer() != nil {
		C.QSignalTransition_SetSenderObject(ptr.Pointer(), PointerFromQObject(sender))
	}
}

func (ptr *QSignalTransition) SetSignal(signal string) {
	defer qt.Recovering("QSignalTransition::setSignal")

	if ptr.Pointer() != nil {
		C.QSignalTransition_SetSignal(ptr.Pointer(), C.CString(signal))
	}
}

func (ptr *QSignalTransition) Signal() string {
	defer qt.Recovering("QSignalTransition::signal")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSignalTransition_Signal(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSignalTransition) ConnectSignalChanged(f func()) {
	defer qt.Recovering("connect QSignalTransition::signalChanged")

	if ptr.Pointer() != nil {
		C.QSignalTransition_ConnectSignalChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "signalChanged", f)
	}
}

func (ptr *QSignalTransition) DisconnectSignalChanged() {
	defer qt.Recovering("disconnect QSignalTransition::signalChanged")

	if ptr.Pointer() != nil {
		C.QSignalTransition_DisconnectSignalChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "signalChanged")
	}
}

//export callbackQSignalTransitionSignalChanged
func callbackQSignalTransitionSignalChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QSignalTransition::signalChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "signalChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QSignalTransition) DestroyQSignalTransition() {
	defer qt.Recovering("QSignalTransition::~QSignalTransition")

	if ptr.Pointer() != nil {
		C.QSignalTransition_DestroyQSignalTransition(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSignalTransition) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QSignalTransition::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSignalTransition) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSignalTransition::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSignalTransitionTimerEvent
func callbackQSignalTransitionTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSignalTransition::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQSignalTransitionFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSignalTransition) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QSignalTransition::timerEvent")

	if ptr.Pointer() != nil {
		C.QSignalTransition_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSignalTransition) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QSignalTransition::timerEvent")

	if ptr.Pointer() != nil {
		C.QSignalTransition_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSignalTransition) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QSignalTransition::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSignalTransition) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSignalTransition::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSignalTransitionChildEvent
func callbackQSignalTransitionChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSignalTransition::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQSignalTransitionFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QSignalTransition) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QSignalTransition::childEvent")

	if ptr.Pointer() != nil {
		C.QSignalTransition_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSignalTransition) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QSignalTransition::childEvent")

	if ptr.Pointer() != nil {
		C.QSignalTransition_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSignalTransition) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QSignalTransition::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSignalTransition) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSignalTransition::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSignalTransitionCustomEvent
func callbackQSignalTransitionCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSignalTransition::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQSignalTransitionFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSignalTransition) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QSignalTransition::customEvent")

	if ptr.Pointer() != nil {
		C.QSignalTransition_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSignalTransition) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QSignalTransition::customEvent")

	if ptr.Pointer() != nil {
		C.QSignalTransition_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QSize struct {
	ptr unsafe.Pointer
}

type QSize_ITF interface {
	QSize_PTR() *QSize
}

func (p *QSize) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSize) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSize(ptr QSize_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSize_PTR().Pointer()
	}
	return nil
}

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

func newQSizeFromPointer(ptr unsafe.Pointer) *QSize {
	var n = NewQSizeFromPointer(ptr)
	return n
}

func (ptr *QSize) QSize_PTR() *QSize {
	return ptr
}

func NewQSize() *QSize {
	defer qt.Recovering("QSize::QSize")

	return newQSizeFromPointer(C.QSize_NewQSize())
}

func NewQSize2(width int, height int) *QSize {
	defer qt.Recovering("QSize::QSize")

	return newQSizeFromPointer(C.QSize_NewQSize2(C.int(width), C.int(height)))
}

func (ptr *QSize) BoundedTo(otherSize QSize_ITF) *QSize {
	defer qt.Recovering("QSize::boundedTo")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QSize_BoundedTo(ptr.Pointer(), PointerFromQSize(otherSize)))
	}
	return nil
}

func (ptr *QSize) ExpandedTo(otherSize QSize_ITF) *QSize {
	defer qt.Recovering("QSize::expandedTo")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QSize_ExpandedTo(ptr.Pointer(), PointerFromQSize(otherSize)))
	}
	return nil
}

func (ptr *QSize) Height() int {
	defer qt.Recovering("QSize::height")

	if ptr.Pointer() != nil {
		return int(C.QSize_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSize) IsEmpty() bool {
	defer qt.Recovering("QSize::isEmpty")

	if ptr.Pointer() != nil {
		return C.QSize_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSize) IsNull() bool {
	defer qt.Recovering("QSize::isNull")

	if ptr.Pointer() != nil {
		return C.QSize_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSize) IsValid() bool {
	defer qt.Recovering("QSize::isValid")

	if ptr.Pointer() != nil {
		return C.QSize_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSize) Rheight() int {
	defer qt.Recovering("QSize::rheight")

	if ptr.Pointer() != nil {
		return int(C.QSize_Rheight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSize) Rwidth() int {
	defer qt.Recovering("QSize::rwidth")

	if ptr.Pointer() != nil {
		return int(C.QSize_Rwidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSize) Scale2(size QSize_ITF, mode Qt__AspectRatioMode) {
	defer qt.Recovering("QSize::scale")

	if ptr.Pointer() != nil {
		C.QSize_Scale2(ptr.Pointer(), PointerFromQSize(size), C.int(mode))
	}
}

func (ptr *QSize) Scale(width int, height int, mode Qt__AspectRatioMode) {
	defer qt.Recovering("QSize::scale")

	if ptr.Pointer() != nil {
		C.QSize_Scale(ptr.Pointer(), C.int(width), C.int(height), C.int(mode))
	}
}

func (ptr *QSize) Scaled2(s QSize_ITF, mode Qt__AspectRatioMode) *QSize {
	defer qt.Recovering("QSize::scaled")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QSize_Scaled2(ptr.Pointer(), PointerFromQSize(s), C.int(mode)))
	}
	return nil
}

func (ptr *QSize) Scaled(width int, height int, mode Qt__AspectRatioMode) *QSize {
	defer qt.Recovering("QSize::scaled")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QSize_Scaled(ptr.Pointer(), C.int(width), C.int(height), C.int(mode)))
	}
	return nil
}

func (ptr *QSize) SetHeight(height int) {
	defer qt.Recovering("QSize::setHeight")

	if ptr.Pointer() != nil {
		C.QSize_SetHeight(ptr.Pointer(), C.int(height))
	}
}

func (ptr *QSize) SetWidth(width int) {
	defer qt.Recovering("QSize::setWidth")

	if ptr.Pointer() != nil {
		C.QSize_SetWidth(ptr.Pointer(), C.int(width))
	}
}

func (ptr *QSize) Transpose() {
	defer qt.Recovering("QSize::transpose")

	if ptr.Pointer() != nil {
		C.QSize_Transpose(ptr.Pointer())
	}
}

func (ptr *QSize) Transposed() *QSize {
	defer qt.Recovering("QSize::transposed")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QSize_Transposed(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSize) Width() int {
	defer qt.Recovering("QSize::width")

	if ptr.Pointer() != nil {
		return int(C.QSize_Width(ptr.Pointer()))
	}
	return 0
}

type QSizeF struct {
	ptr unsafe.Pointer
}

type QSizeF_ITF interface {
	QSizeF_PTR() *QSizeF
}

func (p *QSizeF) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSizeF) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSizeF(ptr QSizeF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSizeF_PTR().Pointer()
	}
	return nil
}

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

func newQSizeFFromPointer(ptr unsafe.Pointer) *QSizeF {
	var n = NewQSizeFFromPointer(ptr)
	return n
}

func (ptr *QSizeF) QSizeF_PTR() *QSizeF {
	return ptr
}

func NewQSizeF() *QSizeF {
	defer qt.Recovering("QSizeF::QSizeF")

	return newQSizeFFromPointer(C.QSizeF_NewQSizeF())
}

func NewQSizeF2(size QSize_ITF) *QSizeF {
	defer qt.Recovering("QSizeF::QSizeF")

	return newQSizeFFromPointer(C.QSizeF_NewQSizeF2(PointerFromQSize(size)))
}

func NewQSizeF3(width float64, height float64) *QSizeF {
	defer qt.Recovering("QSizeF::QSizeF")

	return newQSizeFFromPointer(C.QSizeF_NewQSizeF3(C.double(width), C.double(height)))
}

func (ptr *QSizeF) Height() float64 {
	defer qt.Recovering("QSizeF::height")

	if ptr.Pointer() != nil {
		return float64(C.QSizeF_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSizeF) IsEmpty() bool {
	defer qt.Recovering("QSizeF::isEmpty")

	if ptr.Pointer() != nil {
		return C.QSizeF_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSizeF) IsNull() bool {
	defer qt.Recovering("QSizeF::isNull")

	if ptr.Pointer() != nil {
		return C.QSizeF_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSizeF) IsValid() bool {
	defer qt.Recovering("QSizeF::isValid")

	if ptr.Pointer() != nil {
		return C.QSizeF_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSizeF) Rheight() float64 {
	defer qt.Recovering("QSizeF::rheight")

	if ptr.Pointer() != nil {
		return float64(C.QSizeF_Rheight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSizeF) Rwidth() float64 {
	defer qt.Recovering("QSizeF::rwidth")

	if ptr.Pointer() != nil {
		return float64(C.QSizeF_Rwidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSizeF) Scale2(size QSizeF_ITF, mode Qt__AspectRatioMode) {
	defer qt.Recovering("QSizeF::scale")

	if ptr.Pointer() != nil {
		C.QSizeF_Scale2(ptr.Pointer(), PointerFromQSizeF(size), C.int(mode))
	}
}

func (ptr *QSizeF) Scale(width float64, height float64, mode Qt__AspectRatioMode) {
	defer qt.Recovering("QSizeF::scale")

	if ptr.Pointer() != nil {
		C.QSizeF_Scale(ptr.Pointer(), C.double(width), C.double(height), C.int(mode))
	}
}

func (ptr *QSizeF) SetHeight(height float64) {
	defer qt.Recovering("QSizeF::setHeight")

	if ptr.Pointer() != nil {
		C.QSizeF_SetHeight(ptr.Pointer(), C.double(height))
	}
}

func (ptr *QSizeF) SetWidth(width float64) {
	defer qt.Recovering("QSizeF::setWidth")

	if ptr.Pointer() != nil {
		C.QSizeF_SetWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QSizeF) ToSize() *QSize {
	defer qt.Recovering("QSizeF::toSize")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QSizeF_ToSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSizeF) Transpose() {
	defer qt.Recovering("QSizeF::transpose")

	if ptr.Pointer() != nil {
		C.QSizeF_Transpose(ptr.Pointer())
	}
}

func (ptr *QSizeF) Width() float64 {
	defer qt.Recovering("QSizeF::width")

	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 PointerFromQSocketNotifier(ptr QSocketNotifier_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSocketNotifier_PTR().Pointer()
	}
	return nil
}

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

func newQSocketNotifierFromPointer(ptr unsafe.Pointer) *QSocketNotifier {
	var n = NewQSocketNotifierFromPointer(ptr)
	for len(n.ObjectName()) < len("QSocketNotifier_") {
		n.SetObjectName("QSocketNotifier_" + qt.Identifier())
	}
	return n
}

func (ptr *QSocketNotifier) QSocketNotifier_PTR() *QSocketNotifier {
	return ptr
}

//QSocketNotifier::Type
type QSocketNotifier__Type int64

const (
	QSocketNotifier__Read      = QSocketNotifier__Type(0)
	QSocketNotifier__Write     = QSocketNotifier__Type(1)
	QSocketNotifier__Exception = QSocketNotifier__Type(2)
)

func (ptr *QSocketNotifier) ConnectActivated(f func(socket int)) {
	defer qt.Recovering("connect QSocketNotifier::activated")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_ConnectActivated(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "activated", f)
	}
}

func (ptr *QSocketNotifier) DisconnectActivated() {
	defer qt.Recovering("disconnect QSocketNotifier::activated")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_DisconnectActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "activated")
	}
}

//export callbackQSocketNotifierActivated
func callbackQSocketNotifierActivated(ptr unsafe.Pointer, ptrName *C.char, socket C.int) {
	defer qt.Recovering("callback QSocketNotifier::activated")

	if signal := qt.GetSignal(C.GoString(ptrName), "activated"); signal != nil {
		signal.(func(int))(int(socket))
	}

}

func (ptr *QSocketNotifier) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QSocketNotifier::event")

	if ptr.Pointer() != nil {
		return C.QSocketNotifier_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QSocketNotifier) IsEnabled() bool {
	defer qt.Recovering("QSocketNotifier::isEnabled")

	if ptr.Pointer() != nil {
		return C.QSocketNotifier_IsEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSocketNotifier) SetEnabled(enable bool) {
	defer qt.Recovering("QSocketNotifier::setEnabled")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_SetEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QSocketNotifier) Type() QSocketNotifier__Type {
	defer qt.Recovering("QSocketNotifier::type")

	if ptr.Pointer() != nil {
		return QSocketNotifier__Type(C.QSocketNotifier_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSocketNotifier) DestroyQSocketNotifier() {
	defer qt.Recovering("QSocketNotifier::~QSocketNotifier")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_DestroyQSocketNotifier(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSocketNotifier) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QSocketNotifier::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSocketNotifier) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSocketNotifier::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSocketNotifierTimerEvent
func callbackQSocketNotifierTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSocketNotifier::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQSocketNotifierFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSocketNotifier) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QSocketNotifier::timerEvent")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSocketNotifier) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QSocketNotifier::timerEvent")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSocketNotifier) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QSocketNotifier::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSocketNotifier) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSocketNotifier::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSocketNotifierChildEvent
func callbackQSocketNotifierChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSocketNotifier::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQSocketNotifierFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QSocketNotifier) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QSocketNotifier::childEvent")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSocketNotifier) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QSocketNotifier::childEvent")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSocketNotifier) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QSocketNotifier::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSocketNotifier) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSocketNotifier::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSocketNotifierCustomEvent
func callbackQSocketNotifierCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSocketNotifier::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQSocketNotifierFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSocketNotifier) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QSocketNotifier::customEvent")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSocketNotifier) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QSocketNotifier::customEvent")

	if ptr.Pointer() != nil {
		C.QSocketNotifier_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QSortFilterProxyModel struct {
	QAbstractProxyModel
}

type QSortFilterProxyModel_ITF interface {
	QAbstractProxyModel_ITF
	QSortFilterProxyModel_PTR() *QSortFilterProxyModel
}

func PointerFromQSortFilterProxyModel(ptr QSortFilterProxyModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSortFilterProxyModel_PTR().Pointer()
	}
	return nil
}

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

func newQSortFilterProxyModelFromPointer(ptr unsafe.Pointer) *QSortFilterProxyModel {
	var n = NewQSortFilterProxyModelFromPointer(ptr)
	for len(n.ObjectName()) < len("QSortFilterProxyModel_") {
		n.SetObjectName("QSortFilterProxyModel_" + qt.Identifier())
	}
	return n
}

func (ptr *QSortFilterProxyModel) QSortFilterProxyModel_PTR() *QSortFilterProxyModel {
	return ptr
}

func (ptr *QSortFilterProxyModel) DynamicSortFilter() bool {
	defer qt.Recovering("QSortFilterProxyModel::dynamicSortFilter")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_DynamicSortFilter(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) FilterCaseSensitivity() Qt__CaseSensitivity {
	defer qt.Recovering("QSortFilterProxyModel::filterCaseSensitivity")

	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QSortFilterProxyModel_FilterCaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) FilterKeyColumn() int {
	defer qt.Recovering("QSortFilterProxyModel::filterKeyColumn")

	if ptr.Pointer() != nil {
		return int(C.QSortFilterProxyModel_FilterKeyColumn(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) FilterRegExp() *QRegExp {
	defer qt.Recovering("QSortFilterProxyModel::filterRegExp")

	if ptr.Pointer() != nil {
		return NewQRegExpFromPointer(C.QSortFilterProxyModel_FilterRegExp(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSortFilterProxyModel) FilterRole() int {
	defer qt.Recovering("QSortFilterProxyModel::filterRole")

	if ptr.Pointer() != nil {
		return int(C.QSortFilterProxyModel_FilterRole(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) IsSortLocaleAware() bool {
	defer qt.Recovering("QSortFilterProxyModel::isSortLocaleAware")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_IsSortLocaleAware(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) SetDynamicSortFilter(enable bool) {
	defer qt.Recovering("QSortFilterProxyModel::setDynamicSortFilter")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetDynamicSortFilter(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterCaseSensitivity(cs Qt__CaseSensitivity) {
	defer qt.Recovering("QSortFilterProxyModel::setFilterCaseSensitivity")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterCaseSensitivity(ptr.Pointer(), C.int(cs))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterKeyColumn(column int) {
	defer qt.Recovering("QSortFilterProxyModel::setFilterKeyColumn")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterKeyColumn(ptr.Pointer(), C.int(column))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegExp(regExp QRegExp_ITF) {
	defer qt.Recovering("QSortFilterProxyModel::setFilterRegExp")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterRegExp(ptr.Pointer(), PointerFromQRegExp(regExp))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRole(role int) {
	defer qt.Recovering("QSortFilterProxyModel::setFilterRole")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterRole(ptr.Pointer(), C.int(role))
	}
}

func (ptr *QSortFilterProxyModel) SetSortCaseSensitivity(cs Qt__CaseSensitivity) {
	defer qt.Recovering("QSortFilterProxyModel::setSortCaseSensitivity")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetSortCaseSensitivity(ptr.Pointer(), C.int(cs))
	}
}

func (ptr *QSortFilterProxyModel) SetSortLocaleAware(on bool) {
	defer qt.Recovering("QSortFilterProxyModel::setSortLocaleAware")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetSortLocaleAware(ptr.Pointer(), C.int(qt.GoBoolToInt(on)))
	}
}

func (ptr *QSortFilterProxyModel) SetSortRole(role int) {
	defer qt.Recovering("QSortFilterProxyModel::setSortRole")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetSortRole(ptr.Pointer(), C.int(role))
	}
}

func (ptr *QSortFilterProxyModel) SortCaseSensitivity() Qt__CaseSensitivity {
	defer qt.Recovering("QSortFilterProxyModel::sortCaseSensitivity")

	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QSortFilterProxyModel_SortCaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) SortRole() int {
	defer qt.Recovering("QSortFilterProxyModel::sortRole")

	if ptr.Pointer() != nil {
		return int(C.QSortFilterProxyModel_SortRole(ptr.Pointer()))
	}
	return 0
}

func NewQSortFilterProxyModel(parent QObject_ITF) *QSortFilterProxyModel {
	defer qt.Recovering("QSortFilterProxyModel::QSortFilterProxyModel")

	return newQSortFilterProxyModelFromPointer(C.QSortFilterProxyModel_NewQSortFilterProxyModel(PointerFromQObject(parent)))
}

func (ptr *QSortFilterProxyModel) CanFetchMore(parent QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::canFetchMore")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_CanFetchMore(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) ColumnCount(parent QModelIndex_ITF) int {
	defer qt.Recovering("QSortFilterProxyModel::columnCount")

	if ptr.Pointer() != nil {
		return int(C.QSortFilterProxyModel_ColumnCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) Data(index QModelIndex_ITF, role int) *QVariant {
	defer qt.Recovering("QSortFilterProxyModel::data")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QSortFilterProxyModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
	}
	return nil
}

func (ptr *QSortFilterProxyModel) DropMimeData(data QMimeData_ITF, action Qt__DropAction, row int, column int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::dropMimeData")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_DropMimeData(ptr.Pointer(), PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) FilterAcceptsColumn(source_column int, source_parent QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::filterAcceptsColumn")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_FilterAcceptsColumn(ptr.Pointer(), C.int(source_column), PointerFromQModelIndex(source_parent)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) FilterAcceptsRow(source_row int, source_parent QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::filterAcceptsRow")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_FilterAcceptsRow(ptr.Pointer(), C.int(source_row), PointerFromQModelIndex(source_parent)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
	defer qt.Recovering("QSortFilterProxyModel::flags")

	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QSortFilterProxyModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) HasChildren(parent QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::hasChildren")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_HasChildren(ptr.Pointer(), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) HeaderData(section int, orientation Qt__Orientation, role int) *QVariant {
	defer qt.Recovering("QSortFilterProxyModel::headerData")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QSortFilterProxyModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
	}
	return nil
}

func (ptr *QSortFilterProxyModel) InsertColumns(column int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::insertColumns")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::insertRows")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) Invalidate() {
	defer qt.Recovering("QSortFilterProxyModel::invalidate")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_Invalidate(ptr.Pointer())
	}
}

func (ptr *QSortFilterProxyModel) LessThan(source_left QModelIndex_ITF, source_right QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::lessThan")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_LessThan(ptr.Pointer(), PointerFromQModelIndex(source_left), PointerFromQModelIndex(source_right)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) MimeTypes() []string {
	defer qt.Recovering("QSortFilterProxyModel::mimeTypes")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QSortFilterProxyModel_MimeTypes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QSortFilterProxyModel) RemoveColumns(column int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::removeColumns")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QSortFilterProxyModel::removeRows")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) RowCount(parent QModelIndex_ITF) int {
	defer qt.Recovering("QSortFilterProxyModel::rowCount")

	if ptr.Pointer() != nil {
		return int(C.QSortFilterProxyModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
	defer qt.Recovering("QSortFilterProxyModel::setData")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) SetFilterFixedString(pattern string) {
	defer qt.Recovering("QSortFilterProxyModel::setFilterFixedString")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterFixedString(ptr.Pointer(), C.CString(pattern))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterRegExp2(pattern string) {
	defer qt.Recovering("QSortFilterProxyModel::setFilterRegExp")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterRegExp2(ptr.Pointer(), C.CString(pattern))
	}
}

func (ptr *QSortFilterProxyModel) SetFilterWildcard(pattern string) {
	defer qt.Recovering("QSortFilterProxyModel::setFilterWildcard")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetFilterWildcard(ptr.Pointer(), C.CString(pattern))
	}
}

func (ptr *QSortFilterProxyModel) SetHeaderData(section int, orientation Qt__Orientation, value QVariant_ITF, role int) bool {
	defer qt.Recovering("QSortFilterProxyModel::setHeaderData")

	if ptr.Pointer() != nil {
		return C.QSortFilterProxyModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), PointerFromQVariant(value), C.int(role)) != 0
	}
	return false
}

func (ptr *QSortFilterProxyModel) ConnectSetSourceModel(f func(sourceModel *QAbstractItemModel)) {
	defer qt.Recovering("connect QSortFilterProxyModel::setSourceModel")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "setSourceModel", f)
	}
}

func (ptr *QSortFilterProxyModel) DisconnectSetSourceModel() {
	defer qt.Recovering("disconnect QSortFilterProxyModel::setSourceModel")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "setSourceModel")
	}
}

//export callbackQSortFilterProxyModelSetSourceModel
func callbackQSortFilterProxyModelSetSourceModel(ptr unsafe.Pointer, ptrName *C.char, sourceModel unsafe.Pointer) {
	defer qt.Recovering("callback QSortFilterProxyModel::setSourceModel")

	if signal := qt.GetSignal(C.GoString(ptrName), "setSourceModel"); signal != nil {
		signal.(func(*QAbstractItemModel))(NewQAbstractItemModelFromPointer(sourceModel))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).SetSourceModelDefault(NewQAbstractItemModelFromPointer(sourceModel))
	}
}

func (ptr *QSortFilterProxyModel) SetSourceModel(sourceModel QAbstractItemModel_ITF) {
	defer qt.Recovering("QSortFilterProxyModel::setSourceModel")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetSourceModel(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
	}
}

func (ptr *QSortFilterProxyModel) SetSourceModelDefault(sourceModel QAbstractItemModel_ITF) {
	defer qt.Recovering("QSortFilterProxyModel::setSourceModel")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SetSourceModelDefault(ptr.Pointer(), PointerFromQAbstractItemModel(sourceModel))
	}
}

func (ptr *QSortFilterProxyModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
	defer qt.Recovering("connect QSortFilterProxyModel::sort")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
	}
}

func (ptr *QSortFilterProxyModel) DisconnectSort() {
	defer qt.Recovering("disconnect QSortFilterProxyModel::sort")

	if ptr.Pointer() != nil {

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

//export callbackQSortFilterProxyModelSort
func callbackQSortFilterProxyModelSort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
	defer qt.Recovering("callback QSortFilterProxyModel::sort")

	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
	}
}

func (ptr *QSortFilterProxyModel) Sort(column int, order Qt__SortOrder) {
	defer qt.Recovering("QSortFilterProxyModel::sort")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QSortFilterProxyModel) SortDefault(column int, order Qt__SortOrder) {
	defer qt.Recovering("QSortFilterProxyModel::sort")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QSortFilterProxyModel) SortColumn() int {
	defer qt.Recovering("QSortFilterProxyModel::sortColumn")

	if ptr.Pointer() != nil {
		return int(C.QSortFilterProxyModel_SortColumn(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) SortOrder() Qt__SortOrder {
	defer qt.Recovering("QSortFilterProxyModel::sortOrder")

	if ptr.Pointer() != nil {
		return Qt__SortOrder(C.QSortFilterProxyModel_SortOrder(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) Span(index QModelIndex_ITF) *QSize {
	defer qt.Recovering("QSortFilterProxyModel::span")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QSortFilterProxyModel_Span(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return nil
}

func (ptr *QSortFilterProxyModel) SupportedDropActions() Qt__DropAction {
	defer qt.Recovering("QSortFilterProxyModel::supportedDropActions")

	if ptr.Pointer() != nil {
		return Qt__DropAction(C.QSortFilterProxyModel_SupportedDropActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSortFilterProxyModel) DestroyQSortFilterProxyModel() {
	defer qt.Recovering("QSortFilterProxyModel::~QSortFilterProxyModel")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_DestroyQSortFilterProxyModel(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSortFilterProxyModel) ConnectRevert(f func()) {
	defer qt.Recovering("connect QSortFilterProxyModel::revert")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
	}
}

func (ptr *QSortFilterProxyModel) DisconnectRevert() {
	defer qt.Recovering("disconnect QSortFilterProxyModel::revert")

	if ptr.Pointer() != nil {

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

//export callbackQSortFilterProxyModelRevert
func callbackQSortFilterProxyModelRevert(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QSortFilterProxyModel::revert")

	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QSortFilterProxyModel) Revert() {
	defer qt.Recovering("QSortFilterProxyModel::revert")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_Revert(ptr.Pointer())
	}
}

func (ptr *QSortFilterProxyModel) RevertDefault() {
	defer qt.Recovering("QSortFilterProxyModel::revert")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_RevertDefault(ptr.Pointer())
	}
}

func (ptr *QSortFilterProxyModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QSortFilterProxyModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSortFilterProxyModel) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSortFilterProxyModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSortFilterProxyModelTimerEvent
func callbackQSortFilterProxyModelTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSortFilterProxyModel::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSortFilterProxyModel) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QSortFilterProxyModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSortFilterProxyModel) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QSortFilterProxyModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QSortFilterProxyModel) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QSortFilterProxyModel::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSortFilterProxyModel) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSortFilterProxyModel::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSortFilterProxyModelChildEvent
func callbackQSortFilterProxyModelChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSortFilterProxyModel::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QSortFilterProxyModel) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QSortFilterProxyModel::childEvent")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSortFilterProxyModel) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QSortFilterProxyModel::childEvent")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QSortFilterProxyModel) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QSortFilterProxyModel::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSortFilterProxyModel) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSortFilterProxyModel::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSortFilterProxyModelCustomEvent
func callbackQSortFilterProxyModelCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSortFilterProxyModel::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQSortFilterProxyModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QSortFilterProxyModel) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QSortFilterProxyModel::customEvent")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QSortFilterProxyModel) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QSortFilterProxyModel::customEvent")

	if ptr.Pointer() != nil {
		C.QSortFilterProxyModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QStack struct {
	QVector
}

type QStack_ITF interface {
	QVector_ITF
	QStack_PTR() *QStack
}

func PointerFromQStack(ptr QStack_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStack_PTR().Pointer()
	}
	return nil
}

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

func newQStackFromPointer(ptr unsafe.Pointer) *QStack {
	var n = NewQStackFromPointer(ptr)
	return n
}

func (ptr *QStack) QStack_PTR() *QStack {
	return ptr
}

type QStandardPaths struct {
	ptr unsafe.Pointer
}

type QStandardPaths_ITF interface {
	QStandardPaths_PTR() *QStandardPaths
}

func (p *QStandardPaths) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QStandardPaths) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQStandardPaths(ptr QStandardPaths_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStandardPaths_PTR().Pointer()
	}
	return nil
}

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

func newQStandardPathsFromPointer(ptr unsafe.Pointer) *QStandardPaths {
	var n = NewQStandardPathsFromPointer(ptr)
	return n
}

func (ptr *QStandardPaths) QStandardPaths_PTR() *QStandardPaths {
	return ptr
}

//QStandardPaths::LocateOption
type QStandardPaths__LocateOption int64

const (
	QStandardPaths__LocateFile      = QStandardPaths__LocateOption(0x0)
	QStandardPaths__LocateDirectory = QStandardPaths__LocateOption(0x1)
)

//QStandardPaths::StandardLocation
type QStandardPaths__StandardLocation int64

const (
	QStandardPaths__DesktopLocation       = QStandardPaths__StandardLocation(0)
	QStandardPaths__DocumentsLocation     = QStandardPaths__StandardLocation(1)
	QStandardPaths__FontsLocation         = QStandardPaths__StandardLocation(2)
	QStandardPaths__ApplicationsLocation  = QStandardPaths__StandardLocation(3)
	QStandardPaths__MusicLocation         = QStandardPaths__StandardLocation(4)
	QStandardPaths__MoviesLocation        = QStandardPaths__StandardLocation(5)
	QStandardPaths__PicturesLocation      = QStandardPaths__StandardLocation(6)
	QStandardPaths__TempLocation          = QStandardPaths__StandardLocation(7)
	QStandardPaths__HomeLocation          = QStandardPaths__StandardLocation(8)
	QStandardPaths__DataLocation          = QStandardPaths__StandardLocation(9)
	QStandardPaths__CacheLocation         = QStandardPaths__StandardLocation(10)
	QStandardPaths__GenericDataLocation   = QStandardPaths__StandardLocation(11)
	QStandardPaths__RuntimeLocation       = QStandardPaths__StandardLocation(12)
	QStandardPaths__ConfigLocation        = QStandardPaths__StandardLocation(13)
	QStandardPaths__DownloadLocation      = QStandardPaths__StandardLocation(14)
	QStandardPaths__GenericCacheLocation  = QStandardPaths__StandardLocation(15)
	QStandardPaths__GenericConfigLocation = QStandardPaths__StandardLocation(16)
	QStandardPaths__AppDataLocation       = QStandardPaths__StandardLocation(17)
	QStandardPaths__AppConfigLocation     = QStandardPaths__StandardLocation(18)
	QStandardPaths__AppLocalDataLocation  = QStandardPaths__StandardLocation(QStandardPaths__DataLocation)
)

func QStandardPaths_SetTestModeEnabled(testMode bool) {
	defer qt.Recovering("QStandardPaths::setTestModeEnabled")

	C.QStandardPaths_QStandardPaths_SetTestModeEnabled(C.int(qt.GoBoolToInt(testMode)))
}

func QStandardPaths_FindExecutable(executableName string, paths []string) string {
	defer qt.Recovering("QStandardPaths::findExecutable")

	return C.GoString(C.QStandardPaths_QStandardPaths_FindExecutable(C.CString(executableName), C.CString(strings.Join(paths, "|"))))
}

func QStandardPaths_Locate(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) string {
	defer qt.Recovering("QStandardPaths::locate")

	return C.GoString(C.QStandardPaths_QStandardPaths_Locate(C.int(ty), C.CString(fileName), C.int(options)))
}

func QStandardPaths_LocateAll(ty QStandardPaths__StandardLocation, fileName string, options QStandardPaths__LocateOption) []string {
	defer qt.Recovering("QStandardPaths::locateAll")

	return strings.Split(C.GoString(C.QStandardPaths_QStandardPaths_LocateAll(C.int(ty), C.CString(fileName), C.int(options))), "|")
}

func QStandardPaths_DisplayName(ty QStandardPaths__StandardLocation) string {
	defer qt.Recovering("QStandardPaths::displayName")

	return C.GoString(C.QStandardPaths_QStandardPaths_DisplayName(C.int(ty)))
}

func QStandardPaths_StandardLocations(ty QStandardPaths__StandardLocation) []string {
	defer qt.Recovering("QStandardPaths::standardLocations")

	return strings.Split(C.GoString(C.QStandardPaths_QStandardPaths_StandardLocations(C.int(ty))), "|")
}

func QStandardPaths_WritableLocation(ty QStandardPaths__StandardLocation) string {
	defer qt.Recovering("QStandardPaths::writableLocation")

	return C.GoString(C.QStandardPaths_QStandardPaths_WritableLocation(C.int(ty)))
}

type QState struct {
	QAbstractState
}

type QState_ITF interface {
	QAbstractState_ITF
	QState_PTR() *QState
}

func PointerFromQState(ptr QState_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QState_PTR().Pointer()
	}
	return nil
}

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

func newQStateFromPointer(ptr unsafe.Pointer) *QState {
	var n = NewQStateFromPointer(ptr)
	for len(n.ObjectName()) < len("QState_") {
		n.SetObjectName("QState_" + qt.Identifier())
	}
	return n
}

func (ptr *QState) QState_PTR() *QState {
	return ptr
}

//QState::ChildMode
type QState__ChildMode int64

const (
	QState__ExclusiveStates = QState__ChildMode(0)
	QState__ParallelStates  = QState__ChildMode(1)
)

//QState::RestorePolicy
type QState__RestorePolicy int64

const (
	QState__DontRestoreProperties = QState__RestorePolicy(0)
	QState__RestoreProperties     = QState__RestorePolicy(1)
)

func NewQState2(childMode QState__ChildMode, parent QState_ITF) *QState {
	defer qt.Recovering("QState::QState")

	return newQStateFromPointer(C.QState_NewQState2(C.int(childMode), PointerFromQState(parent)))
}

func NewQState(parent QState_ITF) *QState {
	defer qt.Recovering("QState::QState")

	return newQStateFromPointer(C.QState_NewQState(PointerFromQState(parent)))
}

func (ptr *QState) AddTransition3(target QAbstractState_ITF) *QAbstractTransition {
	defer qt.Recovering("QState::addTransition")

	if ptr.Pointer() != nil {
		return NewQAbstractTransitionFromPointer(C.QState_AddTransition3(ptr.Pointer(), PointerFromQAbstractState(target)))
	}
	return nil
}

func (ptr *QState) AddTransition2(sender QObject_ITF, signal string, target QAbstractState_ITF) *QSignalTransition {
	defer qt.Recovering("QState::addTransition")

	if ptr.Pointer() != nil {
		return NewQSignalTransitionFromPointer(C.QState_AddTransition2(ptr.Pointer(), PointerFromQObject(sender), C.CString(signal), PointerFromQAbstractState(target)))
	}
	return nil
}

func (ptr *QState) AddTransition(transition QAbstractTransition_ITF) {
	defer qt.Recovering("QState::addTransition")

	if ptr.Pointer() != nil {
		C.QState_AddTransition(ptr.Pointer(), PointerFromQAbstractTransition(transition))
	}
}

func (ptr *QState) AssignProperty(object QObject_ITF, name string, value QVariant_ITF) {
	defer qt.Recovering("QState::assignProperty")

	if ptr.Pointer() != nil {
		C.QState_AssignProperty(ptr.Pointer(), PointerFromQObject(object), C.CString(name), PointerFromQVariant(value))
	}
}

func (ptr *QState) ChildMode() QState__ChildMode {
	defer qt.Recovering("QState::childMode")

	if ptr.Pointer() != nil {
		return QState__ChildMode(C.QState_ChildMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QState) ConnectChildModeChanged(f func()) {
	defer qt.Recovering("connect QState::childModeChanged")

	if ptr.Pointer() != nil {
		C.QState_ConnectChildModeChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "childModeChanged", f)
	}
}

func (ptr *QState) DisconnectChildModeChanged() {
	defer qt.Recovering("disconnect QState::childModeChanged")

	if ptr.Pointer() != nil {
		C.QState_DisconnectChildModeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "childModeChanged")
	}
}

//export callbackQStateChildModeChanged
func callbackQStateChildModeChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QState::childModeChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "childModeChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QState) ErrorState() *QAbstractState {
	defer qt.Recovering("QState::errorState")

	if ptr.Pointer() != nil {
		return NewQAbstractStateFromPointer(C.QState_ErrorState(ptr.Pointer()))
	}
	return nil
}

func (ptr *QState) ConnectErrorStateChanged(f func()) {
	defer qt.Recovering("connect QState::errorStateChanged")

	if ptr.Pointer() != nil {
		C.QState_ConnectErrorStateChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "errorStateChanged", f)
	}
}

func (ptr *QState) DisconnectErrorStateChanged() {
	defer qt.Recovering("disconnect QState::errorStateChanged")

	if ptr.Pointer() != nil {
		C.QState_DisconnectErrorStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "errorStateChanged")
	}
}

//export callbackQStateErrorStateChanged
func callbackQStateErrorStateChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QState::errorStateChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "errorStateChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QState) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QState::event")

	if ptr.Pointer() != nil {
		return C.QState_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QState) ConnectFinished(f func()) {
	defer qt.Recovering("connect QState::finished")

	if ptr.Pointer() != nil {
		C.QState_ConnectFinished(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "finished", f)
	}
}

func (ptr *QState) DisconnectFinished() {
	defer qt.Recovering("disconnect QState::finished")

	if ptr.Pointer() != nil {
		C.QState_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "finished")
	}
}

//export callbackQStateFinished
func callbackQStateFinished(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QState::finished")

	if signal := qt.GetSignal(C.GoString(ptrName), "finished"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QState) InitialState() *QAbstractState {
	defer qt.Recovering("QState::initialState")

	if ptr.Pointer() != nil {
		return NewQAbstractStateFromPointer(C.QState_InitialState(ptr.Pointer()))
	}
	return nil
}

func (ptr *QState) ConnectInitialStateChanged(f func()) {
	defer qt.Recovering("connect QState::initialStateChanged")

	if ptr.Pointer() != nil {
		C.QState_ConnectInitialStateChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "initialStateChanged", f)
	}
}

func (ptr *QState) DisconnectInitialStateChanged() {
	defer qt.Recovering("disconnect QState::initialStateChanged")

	if ptr.Pointer() != nil {
		C.QState_DisconnectInitialStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "initialStateChanged")
	}
}

//export callbackQStateInitialStateChanged
func callbackQStateInitialStateChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QState::initialStateChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "initialStateChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QState) ConnectOnEntry(f func(event *QEvent)) {
	defer qt.Recovering("connect QState::onEntry")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onEntry", f)
	}
}

func (ptr *QState) DisconnectOnEntry() {
	defer qt.Recovering("disconnect QState::onEntry")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onEntry")
	}
}

//export callbackQStateOnEntry
func callbackQStateOnEntry(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QState::onEntry")

	if signal := qt.GetSignal(C.GoString(ptrName), "onEntry"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQStateFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QState) OnEntry(event QEvent_ITF) {
	defer qt.Recovering("QState::onEntry")

	if ptr.Pointer() != nil {
		C.QState_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QState) OnEntryDefault(event QEvent_ITF) {
	defer qt.Recovering("QState::onEntry")

	if ptr.Pointer() != nil {
		C.QState_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QState) ConnectOnExit(f func(event *QEvent)) {
	defer qt.Recovering("connect QState::onExit")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onExit", f)
	}
}

func (ptr *QState) DisconnectOnExit() {
	defer qt.Recovering("disconnect QState::onExit")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onExit")
	}
}

//export callbackQStateOnExit
func callbackQStateOnExit(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QState::onExit")

	if signal := qt.GetSignal(C.GoString(ptrName), "onExit"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQStateFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QState) OnExit(event QEvent_ITF) {
	defer qt.Recovering("QState::onExit")

	if ptr.Pointer() != nil {
		C.QState_OnExit(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QState) OnExitDefault(event QEvent_ITF) {
	defer qt.Recovering("QState::onExit")

	if ptr.Pointer() != nil {
		C.QState_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QState) ConnectPropertiesAssigned(f func()) {
	defer qt.Recovering("connect QState::propertiesAssigned")

	if ptr.Pointer() != nil {
		C.QState_ConnectPropertiesAssigned(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "propertiesAssigned", f)
	}
}

func (ptr *QState) DisconnectPropertiesAssigned() {
	defer qt.Recovering("disconnect QState::propertiesAssigned")

	if ptr.Pointer() != nil {
		C.QState_DisconnectPropertiesAssigned(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "propertiesAssigned")
	}
}

//export callbackQStatePropertiesAssigned
func callbackQStatePropertiesAssigned(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QState::propertiesAssigned")

	if signal := qt.GetSignal(C.GoString(ptrName), "propertiesAssigned"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QState) RemoveTransition(transition QAbstractTransition_ITF) {
	defer qt.Recovering("QState::removeTransition")

	if ptr.Pointer() != nil {
		C.QState_RemoveTransition(ptr.Pointer(), PointerFromQAbstractTransition(transition))
	}
}

func (ptr *QState) SetChildMode(mode QState__ChildMode) {
	defer qt.Recovering("QState::setChildMode")

	if ptr.Pointer() != nil {
		C.QState_SetChildMode(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QState) SetErrorState(state QAbstractState_ITF) {
	defer qt.Recovering("QState::setErrorState")

	if ptr.Pointer() != nil {
		C.QState_SetErrorState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

func (ptr *QState) SetInitialState(state QAbstractState_ITF) {
	defer qt.Recovering("QState::setInitialState")

	if ptr.Pointer() != nil {
		C.QState_SetInitialState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

func (ptr *QState) DestroyQState() {
	defer qt.Recovering("QState::~QState")

	if ptr.Pointer() != nil {
		C.QState_DestroyQState(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QState) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QState::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QState) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QState::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQStateTimerEvent
func callbackQStateTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QState::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQStateFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QState) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QState::timerEvent")

	if ptr.Pointer() != nil {
		C.QState_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QState) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QState::timerEvent")

	if ptr.Pointer() != nil {
		C.QState_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QState) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QState::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QState) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QState::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQStateChildEvent
func callbackQStateChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QState::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQStateFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QState) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QState::childEvent")

	if ptr.Pointer() != nil {
		C.QState_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QState) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QState::childEvent")

	if ptr.Pointer() != nil {
		C.QState_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QState) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QState::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QState) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QState::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQStateCustomEvent
func callbackQStateCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QState::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQStateFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QState) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QState::customEvent")

	if ptr.Pointer() != nil {
		C.QState_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QState) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QState::customEvent")

	if ptr.Pointer() != nil {
		C.QState_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QStateMachine struct {
	QState
}

type QStateMachine_ITF interface {
	QState_ITF
	QStateMachine_PTR() *QStateMachine
}

func PointerFromQStateMachine(ptr QStateMachine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStateMachine_PTR().Pointer()
	}
	return nil
}

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

func newQStateMachineFromPointer(ptr unsafe.Pointer) *QStateMachine {
	var n = NewQStateMachineFromPointer(ptr)
	for len(n.ObjectName()) < len("QStateMachine_") {
		n.SetObjectName("QStateMachine_" + qt.Identifier())
	}
	return n
}

func (ptr *QStateMachine) QStateMachine_PTR() *QStateMachine {
	return ptr
}

//QStateMachine::Error
type QStateMachine__Error int64

const (
	QStateMachine__NoError                            = QStateMachine__Error(0)
	QStateMachine__NoInitialStateError                = QStateMachine__Error(1)
	QStateMachine__NoDefaultStateInHistoryStateError  = QStateMachine__Error(2)
	QStateMachine__NoCommonAncestorForTransitionError = QStateMachine__Error(3)
)

//QStateMachine::EventPriority
type QStateMachine__EventPriority int64

const (
	QStateMachine__NormalPriority = QStateMachine__EventPriority(0)
	QStateMachine__HighPriority   = QStateMachine__EventPriority(1)
)

func NewQStateMachine(parent QObject_ITF) *QStateMachine {
	defer qt.Recovering("QStateMachine::QStateMachine")

	return newQStateMachineFromPointer(C.QStateMachine_NewQStateMachine(PointerFromQObject(parent)))
}

func NewQStateMachine2(childMode QState__ChildMode, parent QObject_ITF) *QStateMachine {
	defer qt.Recovering("QStateMachine::QStateMachine")

	return newQStateMachineFromPointer(C.QStateMachine_NewQStateMachine2(C.int(childMode), PointerFromQObject(parent)))
}

func (ptr *QStateMachine) AddDefaultAnimation(animation QAbstractAnimation_ITF) {
	defer qt.Recovering("QStateMachine::addDefaultAnimation")

	if ptr.Pointer() != nil {
		C.QStateMachine_AddDefaultAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QStateMachine) AddState(state QAbstractState_ITF) {
	defer qt.Recovering("QStateMachine::addState")

	if ptr.Pointer() != nil {
		C.QStateMachine_AddState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

func (ptr *QStateMachine) ClearError() {
	defer qt.Recovering("QStateMachine::clearError")

	if ptr.Pointer() != nil {
		C.QStateMachine_ClearError(ptr.Pointer())
	}
}

func (ptr *QStateMachine) CancelDelayedEvent(id int) bool {
	defer qt.Recovering("QStateMachine::cancelDelayedEvent")

	if ptr.Pointer() != nil {
		return C.QStateMachine_CancelDelayedEvent(ptr.Pointer(), C.int(id)) != 0
	}
	return false
}

func (ptr *QStateMachine) Error() QStateMachine__Error {
	defer qt.Recovering("QStateMachine::error")

	if ptr.Pointer() != nil {
		return QStateMachine__Error(C.QStateMachine_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStateMachine) ErrorString() string {
	defer qt.Recovering("QStateMachine::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStateMachine_ErrorString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStateMachine) Event(e QEvent_ITF) bool {
	defer qt.Recovering("QStateMachine::event")

	if ptr.Pointer() != nil {
		return C.QStateMachine_Event(ptr.Pointer(), PointerFromQEvent(e)) != 0
	}
	return false
}

func (ptr *QStateMachine) EventFilter(watched QObject_ITF, event QEvent_ITF) bool {
	defer qt.Recovering("QStateMachine::eventFilter")

	if ptr.Pointer() != nil {
		return C.QStateMachine_EventFilter(ptr.Pointer(), PointerFromQObject(watched), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QStateMachine) GlobalRestorePolicy() QState__RestorePolicy {
	defer qt.Recovering("QStateMachine::globalRestorePolicy")

	if ptr.Pointer() != nil {
		return QState__RestorePolicy(C.QStateMachine_GlobalRestorePolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStateMachine) IsAnimated() bool {
	defer qt.Recovering("QStateMachine::isAnimated")

	if ptr.Pointer() != nil {
		return C.QStateMachine_IsAnimated(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStateMachine) IsRunning() bool {
	defer qt.Recovering("QStateMachine::isRunning")

	if ptr.Pointer() != nil {
		return C.QStateMachine_IsRunning(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStateMachine) ConnectOnEntry(f func(event *QEvent)) {
	defer qt.Recovering("connect QStateMachine::onEntry")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onEntry", f)
	}
}

func (ptr *QStateMachine) DisconnectOnEntry() {
	defer qt.Recovering("disconnect QStateMachine::onEntry")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onEntry")
	}
}

//export callbackQStateMachineOnEntry
func callbackQStateMachineOnEntry(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStateMachine::onEntry")

	if signal := qt.GetSignal(C.GoString(ptrName), "onEntry"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQStateMachineFromPointer(ptr).OnEntryDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QStateMachine) OnEntry(event QEvent_ITF) {
	defer qt.Recovering("QStateMachine::onEntry")

	if ptr.Pointer() != nil {
		C.QStateMachine_OnEntry(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QStateMachine) OnEntryDefault(event QEvent_ITF) {
	defer qt.Recovering("QStateMachine::onEntry")

	if ptr.Pointer() != nil {
		C.QStateMachine_OnEntryDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QStateMachine) ConnectOnExit(f func(event *QEvent)) {
	defer qt.Recovering("connect QStateMachine::onExit")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "onExit", f)
	}
}

func (ptr *QStateMachine) DisconnectOnExit() {
	defer qt.Recovering("disconnect QStateMachine::onExit")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "onExit")
	}
}

//export callbackQStateMachineOnExit
func callbackQStateMachineOnExit(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStateMachine::onExit")

	if signal := qt.GetSignal(C.GoString(ptrName), "onExit"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQStateMachineFromPointer(ptr).OnExitDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QStateMachine) OnExit(event QEvent_ITF) {
	defer qt.Recovering("QStateMachine::onExit")

	if ptr.Pointer() != nil {
		C.QStateMachine_OnExit(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QStateMachine) OnExitDefault(event QEvent_ITF) {
	defer qt.Recovering("QStateMachine::onExit")

	if ptr.Pointer() != nil {
		C.QStateMachine_OnExitDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QStateMachine) PostDelayedEvent(event QEvent_ITF, delay int) int {
	defer qt.Recovering("QStateMachine::postDelayedEvent")

	if ptr.Pointer() != nil {
		return int(C.QStateMachine_PostDelayedEvent(ptr.Pointer(), PointerFromQEvent(event), C.int(delay)))
	}
	return 0
}

func (ptr *QStateMachine) PostEvent(event QEvent_ITF, priority QStateMachine__EventPriority) {
	defer qt.Recovering("QStateMachine::postEvent")

	if ptr.Pointer() != nil {
		C.QStateMachine_PostEvent(ptr.Pointer(), PointerFromQEvent(event), C.int(priority))
	}
}

func (ptr *QStateMachine) RemoveDefaultAnimation(animation QAbstractAnimation_ITF) {
	defer qt.Recovering("QStateMachine::removeDefaultAnimation")

	if ptr.Pointer() != nil {
		C.QStateMachine_RemoveDefaultAnimation(ptr.Pointer(), PointerFromQAbstractAnimation(animation))
	}
}

func (ptr *QStateMachine) RemoveState(state QAbstractState_ITF) {
	defer qt.Recovering("QStateMachine::removeState")

	if ptr.Pointer() != nil {
		C.QStateMachine_RemoveState(ptr.Pointer(), PointerFromQAbstractState(state))
	}
}

func (ptr *QStateMachine) ConnectRunningChanged(f func(running bool)) {
	defer qt.Recovering("connect QStateMachine::runningChanged")

	if ptr.Pointer() != nil {
		C.QStateMachine_ConnectRunningChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "runningChanged", f)
	}
}

func (ptr *QStateMachine) DisconnectRunningChanged() {
	defer qt.Recovering("disconnect QStateMachine::runningChanged")

	if ptr.Pointer() != nil {
		C.QStateMachine_DisconnectRunningChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "runningChanged")
	}
}

//export callbackQStateMachineRunningChanged
func callbackQStateMachineRunningChanged(ptr unsafe.Pointer, ptrName *C.char, running C.int) {
	defer qt.Recovering("callback QStateMachine::runningChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "runningChanged"); signal != nil {
		signal.(func(bool))(int(running) != 0)
	}

}

func (ptr *QStateMachine) RunningChanged(running bool) {
	defer qt.Recovering("QStateMachine::runningChanged")

	if ptr.Pointer() != nil {
		C.QStateMachine_RunningChanged(ptr.Pointer(), C.int(qt.GoBoolToInt(running)))
	}
}

func (ptr *QStateMachine) SetAnimated(enabled bool) {
	defer qt.Recovering("QStateMachine::setAnimated")

	if ptr.Pointer() != nil {
		C.QStateMachine_SetAnimated(ptr.Pointer(), C.int(qt.GoBoolToInt(enabled)))
	}
}

func (ptr *QStateMachine) SetGlobalRestorePolicy(restorePolicy QState__RestorePolicy) {
	defer qt.Recovering("QStateMachine::setGlobalRestorePolicy")

	if ptr.Pointer() != nil {
		C.QStateMachine_SetGlobalRestorePolicy(ptr.Pointer(), C.int(restorePolicy))
	}
}

func (ptr *QStateMachine) SetRunning(running bool) {
	defer qt.Recovering("QStateMachine::setRunning")

	if ptr.Pointer() != nil {
		C.QStateMachine_SetRunning(ptr.Pointer(), C.int(qt.GoBoolToInt(running)))
	}
}

func (ptr *QStateMachine) Start() {
	defer qt.Recovering("QStateMachine::start")

	if ptr.Pointer() != nil {
		C.QStateMachine_Start(ptr.Pointer())
	}
}

func (ptr *QStateMachine) ConnectStarted(f func()) {
	defer qt.Recovering("connect QStateMachine::started")

	if ptr.Pointer() != nil {
		C.QStateMachine_ConnectStarted(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "started", f)
	}
}

func (ptr *QStateMachine) DisconnectStarted() {
	defer qt.Recovering("disconnect QStateMachine::started")

	if ptr.Pointer() != nil {
		C.QStateMachine_DisconnectStarted(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "started")
	}
}

//export callbackQStateMachineStarted
func callbackQStateMachineStarted(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QStateMachine::started")

	if signal := qt.GetSignal(C.GoString(ptrName), "started"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QStateMachine) Stop() {
	defer qt.Recovering("QStateMachine::stop")

	if ptr.Pointer() != nil {
		C.QStateMachine_Stop(ptr.Pointer())
	}
}

func (ptr *QStateMachine) ConnectStopped(f func()) {
	defer qt.Recovering("connect QStateMachine::stopped")

	if ptr.Pointer() != nil {
		C.QStateMachine_ConnectStopped(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "stopped", f)
	}
}

func (ptr *QStateMachine) DisconnectStopped() {
	defer qt.Recovering("disconnect QStateMachine::stopped")

	if ptr.Pointer() != nil {
		C.QStateMachine_DisconnectStopped(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "stopped")
	}
}

//export callbackQStateMachineStopped
func callbackQStateMachineStopped(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QStateMachine::stopped")

	if signal := qt.GetSignal(C.GoString(ptrName), "stopped"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QStateMachine) DestroyQStateMachine() {
	defer qt.Recovering("QStateMachine::~QStateMachine")

	if ptr.Pointer() != nil {
		C.QStateMachine_DestroyQStateMachine(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QStateMachine) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QStateMachine::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QStateMachine) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QStateMachine::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQStateMachineTimerEvent
func callbackQStateMachineTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStateMachine::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQStateMachineFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QStateMachine) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QStateMachine::timerEvent")

	if ptr.Pointer() != nil {
		C.QStateMachine_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QStateMachine) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QStateMachine::timerEvent")

	if ptr.Pointer() != nil {
		C.QStateMachine_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QStateMachine) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QStateMachine::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QStateMachine) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QStateMachine::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQStateMachineChildEvent
func callbackQStateMachineChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStateMachine::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQStateMachineFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QStateMachine) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QStateMachine::childEvent")

	if ptr.Pointer() != nil {
		C.QStateMachine_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QStateMachine) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QStateMachine::childEvent")

	if ptr.Pointer() != nil {
		C.QStateMachine_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QStateMachine) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QStateMachine::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QStateMachine) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QStateMachine::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQStateMachineCustomEvent
func callbackQStateMachineCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStateMachine::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQStateMachineFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QStateMachine) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QStateMachine::customEvent")

	if ptr.Pointer() != nil {
		C.QStateMachine_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QStateMachine) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QStateMachine::customEvent")

	if ptr.Pointer() != nil {
		C.QStateMachine_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QStaticPlugin struct {
	ptr unsafe.Pointer
}

type QStaticPlugin_ITF interface {
	QStaticPlugin_PTR() *QStaticPlugin
}

func (p *QStaticPlugin) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QStaticPlugin) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQStaticPlugin(ptr QStaticPlugin_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStaticPlugin_PTR().Pointer()
	}
	return nil
}

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

func newQStaticPluginFromPointer(ptr unsafe.Pointer) *QStaticPlugin {
	var n = NewQStaticPluginFromPointer(ptr)
	return n
}

func (ptr *QStaticPlugin) QStaticPlugin_PTR() *QStaticPlugin {
	return ptr
}

func (ptr *QStaticPlugin) Instance() *QObject {
	defer qt.Recovering("QStaticPlugin::instance")

	if ptr.Pointer() != nil {
		return NewQObjectFromPointer(C.QStaticPlugin_Instance(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStaticPlugin) MetaData() *QJsonObject {
	defer qt.Recovering("QStaticPlugin::metaData")

	if ptr.Pointer() != nil {
		return NewQJsonObjectFromPointer(C.QStaticPlugin_MetaData(ptr.Pointer()))
	}
	return nil
}

type QStorageInfo struct {
	ptr unsafe.Pointer
}

type QStorageInfo_ITF interface {
	QStorageInfo_PTR() *QStorageInfo
}

func (p *QStorageInfo) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QStorageInfo) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQStorageInfo(ptr QStorageInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStorageInfo_PTR().Pointer()
	}
	return nil
}

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

func newQStorageInfoFromPointer(ptr unsafe.Pointer) *QStorageInfo {
	var n = NewQStorageInfoFromPointer(ptr)
	return n
}

func (ptr *QStorageInfo) QStorageInfo_PTR() *QStorageInfo {
	return ptr
}

func NewQStorageInfo() *QStorageInfo {
	defer qt.Recovering("QStorageInfo::QStorageInfo")

	return newQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo())
}

func NewQStorageInfo3(dir QDir_ITF) *QStorageInfo {
	defer qt.Recovering("QStorageInfo::QStorageInfo")

	return newQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo3(PointerFromQDir(dir)))
}

func NewQStorageInfo4(other QStorageInfo_ITF) *QStorageInfo {
	defer qt.Recovering("QStorageInfo::QStorageInfo")

	return newQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo4(PointerFromQStorageInfo(other)))
}

func NewQStorageInfo2(path string) *QStorageInfo {
	defer qt.Recovering("QStorageInfo::QStorageInfo")

	return newQStorageInfoFromPointer(C.QStorageInfo_NewQStorageInfo2(C.CString(path)))
}

func (ptr *QStorageInfo) BytesAvailable() int64 {
	defer qt.Recovering("QStorageInfo::bytesAvailable")

	if ptr.Pointer() != nil {
		return int64(C.QStorageInfo_BytesAvailable(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStorageInfo) BytesFree() int64 {
	defer qt.Recovering("QStorageInfo::bytesFree")

	if ptr.Pointer() != nil {
		return int64(C.QStorageInfo_BytesFree(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStorageInfo) BytesTotal() int64 {
	defer qt.Recovering("QStorageInfo::bytesTotal")

	if ptr.Pointer() != nil {
		return int64(C.QStorageInfo_BytesTotal(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStorageInfo) Device() string {
	defer qt.Recovering("QStorageInfo::device")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStorageInfo_Device(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStorageInfo) DisplayName() string {
	defer qt.Recovering("QStorageInfo::displayName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStorageInfo_DisplayName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStorageInfo) FileSystemType() string {
	defer qt.Recovering("QStorageInfo::fileSystemType")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStorageInfo_FileSystemType(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStorageInfo) IsReadOnly() bool {
	defer qt.Recovering("QStorageInfo::isReadOnly")

	if ptr.Pointer() != nil {
		return C.QStorageInfo_IsReadOnly(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStorageInfo) IsReady() bool {
	defer qt.Recovering("QStorageInfo::isReady")

	if ptr.Pointer() != nil {
		return C.QStorageInfo_IsReady(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStorageInfo) IsRoot() bool {
	defer qt.Recovering("QStorageInfo::isRoot")

	if ptr.Pointer() != nil {
		return C.QStorageInfo_IsRoot(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStorageInfo) IsValid() bool {
	defer qt.Recovering("QStorageInfo::isValid")

	if ptr.Pointer() != nil {
		return C.QStorageInfo_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStorageInfo) Name() string {
	defer qt.Recovering("QStorageInfo::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStorageInfo_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStorageInfo) Refresh() {
	defer qt.Recovering("QStorageInfo::refresh")

	if ptr.Pointer() != nil {
		C.QStorageInfo_Refresh(ptr.Pointer())
	}
}

func QStorageInfo_Root() *QStorageInfo {
	defer qt.Recovering("QStorageInfo::root")

	return NewQStorageInfoFromPointer(C.QStorageInfo_QStorageInfo_Root())
}

func (ptr *QStorageInfo) RootPath() string {
	defer qt.Recovering("QStorageInfo::rootPath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStorageInfo_RootPath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStorageInfo) SetPath(path string) {
	defer qt.Recovering("QStorageInfo::setPath")

	if ptr.Pointer() != nil {
		C.QStorageInfo_SetPath(ptr.Pointer(), C.CString(path))
	}
}

func (ptr *QStorageInfo) Swap(other QStorageInfo_ITF) {
	defer qt.Recovering("QStorageInfo::swap")

	if ptr.Pointer() != nil {
		C.QStorageInfo_Swap(ptr.Pointer(), PointerFromQStorageInfo(other))
	}
}

func (ptr *QStorageInfo) DestroyQStorageInfo() {
	defer qt.Recovering("QStorageInfo::~QStorageInfo")

	if ptr.Pointer() != nil {
		C.QStorageInfo_DestroyQStorageInfo(ptr.Pointer())
	}
}

type QString struct {
	ptr unsafe.Pointer
}

type QString_ITF interface {
	QString_PTR() *QString
}

func (p *QString) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QString) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQString(ptr QString_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QString_PTR().Pointer()
	}
	return nil
}

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

func newQStringFromPointer(ptr unsafe.Pointer) *QString {
	var n = NewQStringFromPointer(ptr)
	return n
}

func (ptr *QString) QString_PTR() *QString {
	return ptr
}

//QString::NormalizationForm
type QString__NormalizationForm int64

const (
	QString__NormalizationForm_D  = QString__NormalizationForm(0)
	QString__NormalizationForm_C  = QString__NormalizationForm(1)
	QString__NormalizationForm_KD = QString__NormalizationForm(2)
	QString__NormalizationForm_KC = QString__NormalizationForm(3)
)

//QString::SectionFlag
type QString__SectionFlag int64

const (
	QString__SectionDefault             = QString__SectionFlag(0x00)
	QString__SectionSkipEmpty           = QString__SectionFlag(0x01)
	QString__SectionIncludeLeadingSep   = QString__SectionFlag(0x02)
	QString__SectionIncludeTrailingSep  = QString__SectionFlag(0x04)
	QString__SectionCaseInsensitiveSeps = QString__SectionFlag(0x08)
)

//QString::SplitBehavior
type QString__SplitBehavior int64

const (
	QString__KeepEmptyParts = QString__SplitBehavior(0)
	QString__SkipEmptyParts = QString__SplitBehavior(1)
)

type QStringList struct {
	QList
}

type QStringList_ITF interface {
	QList_ITF
	QStringList_PTR() *QStringList
}

func PointerFromQStringList(ptr QStringList_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringList_PTR().Pointer()
	}
	return nil
}

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

func newQStringListFromPointer(ptr unsafe.Pointer) *QStringList {
	var n = NewQStringListFromPointer(ptr)
	return n
}

func (ptr *QStringList) QStringList_PTR() *QStringList {
	return ptr
}

type QStringListModel struct {
	QAbstractListModel
}

type QStringListModel_ITF interface {
	QAbstractListModel_ITF
	QStringListModel_PTR() *QStringListModel
}

func PointerFromQStringListModel(ptr QStringListModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringListModel_PTR().Pointer()
	}
	return nil
}

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

func newQStringListModelFromPointer(ptr unsafe.Pointer) *QStringListModel {
	var n = NewQStringListModelFromPointer(ptr)
	for len(n.ObjectName()) < len("QStringListModel_") {
		n.SetObjectName("QStringListModel_" + qt.Identifier())
	}
	return n
}

func (ptr *QStringListModel) QStringListModel_PTR() *QStringListModel {
	return ptr
}

func (ptr *QStringListModel) Data(index QModelIndex_ITF, role int) *QVariant {
	defer qt.Recovering("QStringListModel::data")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QStringListModel_Data(ptr.Pointer(), PointerFromQModelIndex(index), C.int(role)))
	}
	return nil
}

func (ptr *QStringListModel) Flags(index QModelIndex_ITF) Qt__ItemFlag {
	defer qt.Recovering("QStringListModel::flags")

	if ptr.Pointer() != nil {
		return Qt__ItemFlag(C.QStringListModel_Flags(ptr.Pointer(), PointerFromQModelIndex(index)))
	}
	return 0
}

func (ptr *QStringListModel) InsertRows(row int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QStringListModel::insertRows")

	if ptr.Pointer() != nil {
		return C.QStringListModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStringListModel) RemoveRows(row int, count int, parent QModelIndex_ITF) bool {
	defer qt.Recovering("QStringListModel::removeRows")

	if ptr.Pointer() != nil {
		return C.QStringListModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStringListModel) RowCount(parent QModelIndex_ITF) int {
	defer qt.Recovering("QStringListModel::rowCount")

	if ptr.Pointer() != nil {
		return int(C.QStringListModel_RowCount(ptr.Pointer(), PointerFromQModelIndex(parent)))
	}
	return 0
}

func (ptr *QStringListModel) SetData(index QModelIndex_ITF, value QVariant_ITF, role int) bool {
	defer qt.Recovering("QStringListModel::setData")

	if ptr.Pointer() != nil {
		return C.QStringListModel_SetData(ptr.Pointer(), PointerFromQModelIndex(index), PointerFromQVariant(value), C.int(role)) != 0
	}
	return false
}

func (ptr *QStringListModel) SetStringList(strin []string) {
	defer qt.Recovering("QStringListModel::setStringList")

	if ptr.Pointer() != nil {
		C.QStringListModel_SetStringList(ptr.Pointer(), C.CString(strings.Join(strin, "|")))
	}
}

func (ptr *QStringListModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
	defer qt.Recovering("connect QStringListModel::sort")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
	}
}

func (ptr *QStringListModel) DisconnectSort() {
	defer qt.Recovering("disconnect QStringListModel::sort")

	if ptr.Pointer() != nil {

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

//export callbackQStringListModelSort
func callbackQStringListModelSort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
	defer qt.Recovering("callback QStringListModel::sort")

	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
	} else {
		NewQStringListModelFromPointer(ptr).SortDefault(int(column), Qt__SortOrder(order))
	}
}

func (ptr *QStringListModel) Sort(column int, order Qt__SortOrder) {
	defer qt.Recovering("QStringListModel::sort")

	if ptr.Pointer() != nil {
		C.QStringListModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QStringListModel) SortDefault(column int, order Qt__SortOrder) {
	defer qt.Recovering("QStringListModel::sort")

	if ptr.Pointer() != nil {
		C.QStringListModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QStringListModel) StringList() []string {
	defer qt.Recovering("QStringListModel::stringList")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QStringListModel_StringList(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QStringListModel) SupportedDropActions() Qt__DropAction {
	defer qt.Recovering("QStringListModel::supportedDropActions")

	if ptr.Pointer() != nil {
		return Qt__DropAction(C.QStringListModel_SupportedDropActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStringListModel) ConnectRevert(f func()) {
	defer qt.Recovering("connect QStringListModel::revert")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
	}
}

func (ptr *QStringListModel) DisconnectRevert() {
	defer qt.Recovering("disconnect QStringListModel::revert")

	if ptr.Pointer() != nil {

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

//export callbackQStringListModelRevert
func callbackQStringListModelRevert(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QStringListModel::revert")

	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QStringListModel) Revert() {
	defer qt.Recovering("QStringListModel::revert")

	if ptr.Pointer() != nil {
		C.QStringListModel_Revert(ptr.Pointer())
	}
}

func (ptr *QStringListModel) RevertDefault() {
	defer qt.Recovering("QStringListModel::revert")

	if ptr.Pointer() != nil {
		C.QStringListModel_RevertDefault(ptr.Pointer())
	}
}

func (ptr *QStringListModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QStringListModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QStringListModel) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QStringListModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQStringListModelTimerEvent
func callbackQStringListModelTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStringListModel::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQStringListModelFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QStringListModel) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QStringListModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QStringListModel_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QStringListModel) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QStringListModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QStringListModel_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QStringListModel) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QStringListModel::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QStringListModel) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QStringListModel::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQStringListModelChildEvent
func callbackQStringListModelChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStringListModel::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQStringListModelFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QStringListModel) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QStringListModel::childEvent")

	if ptr.Pointer() != nil {
		C.QStringListModel_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QStringListModel) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QStringListModel::childEvent")

	if ptr.Pointer() != nil {
		C.QStringListModel_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QStringListModel) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QStringListModel::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QStringListModel) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QStringListModel::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQStringListModelCustomEvent
func callbackQStringListModelCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStringListModel::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQStringListModelFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QStringListModel) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QStringListModel::customEvent")

	if ptr.Pointer() != nil {
		C.QStringListModel_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QStringListModel) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QStringListModel::customEvent")

	if ptr.Pointer() != nil {
		C.QStringListModel_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QStringMatcher struct {
	ptr unsafe.Pointer
}

type QStringMatcher_ITF interface {
	QStringMatcher_PTR() *QStringMatcher
}

func (p *QStringMatcher) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QStringMatcher) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQStringMatcher(ptr QStringMatcher_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringMatcher_PTR().Pointer()
	}
	return nil
}

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

func newQStringMatcherFromPointer(ptr unsafe.Pointer) *QStringMatcher {
	var n = NewQStringMatcherFromPointer(ptr)
	return n
}

func (ptr *QStringMatcher) QStringMatcher_PTR() *QStringMatcher {
	return ptr
}

func NewQStringMatcher3(uc QChar_ITF, length int, cs Qt__CaseSensitivity) *QStringMatcher {
	defer qt.Recovering("QStringMatcher::QStringMatcher")

	return newQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher3(PointerFromQChar(uc), C.int(length), C.int(cs)))
}

func (ptr *QStringMatcher) Pattern() string {
	defer qt.Recovering("QStringMatcher::pattern")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStringMatcher_Pattern(ptr.Pointer()))
	}
	return ""
}

func NewQStringMatcher() *QStringMatcher {
	defer qt.Recovering("QStringMatcher::QStringMatcher")

	return newQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher())
}

func NewQStringMatcher2(pattern string, cs Qt__CaseSensitivity) *QStringMatcher {
	defer qt.Recovering("QStringMatcher::QStringMatcher")

	return newQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher2(C.CString(pattern), C.int(cs)))
}

func NewQStringMatcher4(other QStringMatcher_ITF) *QStringMatcher {
	defer qt.Recovering("QStringMatcher::QStringMatcher")

	return newQStringMatcherFromPointer(C.QStringMatcher_NewQStringMatcher4(PointerFromQStringMatcher(other)))
}

func (ptr *QStringMatcher) CaseSensitivity() Qt__CaseSensitivity {
	defer qt.Recovering("QStringMatcher::caseSensitivity")

	if ptr.Pointer() != nil {
		return Qt__CaseSensitivity(C.QStringMatcher_CaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStringMatcher) IndexIn2(str QChar_ITF, length int, from int) int {
	defer qt.Recovering("QStringMatcher::indexIn")

	if ptr.Pointer() != nil {
		return int(C.QStringMatcher_IndexIn2(ptr.Pointer(), PointerFromQChar(str), C.int(length), C.int(from)))
	}
	return 0
}

func (ptr *QStringMatcher) IndexIn(str string, from int) int {
	defer qt.Recovering("QStringMatcher::indexIn")

	if ptr.Pointer() != nil {
		return int(C.QStringMatcher_IndexIn(ptr.Pointer(), C.CString(str), C.int(from)))
	}
	return 0
}

func (ptr *QStringMatcher) SetCaseSensitivity(cs Qt__CaseSensitivity) {
	defer qt.Recovering("QStringMatcher::setCaseSensitivity")

	if ptr.Pointer() != nil {
		C.QStringMatcher_SetCaseSensitivity(ptr.Pointer(), C.int(cs))
	}
}

func (ptr *QStringMatcher) SetPattern(pattern string) {
	defer qt.Recovering("QStringMatcher::setPattern")

	if ptr.Pointer() != nil {
		C.QStringMatcher_SetPattern(ptr.Pointer(), C.CString(pattern))
	}
}

func (ptr *QStringMatcher) DestroyQStringMatcher() {
	defer qt.Recovering("QStringMatcher::~QStringMatcher")

	if ptr.Pointer() != nil {
		C.QStringMatcher_DestroyQStringMatcher(ptr.Pointer())
	}
}

type QStringRef struct {
	ptr unsafe.Pointer
}

type QStringRef_ITF interface {
	QStringRef_PTR() *QStringRef
}

func (p *QStringRef) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QStringRef) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQStringRef(ptr QStringRef_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStringRef_PTR().Pointer()
	}
	return nil
}

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

func newQStringRefFromPointer(ptr unsafe.Pointer) *QStringRef {
	var n = NewQStringRefFromPointer(ptr)
	return n
}

func (ptr *QStringRef) QStringRef_PTR() *QStringRef {
	return ptr
}

func (ptr *QStringRef) Left(n int) *QStringRef {
	defer qt.Recovering("QStringRef::left")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QStringRef_Left(ptr.Pointer(), C.int(n)))
	}
	return nil
}

func (ptr *QStringRef) Mid(position int, n int) *QStringRef {
	defer qt.Recovering("QStringRef::mid")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QStringRef_Mid(ptr.Pointer(), C.int(position), C.int(n)))
	}
	return nil
}

func (ptr *QStringRef) Right(n int) *QStringRef {
	defer qt.Recovering("QStringRef::right")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QStringRef_Right(ptr.Pointer(), C.int(n)))
	}
	return nil
}

func (ptr *QStringRef) AppendTo(stri string) *QStringRef {
	defer qt.Recovering("QStringRef::appendTo")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QStringRef_AppendTo(ptr.Pointer(), C.CString(stri)))
	}
	return nil
}

func (ptr *QStringRef) Begin() *QChar {
	defer qt.Recovering("QStringRef::begin")

	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_Begin(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) Cbegin() *QChar {
	defer qt.Recovering("QStringRef::cbegin")

	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_Cbegin(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) Cend() *QChar {
	defer qt.Recovering("QStringRef::cend")

	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_Cend(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) Clear() {
	defer qt.Recovering("QStringRef::clear")

	if ptr.Pointer() != nil {
		C.QStringRef_Clear(ptr.Pointer())
	}
}

func QStringRef_Compare3(s1 QStringRef_ITF, s2 QLatin1String_ITF, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::compare")

	return int(C.QStringRef_QStringRef_Compare3(PointerFromQStringRef(s1), PointerFromQLatin1String(s2), C.int(cs)))
}

func QStringRef_Compare(s1 QStringRef_ITF, s2 string, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::compare")

	return int(C.QStringRef_QStringRef_Compare(PointerFromQStringRef(s1), C.CString(s2), C.int(cs)))
}

func QStringRef_Compare2(s1 QStringRef_ITF, s2 QStringRef_ITF, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::compare")

	return int(C.QStringRef_QStringRef_Compare2(PointerFromQStringRef(s1), PointerFromQStringRef(s2), C.int(cs)))
}

func (ptr *QStringRef) Compare6(other QLatin1String_ITF, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::compare")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Compare6(ptr.Pointer(), PointerFromQLatin1String(other), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) Compare4(other string, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::compare")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Compare4(ptr.Pointer(), C.CString(other), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) Compare5(other QStringRef_ITF, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::compare")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Compare5(ptr.Pointer(), PointerFromQStringRef(other), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) ConstData() *QChar {
	defer qt.Recovering("QStringRef::constData")

	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_ConstData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) Contains2(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::contains")

	if ptr.Pointer() != nil {
		return C.QStringRef_Contains2(ptr.Pointer(), PointerFromQChar(ch), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) Contains4(str QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::contains")

	if ptr.Pointer() != nil {
		return C.QStringRef_Contains4(ptr.Pointer(), PointerFromQLatin1String(str), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) Contains(str string, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::contains")

	if ptr.Pointer() != nil {
		return C.QStringRef_Contains(ptr.Pointer(), C.CString(str), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) Contains3(str QStringRef_ITF, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::contains")

	if ptr.Pointer() != nil {
		return C.QStringRef_Contains3(ptr.Pointer(), PointerFromQStringRef(str), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) Count() int {
	defer qt.Recovering("QStringRef::count")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Count(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStringRef) Count3(ch QChar_ITF, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::count")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Count3(ptr.Pointer(), PointerFromQChar(ch), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) Count2(str string, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::count")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Count2(ptr.Pointer(), C.CString(str), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) Count4(str QStringRef_ITF, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::count")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Count4(ptr.Pointer(), PointerFromQStringRef(str), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) Data() *QChar {
	defer qt.Recovering("QStringRef::data")

	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_Data(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) End() *QChar {
	defer qt.Recovering("QStringRef::end")

	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_End(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) EndsWith2(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::endsWith")

	if ptr.Pointer() != nil {
		return C.QStringRef_EndsWith2(ptr.Pointer(), PointerFromQChar(ch), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) EndsWith3(str QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::endsWith")

	if ptr.Pointer() != nil {
		return C.QStringRef_EndsWith3(ptr.Pointer(), PointerFromQLatin1String(str), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) EndsWith(str string, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::endsWith")

	if ptr.Pointer() != nil {
		return C.QStringRef_EndsWith(ptr.Pointer(), C.CString(str), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) EndsWith4(str QStringRef_ITF, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::endsWith")

	if ptr.Pointer() != nil {
		return C.QStringRef_EndsWith4(ptr.Pointer(), PointerFromQStringRef(str), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) IndexOf3(ch QChar_ITF, from int, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::indexOf")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_IndexOf3(ptr.Pointer(), PointerFromQChar(ch), C.int(from), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) IndexOf2(str QLatin1String_ITF, from int, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::indexOf")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_IndexOf2(ptr.Pointer(), PointerFromQLatin1String(str), C.int(from), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) IndexOf(str string, from int, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::indexOf")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_IndexOf(ptr.Pointer(), C.CString(str), C.int(from), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) IndexOf4(str QStringRef_ITF, from int, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::indexOf")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_IndexOf4(ptr.Pointer(), PointerFromQStringRef(str), C.int(from), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) IsEmpty() bool {
	defer qt.Recovering("QStringRef::isEmpty")

	if ptr.Pointer() != nil {
		return C.QStringRef_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStringRef) IsNull() bool {
	defer qt.Recovering("QStringRef::isNull")

	if ptr.Pointer() != nil {
		return C.QStringRef_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStringRef) LastIndexOf2(ch QChar_ITF, from int, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::lastIndexOf")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_LastIndexOf2(ptr.Pointer(), PointerFromQChar(ch), C.int(from), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) LastIndexOf3(str QLatin1String_ITF, from int, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::lastIndexOf")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_LastIndexOf3(ptr.Pointer(), PointerFromQLatin1String(str), C.int(from), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) LastIndexOf(str string, from int, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::lastIndexOf")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_LastIndexOf(ptr.Pointer(), C.CString(str), C.int(from), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) LastIndexOf4(str QStringRef_ITF, from int, cs Qt__CaseSensitivity) int {
	defer qt.Recovering("QStringRef::lastIndexOf")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_LastIndexOf4(ptr.Pointer(), PointerFromQStringRef(str), C.int(from), C.int(cs)))
	}
	return 0
}

func (ptr *QStringRef) Length() int {
	defer qt.Recovering("QStringRef::length")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Length(ptr.Pointer()))
	}
	return 0
}

func QStringRef_LocaleAwareCompare(s1 QStringRef_ITF, s2 string) int {
	defer qt.Recovering("QStringRef::localeAwareCompare")

	return int(C.QStringRef_QStringRef_LocaleAwareCompare(PointerFromQStringRef(s1), C.CString(s2)))
}

func QStringRef_LocaleAwareCompare2(s1 QStringRef_ITF, s2 QStringRef_ITF) int {
	defer qt.Recovering("QStringRef::localeAwareCompare")

	return int(C.QStringRef_QStringRef_LocaleAwareCompare2(PointerFromQStringRef(s1), PointerFromQStringRef(s2)))
}

func (ptr *QStringRef) LocaleAwareCompare3(other string) int {
	defer qt.Recovering("QStringRef::localeAwareCompare")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_LocaleAwareCompare3(ptr.Pointer(), C.CString(other)))
	}
	return 0
}

func (ptr *QStringRef) LocaleAwareCompare4(other QStringRef_ITF) int {
	defer qt.Recovering("QStringRef::localeAwareCompare")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_LocaleAwareCompare4(ptr.Pointer(), PointerFromQStringRef(other)))
	}
	return 0
}

func (ptr *QStringRef) Position() int {
	defer qt.Recovering("QStringRef::position")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Position(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStringRef) Size() int {
	defer qt.Recovering("QStringRef::size")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_Size(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStringRef) StartsWith4(ch QChar_ITF, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::startsWith")

	if ptr.Pointer() != nil {
		return C.QStringRef_StartsWith4(ptr.Pointer(), PointerFromQChar(ch), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) StartsWith2(str QLatin1String_ITF, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::startsWith")

	if ptr.Pointer() != nil {
		return C.QStringRef_StartsWith2(ptr.Pointer(), PointerFromQLatin1String(str), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) StartsWith(str string, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::startsWith")

	if ptr.Pointer() != nil {
		return C.QStringRef_StartsWith(ptr.Pointer(), C.CString(str), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) StartsWith3(str QStringRef_ITF, cs Qt__CaseSensitivity) bool {
	defer qt.Recovering("QStringRef::startsWith")

	if ptr.Pointer() != nil {
		return C.QStringRef_StartsWith3(ptr.Pointer(), PointerFromQStringRef(str), C.int(cs)) != 0
	}
	return false
}

func (ptr *QStringRef) String() string {
	defer qt.Recovering("QStringRef::string")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStringRef_String(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStringRef) ToInt(ok bool, base int) int {
	defer qt.Recovering("QStringRef::toInt")

	if ptr.Pointer() != nil {
		return int(C.QStringRef_ToInt(ptr.Pointer(), C.int(qt.GoBoolToInt(ok)), C.int(base)))
	}
	return 0
}

func (ptr *QStringRef) ToLatin1() string {
	defer qt.Recovering("QStringRef::toLatin1")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStringRef_ToLatin1(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStringRef) ToLocal8Bit() string {
	defer qt.Recovering("QStringRef::toLocal8Bit")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStringRef_ToLocal8Bit(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStringRef) ToString() string {
	defer qt.Recovering("QStringRef::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStringRef_ToString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStringRef) ToUtf8() string {
	defer qt.Recovering("QStringRef::toUtf8")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStringRef_ToUtf8(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStringRef) Trimmed() *QStringRef {
	defer qt.Recovering("QStringRef::trimmed")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QStringRef_Trimmed(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) Unicode() *QChar {
	defer qt.Recovering("QStringRef::unicode")

	if ptr.Pointer() != nil {
		return NewQCharFromPointer(C.QStringRef_Unicode(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStringRef) DestroyQStringRef() {
	defer qt.Recovering("QStringRef::~QStringRef")

	if ptr.Pointer() != nil {
		C.QStringRef_DestroyQStringRef(ptr.Pointer())
	}
}

type QSysInfo struct {
	ptr unsafe.Pointer
}

type QSysInfo_ITF interface {
	QSysInfo_PTR() *QSysInfo
}

func (p *QSysInfo) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSysInfo) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSysInfo(ptr QSysInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSysInfo_PTR().Pointer()
	}
	return nil
}

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

func newQSysInfoFromPointer(ptr unsafe.Pointer) *QSysInfo {
	var n = NewQSysInfoFromPointer(ptr)
	return n
}

func (ptr *QSysInfo) QSysInfo_PTR() *QSysInfo {
	return ptr
}

//QSysInfo::Endian
type QSysInfo__Endian int64

const (
	QSysInfo__BigEndian    = QSysInfo__Endian(0)
	QSysInfo__LittleEndian = QSysInfo__Endian(1)
)

//QSysInfo::MacVersion
type QSysInfo__MacVersion int64

var (
	QSysInfo__MV_None         = QSysInfo__MacVersion(0xffff)
	QSysInfo__MV_Unknown      = QSysInfo__MacVersion(0x0000)
	QSysInfo__MV_9            = QSysInfo__MacVersion(0x0001)
	QSysInfo__MV_10_0         = QSysInfo__MacVersion(0x0002)
	QSysInfo__MV_10_1         = QSysInfo__MacVersion(0x0003)
	QSysInfo__MV_10_2         = QSysInfo__MacVersion(0x0004)
	QSysInfo__MV_10_3         = QSysInfo__MacVersion(0x0005)
	QSysInfo__MV_10_4         = QSysInfo__MacVersion(0x0006)
	QSysInfo__MV_10_5         = QSysInfo__MacVersion(0x0007)
	QSysInfo__MV_10_6         = QSysInfo__MacVersion(0x0008)
	QSysInfo__MV_10_7         = QSysInfo__MacVersion(0x0009)
	QSysInfo__MV_10_8         = QSysInfo__MacVersion(0x000A)
	QSysInfo__MV_10_9         = QSysInfo__MacVersion(0x000B)
	QSysInfo__MV_10_10        = QSysInfo__MacVersion(0x000C)
	QSysInfo__MV_10_11        = QSysInfo__MacVersion(0x000D)
	QSysInfo__MV_CHEETAH      = QSysInfo__MacVersion(QSysInfo__MV_10_0)
	QSysInfo__MV_PUMA         = QSysInfo__MacVersion(QSysInfo__MV_10_1)
	QSysInfo__MV_JAGUAR       = QSysInfo__MacVersion(QSysInfo__MV_10_2)
	QSysInfo__MV_PANTHER      = QSysInfo__MacVersion(QSysInfo__MV_10_3)
	QSysInfo__MV_TIGER        = QSysInfo__MacVersion(QSysInfo__MV_10_4)
	QSysInfo__MV_LEOPARD      = QSysInfo__MacVersion(QSysInfo__MV_10_5)
	QSysInfo__MV_SNOWLEOPARD  = QSysInfo__MacVersion(QSysInfo__MV_10_6)
	QSysInfo__MV_LION         = QSysInfo__MacVersion(QSysInfo__MV_10_7)
	QSysInfo__MV_MOUNTAINLION = QSysInfo__MacVersion(QSysInfo__MV_10_8)
	QSysInfo__MV_MAVERICKS    = QSysInfo__MacVersion(QSysInfo__MV_10_9)
	QSysInfo__MV_YOSEMITE     = QSysInfo__MacVersion(QSysInfo__MV_10_10)
	QSysInfo__MV_ELCAPITAN    = QSysInfo__MacVersion(QSysInfo__MV_10_11)
	QSysInfo__MV_IOS          = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_Type())
	QSysInfo__MV_IOS_4_3      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_4_3_Type())
	QSysInfo__MV_IOS_5_0      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_5_0_Type())
	QSysInfo__MV_IOS_5_1      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_5_1_Type())
	QSysInfo__MV_IOS_6_0      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_6_0_Type())
	QSysInfo__MV_IOS_6_1      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_6_1_Type())
	QSysInfo__MV_IOS_7_0      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_7_0_Type())
	QSysInfo__MV_IOS_7_1      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_7_1_Type())
	QSysInfo__MV_IOS_8_0      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_0_Type())
	QSysInfo__MV_IOS_8_1      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_1_Type())
	QSysInfo__MV_IOS_8_2      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_2_Type())
	QSysInfo__MV_IOS_8_3      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_3_Type())
	QSysInfo__MV_IOS_8_4      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_8_4_Type())
	QSysInfo__MV_IOS_9_0      = QSysInfo__MacVersion(C.QSysInfo_MV_IOS_9_0_Type())
)

//QSysInfo::Sizes
type QSysInfo__Sizes int64

var (
	QSysInfo__WordSize = QSysInfo__Sizes(C.QSysInfo_WordSize_Type())
)

//QSysInfo::WinVersion
type QSysInfo__WinVersion int64

const (
	QSysInfo__WV_None       = QSysInfo__WinVersion(0x0000)
	QSysInfo__WV_32s        = QSysInfo__WinVersion(0x0001)
	QSysInfo__WV_95         = QSysInfo__WinVersion(0x0002)
	QSysInfo__WV_98         = QSysInfo__WinVersion(0x0003)
	QSysInfo__WV_Me         = QSysInfo__WinVersion(0x0004)
	QSysInfo__WV_DOS_based  = QSysInfo__WinVersion(0x000f)
	QSysInfo__WV_NT         = QSysInfo__WinVersion(0x0010)
	QSysInfo__WV_2000       = QSysInfo__WinVersion(0x0020)
	QSysInfo__WV_XP         = QSysInfo__WinVersion(0x0030)
	QSysInfo__WV_2003       = QSysInfo__WinVersion(0x0040)
	QSysInfo__WV_VISTA      = QSysInfo__WinVersion(0x0080)
	QSysInfo__WV_WINDOWS7   = QSysInfo__WinVersion(0x0090)
	QSysInfo__WV_WINDOWS8   = QSysInfo__WinVersion(0x00a0)
	QSysInfo__WV_WINDOWS8_1 = QSysInfo__WinVersion(0x00b0)
	QSysInfo__WV_WINDOWS10  = QSysInfo__WinVersion(0x00c0)
	QSysInfo__WV_NT_based   = QSysInfo__WinVersion(0x00f0)
	QSysInfo__WV_4_0        = QSysInfo__WinVersion(QSysInfo__WV_NT)
	QSysInfo__WV_5_0        = QSysInfo__WinVersion(QSysInfo__WV_2000)
	QSysInfo__WV_5_1        = QSysInfo__WinVersion(QSysInfo__WV_XP)
	QSysInfo__WV_5_2        = QSysInfo__WinVersion(QSysInfo__WV_2003)
	QSysInfo__WV_6_0        = QSysInfo__WinVersion(QSysInfo__WV_VISTA)
	QSysInfo__WV_6_1        = QSysInfo__WinVersion(QSysInfo__WV_WINDOWS7)
	QSysInfo__WV_6_2        = QSysInfo__WinVersion(QSysInfo__WV_WINDOWS8)
	QSysInfo__WV_6_3        = QSysInfo__WinVersion(QSysInfo__WV_WINDOWS8_1)
	QSysInfo__WV_10_0       = QSysInfo__WinVersion(QSysInfo__WV_WINDOWS10)
	QSysInfo__WV_CE         = QSysInfo__WinVersion(0x0100)
	QSysInfo__WV_CENET      = QSysInfo__WinVersion(0x0200)
	QSysInfo__WV_CE_5       = QSysInfo__WinVersion(0x0300)
	QSysInfo__WV_CE_6       = QSysInfo__WinVersion(0x0400)
	QSysInfo__WV_CE_based   = QSysInfo__WinVersion(0x0f00)
)

func QSysInfo_MacVersion() QSysInfo__MacVersion {
	defer qt.Recovering("QSysInfo::macVersion")

	return QSysInfo__MacVersion(C.QSysInfo_QSysInfo_MacVersion())
}

func QSysInfo_BuildAbi() string {
	defer qt.Recovering("QSysInfo::buildAbi")

	return C.GoString(C.QSysInfo_QSysInfo_BuildAbi())
}

func QSysInfo_BuildCpuArchitecture() string {
	defer qt.Recovering("QSysInfo::buildCpuArchitecture")

	return C.GoString(C.QSysInfo_QSysInfo_BuildCpuArchitecture())
}

func QSysInfo_CurrentCpuArchitecture() string {
	defer qt.Recovering("QSysInfo::currentCpuArchitecture")

	return C.GoString(C.QSysInfo_QSysInfo_CurrentCpuArchitecture())
}

func QSysInfo_KernelType() string {
	defer qt.Recovering("QSysInfo::kernelType")

	return C.GoString(C.QSysInfo_QSysInfo_KernelType())
}

func QSysInfo_KernelVersion() string {
	defer qt.Recovering("QSysInfo::kernelVersion")

	return C.GoString(C.QSysInfo_QSysInfo_KernelVersion())
}

func QSysInfo_PrettyProductName() string {
	defer qt.Recovering("QSysInfo::prettyProductName")

	return C.GoString(C.QSysInfo_QSysInfo_PrettyProductName())
}

func QSysInfo_ProductType() string {
	defer qt.Recovering("QSysInfo::productType")

	return C.GoString(C.QSysInfo_QSysInfo_ProductType())
}

func QSysInfo_ProductVersion() string {
	defer qt.Recovering("QSysInfo::productVersion")

	return C.GoString(C.QSysInfo_QSysInfo_ProductVersion())
}

func QSysInfo_WindowsVersion() QSysInfo__WinVersion {
	defer qt.Recovering("QSysInfo::windowsVersion")

	return QSysInfo__WinVersion(C.QSysInfo_QSysInfo_WindowsVersion())
}

type QSystemSemaphore struct {
	ptr unsafe.Pointer
}

type QSystemSemaphore_ITF interface {
	QSystemSemaphore_PTR() *QSystemSemaphore
}

func (p *QSystemSemaphore) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSystemSemaphore) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSystemSemaphore(ptr QSystemSemaphore_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSystemSemaphore_PTR().Pointer()
	}
	return nil
}

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

func newQSystemSemaphoreFromPointer(ptr unsafe.Pointer) *QSystemSemaphore {
	var n = NewQSystemSemaphoreFromPointer(ptr)
	return n
}

func (ptr *QSystemSemaphore) QSystemSemaphore_PTR() *QSystemSemaphore {
	return ptr
}

//QSystemSemaphore::AccessMode
type QSystemSemaphore__AccessMode int64

const (
	QSystemSemaphore__Open   = QSystemSemaphore__AccessMode(0)
	QSystemSemaphore__Create = QSystemSemaphore__AccessMode(1)
)

//QSystemSemaphore::SystemSemaphoreError
type QSystemSemaphore__SystemSemaphoreError int64

const (
	QSystemSemaphore__NoError          = QSystemSemaphore__SystemSemaphoreError(0)
	QSystemSemaphore__PermissionDenied = QSystemSemaphore__SystemSemaphoreError(1)
	QSystemSemaphore__KeyError         = QSystemSemaphore__SystemSemaphoreError(2)
	QSystemSemaphore__AlreadyExists    = QSystemSemaphore__SystemSemaphoreError(3)
	QSystemSemaphore__NotFound         = QSystemSemaphore__SystemSemaphoreError(4)
	QSystemSemaphore__OutOfResources   = QSystemSemaphore__SystemSemaphoreError(5)
	QSystemSemaphore__UnknownError     = QSystemSemaphore__SystemSemaphoreError(6)
)

func NewQSystemSemaphore(key string, initialValue int, mode QSystemSemaphore__AccessMode) *QSystemSemaphore {
	defer qt.Recovering("QSystemSemaphore::QSystemSemaphore")

	return newQSystemSemaphoreFromPointer(C.QSystemSemaphore_NewQSystemSemaphore(C.CString(key), C.int(initialValue), C.int(mode)))
}

func (ptr *QSystemSemaphore) Acquire() bool {
	defer qt.Recovering("QSystemSemaphore::acquire")

	if ptr.Pointer() != nil {
		return C.QSystemSemaphore_Acquire(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSystemSemaphore) Error() QSystemSemaphore__SystemSemaphoreError {
	defer qt.Recovering("QSystemSemaphore::error")

	if ptr.Pointer() != nil {
		return QSystemSemaphore__SystemSemaphoreError(C.QSystemSemaphore_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSystemSemaphore) ErrorString() string {
	defer qt.Recovering("QSystemSemaphore::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSystemSemaphore_ErrorString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSystemSemaphore) Key() string {
	defer qt.Recovering("QSystemSemaphore::key")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSystemSemaphore_Key(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSystemSemaphore) Release(n int) bool {
	defer qt.Recovering("QSystemSemaphore::release")

	if ptr.Pointer() != nil {
		return C.QSystemSemaphore_Release(ptr.Pointer(), C.int(n)) != 0
	}
	return false
}

func (ptr *QSystemSemaphore) SetKey(key string, initialValue int, mode QSystemSemaphore__AccessMode) {
	defer qt.Recovering("QSystemSemaphore::setKey")

	if ptr.Pointer() != nil {
		C.QSystemSemaphore_SetKey(ptr.Pointer(), C.CString(key), C.int(initialValue), C.int(mode))
	}
}

func (ptr *QSystemSemaphore) DestroyQSystemSemaphore() {
	defer qt.Recovering("QSystemSemaphore::~QSystemSemaphore")

	if ptr.Pointer() != nil {
		C.QSystemSemaphore_DestroyQSystemSemaphore(ptr.Pointer())
	}
}

type QTemporaryDir struct {
	ptr unsafe.Pointer
}

type QTemporaryDir_ITF interface {
	QTemporaryDir_PTR() *QTemporaryDir
}

func (p *QTemporaryDir) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTemporaryDir) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTemporaryDir(ptr QTemporaryDir_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTemporaryDir_PTR().Pointer()
	}
	return nil
}

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

func newQTemporaryDirFromPointer(ptr unsafe.Pointer) *QTemporaryDir {
	var n = NewQTemporaryDirFromPointer(ptr)
	return n
}

func (ptr *QTemporaryDir) QTemporaryDir_PTR() *QTemporaryDir {
	return ptr
}

func NewQTemporaryDir() *QTemporaryDir {
	defer qt.Recovering("QTemporaryDir::QTemporaryDir")

	return newQTemporaryDirFromPointer(C.QTemporaryDir_NewQTemporaryDir())
}

func NewQTemporaryDir2(templatePath string) *QTemporaryDir {
	defer qt.Recovering("QTemporaryDir::QTemporaryDir")

	return newQTemporaryDirFromPointer(C.QTemporaryDir_NewQTemporaryDir2(C.CString(templatePath)))
}

func (ptr *QTemporaryDir) AutoRemove() bool {
	defer qt.Recovering("QTemporaryDir::autoRemove")

	if ptr.Pointer() != nil {
		return C.QTemporaryDir_AutoRemove(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTemporaryDir) IsValid() bool {
	defer qt.Recovering("QTemporaryDir::isValid")

	if ptr.Pointer() != nil {
		return C.QTemporaryDir_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTemporaryDir) Path() string {
	defer qt.Recovering("QTemporaryDir::path")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTemporaryDir_Path(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTemporaryDir) SetAutoRemove(b bool) {
	defer qt.Recovering("QTemporaryDir::setAutoRemove")

	if ptr.Pointer() != nil {
		C.QTemporaryDir_SetAutoRemove(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
	}
}

func (ptr *QTemporaryDir) DestroyQTemporaryDir() {
	defer qt.Recovering("QTemporaryDir::~QTemporaryDir")

	if ptr.Pointer() != nil {
		C.QTemporaryDir_DestroyQTemporaryDir(ptr.Pointer())
	}
}

type QTemporaryFile struct {
	QFile
}

type QTemporaryFile_ITF interface {
	QFile_ITF
	QTemporaryFile_PTR() *QTemporaryFile
}

func PointerFromQTemporaryFile(ptr QTemporaryFile_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTemporaryFile_PTR().Pointer()
	}
	return nil
}

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

func newQTemporaryFileFromPointer(ptr unsafe.Pointer) *QTemporaryFile {
	var n = NewQTemporaryFileFromPointer(ptr)
	for len(n.ObjectName()) < len("QTemporaryFile_") {
		n.SetObjectName("QTemporaryFile_" + qt.Identifier())
	}
	return n
}

func (ptr *QTemporaryFile) QTemporaryFile_PTR() *QTemporaryFile {
	return ptr
}

func NewQTemporaryFile() *QTemporaryFile {
	defer qt.Recovering("QTemporaryFile::QTemporaryFile")

	return newQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile())
}

func NewQTemporaryFile3(parent QObject_ITF) *QTemporaryFile {
	defer qt.Recovering("QTemporaryFile::QTemporaryFile")

	return newQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile3(PointerFromQObject(parent)))
}

func NewQTemporaryFile2(templateName string) *QTemporaryFile {
	defer qt.Recovering("QTemporaryFile::QTemporaryFile")

	return newQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile2(C.CString(templateName)))
}

func NewQTemporaryFile4(templateName string, parent QObject_ITF) *QTemporaryFile {
	defer qt.Recovering("QTemporaryFile::QTemporaryFile")

	return newQTemporaryFileFromPointer(C.QTemporaryFile_NewQTemporaryFile4(C.CString(templateName), PointerFromQObject(parent)))
}

func (ptr *QTemporaryFile) AutoRemove() bool {
	defer qt.Recovering("QTemporaryFile::autoRemove")

	if ptr.Pointer() != nil {
		return C.QTemporaryFile_AutoRemove(ptr.Pointer()) != 0
	}
	return false
}

func QTemporaryFile_CreateNativeFile(file QFile_ITF) *QTemporaryFile {
	defer qt.Recovering("QTemporaryFile::createNativeFile")

	return NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile(PointerFromQFile(file)))
}

func QTemporaryFile_CreateNativeFile2(fileName string) *QTemporaryFile {
	defer qt.Recovering("QTemporaryFile::createNativeFile")

	return NewQTemporaryFileFromPointer(C.QTemporaryFile_QTemporaryFile_CreateNativeFile2(C.CString(fileName)))
}

func (ptr *QTemporaryFile) FileName() string {
	defer qt.Recovering("QTemporaryFile::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTemporaryFile_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTemporaryFile) FileTemplate() string {
	defer qt.Recovering("QTemporaryFile::fileTemplate")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTemporaryFile_FileTemplate(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTemporaryFile) Open() bool {
	defer qt.Recovering("QTemporaryFile::open")

	if ptr.Pointer() != nil {
		return C.QTemporaryFile_Open(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTemporaryFile) SetAutoRemove(b bool) {
	defer qt.Recovering("QTemporaryFile::setAutoRemove")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_SetAutoRemove(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
	}
}

func (ptr *QTemporaryFile) SetFileTemplate(name string) {
	defer qt.Recovering("QTemporaryFile::setFileTemplate")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_SetFileTemplate(ptr.Pointer(), C.CString(name))
	}
}

func (ptr *QTemporaryFile) DestroyQTemporaryFile() {
	defer qt.Recovering("QTemporaryFile::~QTemporaryFile")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_DestroyQTemporaryFile(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QTemporaryFile) ConnectClose(f func()) {
	defer qt.Recovering("connect QTemporaryFile::close")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "close", f)
	}
}

func (ptr *QTemporaryFile) DisconnectClose() {
	defer qt.Recovering("disconnect QTemporaryFile::close")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "close")
	}
}

//export callbackQTemporaryFileClose
func callbackQTemporaryFileClose(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QTemporaryFile::close")

	if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
		signal.(func())()
	} else {
		NewQTemporaryFileFromPointer(ptr).CloseDefault()
	}
}

func (ptr *QTemporaryFile) Close() {
	defer qt.Recovering("QTemporaryFile::close")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_Close(ptr.Pointer())
	}
}

func (ptr *QTemporaryFile) CloseDefault() {
	defer qt.Recovering("QTemporaryFile::close")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_CloseDefault(ptr.Pointer())
	}
}

func (ptr *QTemporaryFile) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QTemporaryFile::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTemporaryFile) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTemporaryFile::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTemporaryFileTimerEvent
func callbackQTemporaryFileTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTemporaryFile::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQTemporaryFileFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QTemporaryFile) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QTemporaryFile::timerEvent")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QTemporaryFile) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QTemporaryFile::timerEvent")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QTemporaryFile) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QTemporaryFile::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTemporaryFile) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTemporaryFile::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTemporaryFileChildEvent
func callbackQTemporaryFileChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTemporaryFile::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQTemporaryFileFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QTemporaryFile) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QTemporaryFile::childEvent")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QTemporaryFile) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QTemporaryFile::childEvent")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QTemporaryFile) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QTemporaryFile::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTemporaryFile) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTemporaryFile::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTemporaryFileCustomEvent
func callbackQTemporaryFileCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTemporaryFile::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQTemporaryFileFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QTemporaryFile) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QTemporaryFile::customEvent")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QTemporaryFile) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QTemporaryFile::customEvent")

	if ptr.Pointer() != nil {
		C.QTemporaryFile_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QTextBoundaryFinder struct {
	ptr unsafe.Pointer
}

type QTextBoundaryFinder_ITF interface {
	QTextBoundaryFinder_PTR() *QTextBoundaryFinder
}

func (p *QTextBoundaryFinder) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextBoundaryFinder) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextBoundaryFinder(ptr QTextBoundaryFinder_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextBoundaryFinder_PTR().Pointer()
	}
	return nil
}

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

func newQTextBoundaryFinderFromPointer(ptr unsafe.Pointer) *QTextBoundaryFinder {
	var n = NewQTextBoundaryFinderFromPointer(ptr)
	return n
}

func (ptr *QTextBoundaryFinder) QTextBoundaryFinder_PTR() *QTextBoundaryFinder {
	return ptr
}

//QTextBoundaryFinder::BoundaryReason
type QTextBoundaryFinder__BoundaryReason int64

const (
	QTextBoundaryFinder__NotAtBoundary    = QTextBoundaryFinder__BoundaryReason(0)
	QTextBoundaryFinder__BreakOpportunity = QTextBoundaryFinder__BoundaryReason(0x1f)
	QTextBoundaryFinder__StartOfItem      = QTextBoundaryFinder__BoundaryReason(0x20)
	QTextBoundaryFinder__EndOfItem        = QTextBoundaryFinder__BoundaryReason(0x40)
	QTextBoundaryFinder__MandatoryBreak   = QTextBoundaryFinder__BoundaryReason(0x80)
	QTextBoundaryFinder__SoftHyphen       = QTextBoundaryFinder__BoundaryReason(0x100)
)

//QTextBoundaryFinder::BoundaryType
type QTextBoundaryFinder__BoundaryType int64

const (
	QTextBoundaryFinder__Grapheme = QTextBoundaryFinder__BoundaryType(0)
	QTextBoundaryFinder__Word     = QTextBoundaryFinder__BoundaryType(1)
	QTextBoundaryFinder__Sentence = QTextBoundaryFinder__BoundaryType(2)
	QTextBoundaryFinder__Line     = QTextBoundaryFinder__BoundaryType(3)
)

func NewQTextBoundaryFinder() *QTextBoundaryFinder {
	defer qt.Recovering("QTextBoundaryFinder::QTextBoundaryFinder")

	return newQTextBoundaryFinderFromPointer(C.QTextBoundaryFinder_NewQTextBoundaryFinder())
}

func NewQTextBoundaryFinder3(ty QTextBoundaryFinder__BoundaryType, stri string) *QTextBoundaryFinder {
	defer qt.Recovering("QTextBoundaryFinder::QTextBoundaryFinder")

	return newQTextBoundaryFinderFromPointer(C.QTextBoundaryFinder_NewQTextBoundaryFinder3(C.int(ty), C.CString(stri)))
}

func NewQTextBoundaryFinder2(other QTextBoundaryFinder_ITF) *QTextBoundaryFinder {
	defer qt.Recovering("QTextBoundaryFinder::QTextBoundaryFinder")

	return newQTextBoundaryFinderFromPointer(C.QTextBoundaryFinder_NewQTextBoundaryFinder2(PointerFromQTextBoundaryFinder(other)))
}

func (ptr *QTextBoundaryFinder) BoundaryReasons() QTextBoundaryFinder__BoundaryReason {
	defer qt.Recovering("QTextBoundaryFinder::boundaryReasons")

	if ptr.Pointer() != nil {
		return QTextBoundaryFinder__BoundaryReason(C.QTextBoundaryFinder_BoundaryReasons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) IsAtBoundary() bool {
	defer qt.Recovering("QTextBoundaryFinder::isAtBoundary")

	if ptr.Pointer() != nil {
		return C.QTextBoundaryFinder_IsAtBoundary(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextBoundaryFinder) IsValid() bool {
	defer qt.Recovering("QTextBoundaryFinder::isValid")

	if ptr.Pointer() != nil {
		return C.QTextBoundaryFinder_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextBoundaryFinder) Position() int {
	defer qt.Recovering("QTextBoundaryFinder::position")

	if ptr.Pointer() != nil {
		return int(C.QTextBoundaryFinder_Position(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) SetPosition(position int) {
	defer qt.Recovering("QTextBoundaryFinder::setPosition")

	if ptr.Pointer() != nil {
		C.QTextBoundaryFinder_SetPosition(ptr.Pointer(), C.int(position))
	}
}

func (ptr *QTextBoundaryFinder) String() string {
	defer qt.Recovering("QTextBoundaryFinder::string")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextBoundaryFinder_String(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextBoundaryFinder) ToEnd() {
	defer qt.Recovering("QTextBoundaryFinder::toEnd")

	if ptr.Pointer() != nil {
		C.QTextBoundaryFinder_ToEnd(ptr.Pointer())
	}
}

func (ptr *QTextBoundaryFinder) ToNextBoundary() int {
	defer qt.Recovering("QTextBoundaryFinder::toNextBoundary")

	if ptr.Pointer() != nil {
		return int(C.QTextBoundaryFinder_ToNextBoundary(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) ToPreviousBoundary() int {
	defer qt.Recovering("QTextBoundaryFinder::toPreviousBoundary")

	if ptr.Pointer() != nil {
		return int(C.QTextBoundaryFinder_ToPreviousBoundary(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) ToStart() {
	defer qt.Recovering("QTextBoundaryFinder::toStart")

	if ptr.Pointer() != nil {
		C.QTextBoundaryFinder_ToStart(ptr.Pointer())
	}
}

func (ptr *QTextBoundaryFinder) Type() QTextBoundaryFinder__BoundaryType {
	defer qt.Recovering("QTextBoundaryFinder::type")

	if ptr.Pointer() != nil {
		return QTextBoundaryFinder__BoundaryType(C.QTextBoundaryFinder_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBoundaryFinder) DestroyQTextBoundaryFinder() {
	defer qt.Recovering("QTextBoundaryFinder::~QTextBoundaryFinder")

	if ptr.Pointer() != nil {
		C.QTextBoundaryFinder_DestroyQTextBoundaryFinder(ptr.Pointer())
	}
}

type QTextCodec struct {
	ptr unsafe.Pointer
}

type QTextCodec_ITF interface {
	QTextCodec_PTR() *QTextCodec
}

func (p *QTextCodec) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextCodec) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextCodec(ptr QTextCodec_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextCodec_PTR().Pointer()
	}
	return nil
}

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

func newQTextCodecFromPointer(ptr unsafe.Pointer) *QTextCodec {
	var n = NewQTextCodecFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QTextCodec_") {
		n.SetObjectNameAbs("QTextCodec_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextCodec) QTextCodec_PTR() *QTextCodec {
	return ptr
}

//QTextCodec::ConversionFlag
type QTextCodec__ConversionFlag int64

const (
	QTextCodec__DefaultConversion    = QTextCodec__ConversionFlag(0)
	QTextCodec__ConvertInvalidToNull = QTextCodec__ConversionFlag(0x80000000)
	QTextCodec__IgnoreHeader         = QTextCodec__ConversionFlag(0x1)
	QTextCodec__FreeFunction         = QTextCodec__ConversionFlag(0x2)
)

func (ptr *QTextCodec) CanEncode(ch QChar_ITF) bool {
	defer qt.Recovering("QTextCodec::canEncode")

	if ptr.Pointer() != nil {
		return C.QTextCodec_CanEncode(ptr.Pointer(), PointerFromQChar(ch)) != 0
	}
	return false
}

func (ptr *QTextCodec) CanEncode2(s string) bool {
	defer qt.Recovering("QTextCodec::canEncode")

	if ptr.Pointer() != nil {
		return C.QTextCodec_CanEncode2(ptr.Pointer(), C.CString(s)) != 0
	}
	return false
}

func QTextCodec_CodecForHtml2(ba string) *QTextCodec {
	defer qt.Recovering("QTextCodec::codecForHtml")

	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml2(C.CString(ba)))
}

func QTextCodec_CodecForHtml(ba string, defaultCodec QTextCodec_ITF) *QTextCodec {
	defer qt.Recovering("QTextCodec::codecForHtml")

	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForHtml(C.CString(ba), PointerFromQTextCodec(defaultCodec)))
}

func QTextCodec_CodecForLocale() *QTextCodec {
	defer qt.Recovering("QTextCodec::codecForLocale")

	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForLocale())
}

func QTextCodec_CodecForMib(mib int) *QTextCodec {
	defer qt.Recovering("QTextCodec::codecForMib")

	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForMib(C.int(mib)))
}

func QTextCodec_CodecForName(name string) *QTextCodec {
	defer qt.Recovering("QTextCodec::codecForName")

	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName(C.CString(name)))
}

func QTextCodec_CodecForName2(name string) *QTextCodec {
	defer qt.Recovering("QTextCodec::codecForName")

	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForName2(C.CString(name)))
}

func QTextCodec_CodecForUtfText2(ba string) *QTextCodec {
	defer qt.Recovering("QTextCodec::codecForUtfText")

	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText2(C.CString(ba)))
}

func QTextCodec_CodecForUtfText(ba string, defaultCodec QTextCodec_ITF) *QTextCodec {
	defer qt.Recovering("QTextCodec::codecForUtfText")

	return NewQTextCodecFromPointer(C.QTextCodec_QTextCodec_CodecForUtfText(C.CString(ba), PointerFromQTextCodec(defaultCodec)))
}

func (ptr *QTextCodec) FromUnicode(str string) string {
	defer qt.Recovering("QTextCodec::fromUnicode")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextCodec_FromUnicode(ptr.Pointer(), C.CString(str)))
	}
	return ""
}

func (ptr *QTextCodec) MakeDecoder(flags QTextCodec__ConversionFlag) *QTextDecoder {
	defer qt.Recovering("QTextCodec::makeDecoder")

	if ptr.Pointer() != nil {
		return NewQTextDecoderFromPointer(C.QTextCodec_MakeDecoder(ptr.Pointer(), C.int(flags)))
	}
	return nil
}

func (ptr *QTextCodec) MakeEncoder(flags QTextCodec__ConversionFlag) *QTextEncoder {
	defer qt.Recovering("QTextCodec::makeEncoder")

	if ptr.Pointer() != nil {
		return NewQTextEncoderFromPointer(C.QTextCodec_MakeEncoder(ptr.Pointer(), C.int(flags)))
	}
	return nil
}

func (ptr *QTextCodec) MibEnum() int {
	defer qt.Recovering("QTextCodec::mibEnum")

	if ptr.Pointer() != nil {
		return int(C.QTextCodec_MibEnum(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCodec) Name() string {
	defer qt.Recovering("QTextCodec::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextCodec_Name(ptr.Pointer()))
	}
	return ""
}

func QTextCodec_SetCodecForLocale(c QTextCodec_ITF) {
	defer qt.Recovering("QTextCodec::setCodecForLocale")

	C.QTextCodec_QTextCodec_SetCodecForLocale(PointerFromQTextCodec(c))
}

func (ptr *QTextCodec) DestroyQTextCodec() {
	defer qt.Recovering("QTextCodec::~QTextCodec")

	if ptr.Pointer() != nil {
		C.QTextCodec_DestroyQTextCodec(ptr.Pointer())
	}
}

func (ptr *QTextCodec) ObjectNameAbs() string {
	defer qt.Recovering("QTextCodec::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextCodec_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextCodec) SetObjectNameAbs(name string) {
	defer qt.Recovering("QTextCodec::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QTextCodec_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QTextDecoder struct {
	ptr unsafe.Pointer
}

type QTextDecoder_ITF interface {
	QTextDecoder_PTR() *QTextDecoder
}

func (p *QTextDecoder) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextDecoder) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextDecoder(ptr QTextDecoder_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextDecoder_PTR().Pointer()
	}
	return nil
}

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

func newQTextDecoderFromPointer(ptr unsafe.Pointer) *QTextDecoder {
	var n = NewQTextDecoderFromPointer(ptr)
	return n
}

func (ptr *QTextDecoder) QTextDecoder_PTR() *QTextDecoder {
	return ptr
}

func NewQTextDecoder(codec QTextCodec_ITF) *QTextDecoder {
	defer qt.Recovering("QTextDecoder::QTextDecoder")

	return newQTextDecoderFromPointer(C.QTextDecoder_NewQTextDecoder(PointerFromQTextCodec(codec)))
}

func NewQTextDecoder2(codec QTextCodec_ITF, flags QTextCodec__ConversionFlag) *QTextDecoder {
	defer qt.Recovering("QTextDecoder::QTextDecoder")

	return newQTextDecoderFromPointer(C.QTextDecoder_NewQTextDecoder2(PointerFromQTextCodec(codec), C.int(flags)))
}

func (ptr *QTextDecoder) DestroyQTextDecoder() {
	defer qt.Recovering("QTextDecoder::~QTextDecoder")

	if ptr.Pointer() != nil {
		C.QTextDecoder_DestroyQTextDecoder(ptr.Pointer())
	}
}

type QTextEncoder struct {
	ptr unsafe.Pointer
}

type QTextEncoder_ITF interface {
	QTextEncoder_PTR() *QTextEncoder
}

func (p *QTextEncoder) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextEncoder) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextEncoder(ptr QTextEncoder_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextEncoder_PTR().Pointer()
	}
	return nil
}

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

func newQTextEncoderFromPointer(ptr unsafe.Pointer) *QTextEncoder {
	var n = NewQTextEncoderFromPointer(ptr)
	return n
}

func (ptr *QTextEncoder) QTextEncoder_PTR() *QTextEncoder {
	return ptr
}

func NewQTextEncoder(codec QTextCodec_ITF) *QTextEncoder {
	defer qt.Recovering("QTextEncoder::QTextEncoder")

	return newQTextEncoderFromPointer(C.QTextEncoder_NewQTextEncoder(PointerFromQTextCodec(codec)))
}

func NewQTextEncoder2(codec QTextCodec_ITF, flags QTextCodec__ConversionFlag) *QTextEncoder {
	defer qt.Recovering("QTextEncoder::QTextEncoder")

	return newQTextEncoderFromPointer(C.QTextEncoder_NewQTextEncoder2(PointerFromQTextCodec(codec), C.int(flags)))
}

func (ptr *QTextEncoder) FromUnicode2(uc QChar_ITF, len int) string {
	defer qt.Recovering("QTextEncoder::fromUnicode")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextEncoder_FromUnicode2(ptr.Pointer(), PointerFromQChar(uc), C.int(len)))
	}
	return ""
}

func (ptr *QTextEncoder) FromUnicode(str string) string {
	defer qt.Recovering("QTextEncoder::fromUnicode")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextEncoder_FromUnicode(ptr.Pointer(), C.CString(str)))
	}
	return ""
}

func (ptr *QTextEncoder) DestroyQTextEncoder() {
	defer qt.Recovering("QTextEncoder::~QTextEncoder")

	if ptr.Pointer() != nil {
		C.QTextEncoder_DestroyQTextEncoder(ptr.Pointer())
	}
}

type QTextStream struct {
	ptr unsafe.Pointer
}

type QTextStream_ITF interface {
	QTextStream_PTR() *QTextStream
}

func (p *QTextStream) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextStream) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextStream(ptr QTextStream_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextStream_PTR().Pointer()
	}
	return nil
}

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

func newQTextStreamFromPointer(ptr unsafe.Pointer) *QTextStream {
	var n = NewQTextStreamFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QTextStream_") {
		n.SetObjectNameAbs("QTextStream_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextStream) QTextStream_PTR() *QTextStream {
	return ptr
}

//QTextStream::FieldAlignment
type QTextStream__FieldAlignment int64

const (
	QTextStream__AlignLeft            = QTextStream__FieldAlignment(0)
	QTextStream__AlignRight           = QTextStream__FieldAlignment(1)
	QTextStream__AlignCenter          = QTextStream__FieldAlignment(2)
	QTextStream__AlignAccountingStyle = QTextStream__FieldAlignment(3)
)

//QTextStream::NumberFlag
type QTextStream__NumberFlag int64

const (
	QTextStream__ShowBase        = QTextStream__NumberFlag(0x1)
	QTextStream__ForcePoint      = QTextStream__NumberFlag(0x2)
	QTextStream__ForceSign       = QTextStream__NumberFlag(0x4)
	QTextStream__UppercaseBase   = QTextStream__NumberFlag(0x8)
	QTextStream__UppercaseDigits = QTextStream__NumberFlag(0x10)
)

//QTextStream::RealNumberNotation
type QTextStream__RealNumberNotation int64

const (
	QTextStream__SmartNotation      = QTextStream__RealNumberNotation(0)
	QTextStream__FixedNotation      = QTextStream__RealNumberNotation(1)
	QTextStream__ScientificNotation = QTextStream__RealNumberNotation(2)
)

//QTextStream::Status
type QTextStream__Status int64

const (
	QTextStream__Ok              = QTextStream__Status(0)
	QTextStream__ReadPastEnd     = QTextStream__Status(1)
	QTextStream__ReadCorruptData = QTextStream__Status(2)
	QTextStream__WriteFailed     = QTextStream__Status(3)
)

func (ptr *QTextStream) AtEnd() bool {
	defer qt.Recovering("QTextStream::atEnd")

	if ptr.Pointer() != nil {
		return C.QTextStream_AtEnd(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextStream) AutoDetectUnicode() bool {
	defer qt.Recovering("QTextStream::autoDetectUnicode")

	if ptr.Pointer() != nil {
		return C.QTextStream_AutoDetectUnicode(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextStream) Codec() *QTextCodec {
	defer qt.Recovering("QTextStream::codec")

	if ptr.Pointer() != nil {
		return NewQTextCodecFromPointer(C.QTextStream_Codec(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextStream) Device() *QIODevice {
	defer qt.Recovering("QTextStream::device")

	if ptr.Pointer() != nil {
		return NewQIODeviceFromPointer(C.QTextStream_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextStream) FieldAlignment() QTextStream__FieldAlignment {
	defer qt.Recovering("QTextStream::fieldAlignment")

	if ptr.Pointer() != nil {
		return QTextStream__FieldAlignment(C.QTextStream_FieldAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) FieldWidth() int {
	defer qt.Recovering("QTextStream::fieldWidth")

	if ptr.Pointer() != nil {
		return int(C.QTextStream_FieldWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) Flush() {
	defer qt.Recovering("QTextStream::flush")

	if ptr.Pointer() != nil {
		C.QTextStream_Flush(ptr.Pointer())
	}
}

func (ptr *QTextStream) GenerateByteOrderMark() bool {
	defer qt.Recovering("QTextStream::generateByteOrderMark")

	if ptr.Pointer() != nil {
		return C.QTextStream_GenerateByteOrderMark(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextStream) IntegerBase() int {
	defer qt.Recovering("QTextStream::integerBase")

	if ptr.Pointer() != nil {
		return int(C.QTextStream_IntegerBase(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) Locale() *QLocale {
	defer qt.Recovering("QTextStream::locale")

	if ptr.Pointer() != nil {
		return NewQLocaleFromPointer(C.QTextStream_Locale(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextStream) NumberFlags() QTextStream__NumberFlag {
	defer qt.Recovering("QTextStream::numberFlags")

	if ptr.Pointer() != nil {
		return QTextStream__NumberFlag(C.QTextStream_NumberFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) Pos() int64 {
	defer qt.Recovering("QTextStream::pos")

	if ptr.Pointer() != nil {
		return int64(C.QTextStream_Pos(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) Read(maxlen int64) string {
	defer qt.Recovering("QTextStream::read")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextStream_Read(ptr.Pointer(), C.longlong(maxlen)))
	}
	return ""
}

func (ptr *QTextStream) ReadAll() string {
	defer qt.Recovering("QTextStream::readAll")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextStream_ReadAll(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextStream) ReadLine(maxlen int64) string {
	defer qt.Recovering("QTextStream::readLine")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextStream_ReadLine(ptr.Pointer(), C.longlong(maxlen)))
	}
	return ""
}

func (ptr *QTextStream) ReadLineInto(line string, maxlen int64) bool {
	defer qt.Recovering("QTextStream::readLineInto")

	if ptr.Pointer() != nil {
		return C.QTextStream_ReadLineInto(ptr.Pointer(), C.CString(line), C.longlong(maxlen)) != 0
	}
	return false
}

func (ptr *QTextStream) RealNumberNotation() QTextStream__RealNumberNotation {
	defer qt.Recovering("QTextStream::realNumberNotation")

	if ptr.Pointer() != nil {
		return QTextStream__RealNumberNotation(C.QTextStream_RealNumberNotation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) RealNumberPrecision() int {
	defer qt.Recovering("QTextStream::realNumberPrecision")

	if ptr.Pointer() != nil {
		return int(C.QTextStream_RealNumberPrecision(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) Reset() {
	defer qt.Recovering("QTextStream::reset")

	if ptr.Pointer() != nil {
		C.QTextStream_Reset(ptr.Pointer())
	}
}

func (ptr *QTextStream) ResetStatus() {
	defer qt.Recovering("QTextStream::resetStatus")

	if ptr.Pointer() != nil {
		C.QTextStream_ResetStatus(ptr.Pointer())
	}
}

func (ptr *QTextStream) Seek(pos int64) bool {
	defer qt.Recovering("QTextStream::seek")

	if ptr.Pointer() != nil {
		return C.QTextStream_Seek(ptr.Pointer(), C.longlong(pos)) != 0
	}
	return false
}

func (ptr *QTextStream) SetAutoDetectUnicode(enabled bool) {
	defer qt.Recovering("QTextStream::setAutoDetectUnicode")

	if ptr.Pointer() != nil {
		C.QTextStream_SetAutoDetectUnicode(ptr.Pointer(), C.int(qt.GoBoolToInt(enabled)))
	}
}

func (ptr *QTextStream) SetCodec(codec QTextCodec_ITF) {
	defer qt.Recovering("QTextStream::setCodec")

	if ptr.Pointer() != nil {
		C.QTextStream_SetCodec(ptr.Pointer(), PointerFromQTextCodec(codec))
	}
}

func (ptr *QTextStream) SetCodec2(codecName string) {
	defer qt.Recovering("QTextStream::setCodec")

	if ptr.Pointer() != nil {
		C.QTextStream_SetCodec2(ptr.Pointer(), C.CString(codecName))
	}
}

func (ptr *QTextStream) SetDevice(device QIODevice_ITF) {
	defer qt.Recovering("QTextStream::setDevice")

	if ptr.Pointer() != nil {
		C.QTextStream_SetDevice(ptr.Pointer(), PointerFromQIODevice(device))
	}
}

func (ptr *QTextStream) SetFieldAlignment(mode QTextStream__FieldAlignment) {
	defer qt.Recovering("QTextStream::setFieldAlignment")

	if ptr.Pointer() != nil {
		C.QTextStream_SetFieldAlignment(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QTextStream) SetFieldWidth(width int) {
	defer qt.Recovering("QTextStream::setFieldWidth")

	if ptr.Pointer() != nil {
		C.QTextStream_SetFieldWidth(ptr.Pointer(), C.int(width))
	}
}

func (ptr *QTextStream) SetGenerateByteOrderMark(generate bool) {
	defer qt.Recovering("QTextStream::setGenerateByteOrderMark")

	if ptr.Pointer() != nil {
		C.QTextStream_SetGenerateByteOrderMark(ptr.Pointer(), C.int(qt.GoBoolToInt(generate)))
	}
}

func (ptr *QTextStream) SetIntegerBase(base int) {
	defer qt.Recovering("QTextStream::setIntegerBase")

	if ptr.Pointer() != nil {
		C.QTextStream_SetIntegerBase(ptr.Pointer(), C.int(base))
	}
}

func (ptr *QTextStream) SetLocale(locale QLocale_ITF) {
	defer qt.Recovering("QTextStream::setLocale")

	if ptr.Pointer() != nil {
		C.QTextStream_SetLocale(ptr.Pointer(), PointerFromQLocale(locale))
	}
}

func (ptr *QTextStream) SetNumberFlags(flags QTextStream__NumberFlag) {
	defer qt.Recovering("QTextStream::setNumberFlags")

	if ptr.Pointer() != nil {
		C.QTextStream_SetNumberFlags(ptr.Pointer(), C.int(flags))
	}
}

func (ptr *QTextStream) SetPadChar(ch QChar_ITF) {
	defer qt.Recovering("QTextStream::setPadChar")

	if ptr.Pointer() != nil {
		C.QTextStream_SetPadChar(ptr.Pointer(), PointerFromQChar(ch))
	}
}

func (ptr *QTextStream) SetRealNumberNotation(notation QTextStream__RealNumberNotation) {
	defer qt.Recovering("QTextStream::setRealNumberNotation")

	if ptr.Pointer() != nil {
		C.QTextStream_SetRealNumberNotation(ptr.Pointer(), C.int(notation))
	}
}

func (ptr *QTextStream) SetRealNumberPrecision(precision int) {
	defer qt.Recovering("QTextStream::setRealNumberPrecision")

	if ptr.Pointer() != nil {
		C.QTextStream_SetRealNumberPrecision(ptr.Pointer(), C.int(precision))
	}
}

func (ptr *QTextStream) SetStatus(status QTextStream__Status) {
	defer qt.Recovering("QTextStream::setStatus")

	if ptr.Pointer() != nil {
		C.QTextStream_SetStatus(ptr.Pointer(), C.int(status))
	}
}

func (ptr *QTextStream) SetString(stri string, openMode QIODevice__OpenModeFlag) {
	defer qt.Recovering("QTextStream::setString")

	if ptr.Pointer() != nil {
		C.QTextStream_SetString(ptr.Pointer(), C.CString(stri), C.int(openMode))
	}
}

func (ptr *QTextStream) SkipWhiteSpace() {
	defer qt.Recovering("QTextStream::skipWhiteSpace")

	if ptr.Pointer() != nil {
		C.QTextStream_SkipWhiteSpace(ptr.Pointer())
	}
}

func (ptr *QTextStream) Status() QTextStream__Status {
	defer qt.Recovering("QTextStream::status")

	if ptr.Pointer() != nil {
		return QTextStream__Status(C.QTextStream_Status(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextStream) String() string {
	defer qt.Recovering("QTextStream::string")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextStream_String(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextStream) DestroyQTextStream() {
	defer qt.Recovering("QTextStream::~QTextStream")

	if ptr.Pointer() != nil {
		C.QTextStream_DestroyQTextStream(ptr.Pointer())
	}
}

func (ptr *QTextStream) ObjectNameAbs() string {
	defer qt.Recovering("QTextStream::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextStream_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextStream) SetObjectNameAbs(name string) {
	defer qt.Recovering("QTextStream::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QTextStream_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QThread struct {
	QObject
}

type QThread_ITF interface {
	QObject_ITF
	QThread_PTR() *QThread
}

func PointerFromQThread(ptr QThread_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QThread_PTR().Pointer()
	}
	return nil
}

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

func newQThreadFromPointer(ptr unsafe.Pointer) *QThread {
	var n = NewQThreadFromPointer(ptr)
	for len(n.ObjectName()) < len("QThread_") {
		n.SetObjectName("QThread_" + qt.Identifier())
	}
	return n
}

func (ptr *QThread) QThread_PTR() *QThread {
	return ptr
}

//QThread::Priority
type QThread__Priority int64

const (
	QThread__IdlePriority         = QThread__Priority(0)
	QThread__LowestPriority       = QThread__Priority(1)
	QThread__LowPriority          = QThread__Priority(2)
	QThread__NormalPriority       = QThread__Priority(3)
	QThread__HighPriority         = QThread__Priority(4)
	QThread__HighestPriority      = QThread__Priority(5)
	QThread__TimeCriticalPriority = QThread__Priority(6)
	QThread__InheritPriority      = QThread__Priority(7)
)

func (ptr *QThread) SetPriority(priority QThread__Priority) {
	defer qt.Recovering("QThread::setPriority")

	if ptr.Pointer() != nil {
		C.QThread_SetPriority(ptr.Pointer(), C.int(priority))
	}
}

func NewQThread(parent QObject_ITF) *QThread {
	defer qt.Recovering("QThread::QThread")

	return newQThreadFromPointer(C.QThread_NewQThread(PointerFromQObject(parent)))
}

func QThread_CurrentThread() *QThread {
	defer qt.Recovering("QThread::currentThread")

	return NewQThreadFromPointer(C.QThread_QThread_CurrentThread())
}

func (ptr *QThread) Event(event QEvent_ITF) bool {
	defer qt.Recovering("QThread::event")

	if ptr.Pointer() != nil {
		return C.QThread_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QThread) EventDispatcher() *QAbstractEventDispatcher {
	defer qt.Recovering("QThread::eventDispatcher")

	if ptr.Pointer() != nil {
		return NewQAbstractEventDispatcherFromPointer(C.QThread_EventDispatcher(ptr.Pointer()))
	}
	return nil
}

func (ptr *QThread) Exit(returnCode int) {
	defer qt.Recovering("QThread::exit")

	if ptr.Pointer() != nil {
		C.QThread_Exit(ptr.Pointer(), C.int(returnCode))
	}
}

func (ptr *QThread) ConnectFinished(f func()) {
	defer qt.Recovering("connect QThread::finished")

	if ptr.Pointer() != nil {
		C.QThread_ConnectFinished(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "finished", f)
	}
}

func (ptr *QThread) DisconnectFinished() {
	defer qt.Recovering("disconnect QThread::finished")

	if ptr.Pointer() != nil {
		C.QThread_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "finished")
	}
}

//export callbackQThreadFinished
func callbackQThreadFinished(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QThread::finished")

	if signal := qt.GetSignal(C.GoString(ptrName), "finished"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QThread) IsFinished() bool {
	defer qt.Recovering("QThread::isFinished")

	if ptr.Pointer() != nil {
		return C.QThread_IsFinished(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QThread) IsInterruptionRequested() bool {
	defer qt.Recovering("QThread::isInterruptionRequested")

	if ptr.Pointer() != nil {
		return C.QThread_IsInterruptionRequested(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QThread) IsRunning() bool {
	defer qt.Recovering("QThread::isRunning")

	if ptr.Pointer() != nil {
		return C.QThread_IsRunning(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QThread) LoopLevel() int {
	defer qt.Recovering("QThread::loopLevel")

	if ptr.Pointer() != nil {
		return int(C.QThread_LoopLevel(ptr.Pointer()))
	}
	return 0
}

func (ptr *QThread) Priority() QThread__Priority {
	defer qt.Recovering("QThread::priority")

	if ptr.Pointer() != nil {
		return QThread__Priority(C.QThread_Priority(ptr.Pointer()))
	}
	return 0
}

func (ptr *QThread) Quit() {
	defer qt.Recovering("QThread::quit")

	if ptr.Pointer() != nil {
		C.QThread_Quit(ptr.Pointer())
	}
}

func (ptr *QThread) RequestInterruption() {
	defer qt.Recovering("QThread::requestInterruption")

	if ptr.Pointer() != nil {
		C.QThread_RequestInterruption(ptr.Pointer())
	}
}

func (ptr *QThread) ConnectRun(f func()) {
	defer qt.Recovering("connect QThread::run")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "run", f)
	}
}

func (ptr *QThread) DisconnectRun() {
	defer qt.Recovering("disconnect QThread::run")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "run")
	}
}

//export callbackQThreadRun
func callbackQThreadRun(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QThread::run")

	if signal := qt.GetSignal(C.GoString(ptrName), "run"); signal != nil {
		signal.(func())()
	} else {
		NewQThreadFromPointer(ptr).RunDefault()
	}
}

func (ptr *QThread) Run() {
	defer qt.Recovering("QThread::run")

	if ptr.Pointer() != nil {
		C.QThread_Run(ptr.Pointer())
	}
}

func (ptr *QThread) RunDefault() {
	defer qt.Recovering("QThread::run")

	if ptr.Pointer() != nil {
		C.QThread_RunDefault(ptr.Pointer())
	}
}

func (ptr *QThread) SetEventDispatcher(eventDispatcher QAbstractEventDispatcher_ITF) {
	defer qt.Recovering("QThread::setEventDispatcher")

	if ptr.Pointer() != nil {
		C.QThread_SetEventDispatcher(ptr.Pointer(), PointerFromQAbstractEventDispatcher(eventDispatcher))
	}
}

func (ptr *QThread) ConnectStarted(f func()) {
	defer qt.Recovering("connect QThread::started")

	if ptr.Pointer() != nil {
		C.QThread_ConnectStarted(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "started", f)
	}
}

func (ptr *QThread) DisconnectStarted() {
	defer qt.Recovering("disconnect QThread::started")

	if ptr.Pointer() != nil {
		C.QThread_DisconnectStarted(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "started")
	}
}

//export callbackQThreadStarted
func callbackQThreadStarted(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QThread::started")

	if signal := qt.GetSignal(C.GoString(ptrName), "started"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QThread) DestroyQThread() {
	defer qt.Recovering("QThread::~QThread")

	if ptr.Pointer() != nil {
		C.QThread_DestroyQThread(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func QThread_IdealThreadCount() int {
	defer qt.Recovering("QThread::idealThreadCount")

	return int(C.QThread_QThread_IdealThreadCount())
}

func (ptr *QThread) Start() {
	defer qt.Recovering("QThread::start")

	if ptr.Pointer() != nil {
		C.QThread_Start(ptr.Pointer())
	}
}

func (ptr *QThread) Terminate() {
	defer qt.Recovering("QThread::terminate")

	if ptr.Pointer() != nil {
		C.QThread_Terminate(ptr.Pointer())
	}
}

func QThread_YieldCurrentThread() {
	defer qt.Recovering("QThread::yieldCurrentThread")

	C.QThread_QThread_YieldCurrentThread()
}

func (ptr *QThread) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QThread::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QThread) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QThread::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQThreadTimerEvent
func callbackQThreadTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QThread::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQThreadFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QThread) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QThread::timerEvent")

	if ptr.Pointer() != nil {
		C.QThread_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QThread) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QThread::timerEvent")

	if ptr.Pointer() != nil {
		C.QThread_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QThread) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QThread::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QThread) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QThread::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQThreadChildEvent
func callbackQThreadChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QThread::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQThreadFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QThread) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QThread::childEvent")

	if ptr.Pointer() != nil {
		C.QThread_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QThread) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QThread::childEvent")

	if ptr.Pointer() != nil {
		C.QThread_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QThread) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QThread::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QThread) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QThread::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQThreadCustomEvent
func callbackQThreadCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QThread::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQThreadFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QThread) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QThread::customEvent")

	if ptr.Pointer() != nil {
		C.QThread_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QThread) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QThread::customEvent")

	if ptr.Pointer() != nil {
		C.QThread_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QThreadPool struct {
	QObject
}

type QThreadPool_ITF interface {
	QObject_ITF
	QThreadPool_PTR() *QThreadPool
}

func PointerFromQThreadPool(ptr QThreadPool_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QThreadPool_PTR().Pointer()
	}
	return nil
}

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

func newQThreadPoolFromPointer(ptr unsafe.Pointer) *QThreadPool {
	var n = NewQThreadPoolFromPointer(ptr)
	for len(n.ObjectName()) < len("QThreadPool_") {
		n.SetObjectName("QThreadPool_" + qt.Identifier())
	}
	return n
}

func (ptr *QThreadPool) QThreadPool_PTR() *QThreadPool {
	return ptr
}

func (ptr *QThreadPool) ActiveThreadCount() int {
	defer qt.Recovering("QThreadPool::activeThreadCount")

	if ptr.Pointer() != nil {
		return int(C.QThreadPool_ActiveThreadCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QThreadPool) ExpiryTimeout() int {
	defer qt.Recovering("QThreadPool::expiryTimeout")

	if ptr.Pointer() != nil {
		return int(C.QThreadPool_ExpiryTimeout(ptr.Pointer()))
	}
	return 0
}

func (ptr *QThreadPool) MaxThreadCount() int {
	defer qt.Recovering("QThreadPool::maxThreadCount")

	if ptr.Pointer() != nil {
		return int(C.QThreadPool_MaxThreadCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QThreadPool) SetExpiryTimeout(expiryTimeout int) {
	defer qt.Recovering("QThreadPool::setExpiryTimeout")

	if ptr.Pointer() != nil {
		C.QThreadPool_SetExpiryTimeout(ptr.Pointer(), C.int(expiryTimeout))
	}
}

func (ptr *QThreadPool) SetMaxThreadCount(maxThreadCount int) {
	defer qt.Recovering("QThreadPool::setMaxThreadCount")

	if ptr.Pointer() != nil {
		C.QThreadPool_SetMaxThreadCount(ptr.Pointer(), C.int(maxThreadCount))
	}
}

func NewQThreadPool(parent QObject_ITF) *QThreadPool {
	defer qt.Recovering("QThreadPool::QThreadPool")

	return newQThreadPoolFromPointer(C.QThreadPool_NewQThreadPool(PointerFromQObject(parent)))
}

func (ptr *QThreadPool) Cancel(runnable QRunnable_ITF) {
	defer qt.Recovering("QThreadPool::cancel")

	if ptr.Pointer() != nil {
		C.QThreadPool_Cancel(ptr.Pointer(), PointerFromQRunnable(runnable))
	}
}

func (ptr *QThreadPool) Clear() {
	defer qt.Recovering("QThreadPool::clear")

	if ptr.Pointer() != nil {
		C.QThreadPool_Clear(ptr.Pointer())
	}
}

func QThreadPool_GlobalInstance() *QThreadPool {
	defer qt.Recovering("QThreadPool::globalInstance")

	return NewQThreadPoolFromPointer(C.QThreadPool_QThreadPool_GlobalInstance())
}

func (ptr *QThreadPool) ReleaseThread() {
	defer qt.Recovering("QThreadPool::releaseThread")

	if ptr.Pointer() != nil {
		C.QThreadPool_ReleaseThread(ptr.Pointer())
	}
}

func (ptr *QThreadPool) ReserveThread() {
	defer qt.Recovering("QThreadPool::reserveThread")

	if ptr.Pointer() != nil {
		C.QThreadPool_ReserveThread(ptr.Pointer())
	}
}

func (ptr *QThreadPool) Start(runnable QRunnable_ITF, priority int) {
	defer qt.Recovering("QThreadPool::start")

	if ptr.Pointer() != nil {
		C.QThreadPool_Start(ptr.Pointer(), PointerFromQRunnable(runnable), C.int(priority))
	}
}

func (ptr *QThreadPool) TryStart(runnable QRunnable_ITF) bool {
	defer qt.Recovering("QThreadPool::tryStart")

	if ptr.Pointer() != nil {
		return C.QThreadPool_TryStart(ptr.Pointer(), PointerFromQRunnable(runnable)) != 0
	}
	return false
}

func (ptr *QThreadPool) WaitForDone(msecs int) bool {
	defer qt.Recovering("QThreadPool::waitForDone")

	if ptr.Pointer() != nil {
		return C.QThreadPool_WaitForDone(ptr.Pointer(), C.int(msecs)) != 0
	}
	return false
}

func (ptr *QThreadPool) DestroyQThreadPool() {
	defer qt.Recovering("QThreadPool::~QThreadPool")

	if ptr.Pointer() != nil {
		C.QThreadPool_DestroyQThreadPool(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QThreadPool) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QThreadPool::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QThreadPool) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QThreadPool::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQThreadPoolTimerEvent
func callbackQThreadPoolTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QThreadPool::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQThreadPoolFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QThreadPool) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QThreadPool::timerEvent")

	if ptr.Pointer() != nil {
		C.QThreadPool_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QThreadPool) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QThreadPool::timerEvent")

	if ptr.Pointer() != nil {
		C.QThreadPool_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QThreadPool) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QThreadPool::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QThreadPool) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QThreadPool::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQThreadPoolChildEvent
func callbackQThreadPoolChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QThreadPool::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQThreadPoolFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QThreadPool) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QThreadPool::childEvent")

	if ptr.Pointer() != nil {
		C.QThreadPool_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QThreadPool) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QThreadPool::childEvent")

	if ptr.Pointer() != nil {
		C.QThreadPool_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QThreadPool) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QThreadPool::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QThreadPool) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QThreadPool::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQThreadPoolCustomEvent
func callbackQThreadPoolCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QThreadPool::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQThreadPoolFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QThreadPool) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QThreadPool::customEvent")

	if ptr.Pointer() != nil {
		C.QThreadPool_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QThreadPool) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QThreadPool::customEvent")

	if ptr.Pointer() != nil {
		C.QThreadPool_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QThreadStorage struct {
	ptr unsafe.Pointer
}

type QThreadStorage_ITF interface {
	QThreadStorage_PTR() *QThreadStorage
}

func (p *QThreadStorage) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QThreadStorage) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQThreadStorage(ptr QThreadStorage_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QThreadStorage_PTR().Pointer()
	}
	return nil
}

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

func newQThreadStorageFromPointer(ptr unsafe.Pointer) *QThreadStorage {
	var n = NewQThreadStorageFromPointer(ptr)
	return n
}

func (ptr *QThreadStorage) QThreadStorage_PTR() *QThreadStorage {
	return ptr
}

type QTime struct {
	ptr unsafe.Pointer
}

type QTime_ITF interface {
	QTime_PTR() *QTime
}

func (p *QTime) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTime) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTime(ptr QTime_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTime_PTR().Pointer()
	}
	return nil
}

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

func newQTimeFromPointer(ptr unsafe.Pointer) *QTime {
	var n = NewQTimeFromPointer(ptr)
	return n
}

func (ptr *QTime) QTime_PTR() *QTime {
	return ptr
}

func NewQTime() *QTime {
	defer qt.Recovering("QTime::QTime")

	return newQTimeFromPointer(C.QTime_NewQTime())
}

func NewQTime3(h int, m int, s int, ms int) *QTime {
	defer qt.Recovering("QTime::QTime")

	return newQTimeFromPointer(C.QTime_NewQTime3(C.int(h), C.int(m), C.int(s), C.int(ms)))
}

func (ptr *QTime) Elapsed() int {
	defer qt.Recovering("QTime::elapsed")

	if ptr.Pointer() != nil {
		return int(C.QTime_Elapsed(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTime) Hour() int {
	defer qt.Recovering("QTime::hour")

	if ptr.Pointer() != nil {
		return int(C.QTime_Hour(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTime) IsNull() bool {
	defer qt.Recovering("QTime::isNull")

	if ptr.Pointer() != nil {
		return C.QTime_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func QTime_IsValid2(h int, m int, s int, ms int) bool {
	defer qt.Recovering("QTime::isValid")

	return C.QTime_QTime_IsValid2(C.int(h), C.int(m), C.int(s), C.int(ms)) != 0
}

func (ptr *QTime) IsValid() bool {
	defer qt.Recovering("QTime::isValid")

	if ptr.Pointer() != nil {
		return C.QTime_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTime) Minute() int {
	defer qt.Recovering("QTime::minute")

	if ptr.Pointer() != nil {
		return int(C.QTime_Minute(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTime) Msec() int {
	defer qt.Recovering("QTime::msec")

	if ptr.Pointer() != nil {
		return int(C.QTime_Msec(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTime) MsecsSinceStartOfDay() int {
	defer qt.Recovering("QTime::msecsSinceStartOfDay")

	if ptr.Pointer() != nil {
		return int(C.QTime_MsecsSinceStartOfDay(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTime) MsecsTo(t QTime_ITF) int {
	defer qt.Recovering("QTime::msecsTo")

	if ptr.Pointer() != nil {
		return int(C.QTime_MsecsTo(ptr.Pointer(), PointerFromQTime(t)))
	}
	return 0
}

func (ptr *QTime) Restart() int {
	defer qt.Recovering("QTime::restart")

	if ptr.Pointer() != nil {
		return int(C.QTime_Restart(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTime) Second() int {
	defer qt.Recovering("QTime::second")

	if ptr.Pointer() != nil {
		return int(C.QTime_Second(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTime) SecsTo(t QTime_ITF) int {
	defer qt.Recovering("QTime::secsTo")

	if ptr.Pointer() != nil {
		return int(C.QTime_SecsTo(ptr.Pointer(), PointerFromQTime(t)))
	}
	return 0
}

func (ptr *QTime) SetHMS(h int, m int, s int, ms int) bool {
	defer qt.Recovering("QTime::setHMS")

	if ptr.Pointer() != nil {
		return C.QTime_SetHMS(ptr.Pointer(), C.int(h), C.int(m), C.int(s), C.int(ms)) != 0
	}
	return false
}

func (ptr *QTime) Start() {
	defer qt.Recovering("QTime::start")

	if ptr.Pointer() != nil {
		C.QTime_Start(ptr.Pointer())
	}
}

func (ptr *QTime) ToString2(format Qt__DateFormat) string {
	defer qt.Recovering("QTime::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTime_ToString2(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func (ptr *QTime) ToString(format string) string {
	defer qt.Recovering("QTime::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTime_ToString(ptr.Pointer(), C.CString(format)))
	}
	return ""
}

type QTimeLine struct {
	QObject
}

type QTimeLine_ITF interface {
	QObject_ITF
	QTimeLine_PTR() *QTimeLine
}

func PointerFromQTimeLine(ptr QTimeLine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTimeLine_PTR().Pointer()
	}
	return nil
}

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

func newQTimeLineFromPointer(ptr unsafe.Pointer) *QTimeLine {
	var n = NewQTimeLineFromPointer(ptr)
	for len(n.ObjectName()) < len("QTimeLine_") {
		n.SetObjectName("QTimeLine_" + qt.Identifier())
	}
	return n
}

func (ptr *QTimeLine) QTimeLine_PTR() *QTimeLine {
	return ptr
}

//QTimeLine::CurveShape
type QTimeLine__CurveShape int64

const (
	QTimeLine__EaseInCurve    = QTimeLine__CurveShape(0)
	QTimeLine__EaseOutCurve   = QTimeLine__CurveShape(1)
	QTimeLine__EaseInOutCurve = QTimeLine__CurveShape(2)
	QTimeLine__LinearCurve    = QTimeLine__CurveShape(3)
	QTimeLine__SineCurve      = QTimeLine__CurveShape(4)
	QTimeLine__CosineCurve    = QTimeLine__CurveShape(5)
)

//QTimeLine::Direction
type QTimeLine__Direction int64

const (
	QTimeLine__Forward  = QTimeLine__Direction(0)
	QTimeLine__Backward = QTimeLine__Direction(1)
)

//QTimeLine::State
type QTimeLine__State int64

const (
	QTimeLine__NotRunning = QTimeLine__State(0)
	QTimeLine__Paused     = QTimeLine__State(1)
	QTimeLine__Running    = QTimeLine__State(2)
)

func (ptr *QTimeLine) CurrentTime() int {
	defer qt.Recovering("QTimeLine::currentTime")

	if ptr.Pointer() != nil {
		return int(C.QTimeLine_CurrentTime(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) CurveShape() QTimeLine__CurveShape {
	defer qt.Recovering("QTimeLine::curveShape")

	if ptr.Pointer() != nil {
		return QTimeLine__CurveShape(C.QTimeLine_CurveShape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) Direction() QTimeLine__Direction {
	defer qt.Recovering("QTimeLine::direction")

	if ptr.Pointer() != nil {
		return QTimeLine__Direction(C.QTimeLine_Direction(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) Duration() int {
	defer qt.Recovering("QTimeLine::duration")

	if ptr.Pointer() != nil {
		return int(C.QTimeLine_Duration(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) EasingCurve() *QEasingCurve {
	defer qt.Recovering("QTimeLine::easingCurve")

	if ptr.Pointer() != nil {
		return NewQEasingCurveFromPointer(C.QTimeLine_EasingCurve(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTimeLine) LoopCount() int {
	defer qt.Recovering("QTimeLine::loopCount")

	if ptr.Pointer() != nil {
		return int(C.QTimeLine_LoopCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) SetCurrentTime(msec int) {
	defer qt.Recovering("QTimeLine::setCurrentTime")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetCurrentTime(ptr.Pointer(), C.int(msec))
	}
}

func (ptr *QTimeLine) SetCurveShape(shape QTimeLine__CurveShape) {
	defer qt.Recovering("QTimeLine::setCurveShape")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetCurveShape(ptr.Pointer(), C.int(shape))
	}
}

func (ptr *QTimeLine) SetDirection(direction QTimeLine__Direction) {
	defer qt.Recovering("QTimeLine::setDirection")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QTimeLine) SetDuration(duration int) {
	defer qt.Recovering("QTimeLine::setDuration")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetDuration(ptr.Pointer(), C.int(duration))
	}
}

func (ptr *QTimeLine) SetEasingCurve(curve QEasingCurve_ITF) {
	defer qt.Recovering("QTimeLine::setEasingCurve")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetEasingCurve(ptr.Pointer(), PointerFromQEasingCurve(curve))
	}
}

func (ptr *QTimeLine) SetLoopCount(count int) {
	defer qt.Recovering("QTimeLine::setLoopCount")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetLoopCount(ptr.Pointer(), C.int(count))
	}
}

func (ptr *QTimeLine) SetUpdateInterval(interval int) {
	defer qt.Recovering("QTimeLine::setUpdateInterval")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetUpdateInterval(ptr.Pointer(), C.int(interval))
	}
}

func (ptr *QTimeLine) UpdateInterval() int {
	defer qt.Recovering("QTimeLine::updateInterval")

	if ptr.Pointer() != nil {
		return int(C.QTimeLine_UpdateInterval(ptr.Pointer()))
	}
	return 0
}

func NewQTimeLine(duration int, parent QObject_ITF) *QTimeLine {
	defer qt.Recovering("QTimeLine::QTimeLine")

	return newQTimeLineFromPointer(C.QTimeLine_NewQTimeLine(C.int(duration), PointerFromQObject(parent)))
}

func (ptr *QTimeLine) CurrentFrame() int {
	defer qt.Recovering("QTimeLine::currentFrame")

	if ptr.Pointer() != nil {
		return int(C.QTimeLine_CurrentFrame(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) CurrentValue() float64 {
	defer qt.Recovering("QTimeLine::currentValue")

	if ptr.Pointer() != nil {
		return float64(C.QTimeLine_CurrentValue(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) EndFrame() int {
	defer qt.Recovering("QTimeLine::endFrame")

	if ptr.Pointer() != nil {
		return int(C.QTimeLine_EndFrame(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) ConnectFinished(f func()) {
	defer qt.Recovering("connect QTimeLine::finished")

	if ptr.Pointer() != nil {
		C.QTimeLine_ConnectFinished(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "finished", f)
	}
}

func (ptr *QTimeLine) DisconnectFinished() {
	defer qt.Recovering("disconnect QTimeLine::finished")

	if ptr.Pointer() != nil {
		C.QTimeLine_DisconnectFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "finished")
	}
}

//export callbackQTimeLineFinished
func callbackQTimeLineFinished(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QTimeLine::finished")

	if signal := qt.GetSignal(C.GoString(ptrName), "finished"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QTimeLine) ConnectFrameChanged(f func(frame int)) {
	defer qt.Recovering("connect QTimeLine::frameChanged")

	if ptr.Pointer() != nil {
		C.QTimeLine_ConnectFrameChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "frameChanged", f)
	}
}

func (ptr *QTimeLine) DisconnectFrameChanged() {
	defer qt.Recovering("disconnect QTimeLine::frameChanged")

	if ptr.Pointer() != nil {
		C.QTimeLine_DisconnectFrameChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "frameChanged")
	}
}

//export callbackQTimeLineFrameChanged
func callbackQTimeLineFrameChanged(ptr unsafe.Pointer, ptrName *C.char, frame C.int) {
	defer qt.Recovering("callback QTimeLine::frameChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "frameChanged"); signal != nil {
		signal.(func(int))(int(frame))
	}

}

func (ptr *QTimeLine) FrameForTime(msec int) int {
	defer qt.Recovering("QTimeLine::frameForTime")

	if ptr.Pointer() != nil {
		return int(C.QTimeLine_FrameForTime(ptr.Pointer(), C.int(msec)))
	}
	return 0
}

func (ptr *QTimeLine) Resume() {
	defer qt.Recovering("QTimeLine::resume")

	if ptr.Pointer() != nil {
		C.QTimeLine_Resume(ptr.Pointer())
	}
}

func (ptr *QTimeLine) SetEndFrame(frame int) {
	defer qt.Recovering("QTimeLine::setEndFrame")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetEndFrame(ptr.Pointer(), C.int(frame))
	}
}

func (ptr *QTimeLine) SetFrameRange(startFrame int, endFrame int) {
	defer qt.Recovering("QTimeLine::setFrameRange")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetFrameRange(ptr.Pointer(), C.int(startFrame), C.int(endFrame))
	}
}

func (ptr *QTimeLine) SetPaused(paused bool) {
	defer qt.Recovering("QTimeLine::setPaused")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetPaused(ptr.Pointer(), C.int(qt.GoBoolToInt(paused)))
	}
}

func (ptr *QTimeLine) SetStartFrame(frame int) {
	defer qt.Recovering("QTimeLine::setStartFrame")

	if ptr.Pointer() != nil {
		C.QTimeLine_SetStartFrame(ptr.Pointer(), C.int(frame))
	}
}

func (ptr *QTimeLine) Start() {
	defer qt.Recovering("QTimeLine::start")

	if ptr.Pointer() != nil {
		C.QTimeLine_Start(ptr.Pointer())
	}
}

func (ptr *QTimeLine) StartFrame() int {
	defer qt.Recovering("QTimeLine::startFrame")

	if ptr.Pointer() != nil {
		return int(C.QTimeLine_StartFrame(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) State() QTimeLine__State {
	defer qt.Recovering("QTimeLine::state")

	if ptr.Pointer() != nil {
		return QTimeLine__State(C.QTimeLine_State(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeLine) ConnectStateChanged(f func(newState QTimeLine__State)) {
	defer qt.Recovering("connect QTimeLine::stateChanged")

	if ptr.Pointer() != nil {
		C.QTimeLine_ConnectStateChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "stateChanged", f)
	}
}

func (ptr *QTimeLine) DisconnectStateChanged() {
	defer qt.Recovering("disconnect QTimeLine::stateChanged")

	if ptr.Pointer() != nil {
		C.QTimeLine_DisconnectStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "stateChanged")
	}
}

//export callbackQTimeLineStateChanged
func callbackQTimeLineStateChanged(ptr unsafe.Pointer, ptrName *C.char, newState C.int) {
	defer qt.Recovering("callback QTimeLine::stateChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "stateChanged"); signal != nil {
		signal.(func(QTimeLine__State))(QTimeLine__State(newState))
	}

}

func (ptr *QTimeLine) Stop() {
	defer qt.Recovering("QTimeLine::stop")

	if ptr.Pointer() != nil {
		C.QTimeLine_Stop(ptr.Pointer())
	}
}

func (ptr *QTimeLine) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QTimeLine::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTimeLine) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTimeLine::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTimeLineTimerEvent
func callbackQTimeLineTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTimeLine::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQTimeLineFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QTimeLine) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QTimeLine::timerEvent")

	if ptr.Pointer() != nil {
		C.QTimeLine_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QTimeLine) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QTimeLine::timerEvent")

	if ptr.Pointer() != nil {
		C.QTimeLine_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QTimeLine) ToggleDirection() {
	defer qt.Recovering("QTimeLine::toggleDirection")

	if ptr.Pointer() != nil {
		C.QTimeLine_ToggleDirection(ptr.Pointer())
	}
}

func (ptr *QTimeLine) ConnectValueChanged(f func(value float64)) {
	defer qt.Recovering("connect QTimeLine::valueChanged")

	if ptr.Pointer() != nil {
		C.QTimeLine_ConnectValueChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "valueChanged", f)
	}
}

func (ptr *QTimeLine) DisconnectValueChanged() {
	defer qt.Recovering("disconnect QTimeLine::valueChanged")

	if ptr.Pointer() != nil {
		C.QTimeLine_DisconnectValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "valueChanged")
	}
}

//export callbackQTimeLineValueChanged
func callbackQTimeLineValueChanged(ptr unsafe.Pointer, ptrName *C.char, value C.double) {
	defer qt.Recovering("callback QTimeLine::valueChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "valueChanged"); signal != nil {
		signal.(func(float64))(float64(value))
	}

}

func (ptr *QTimeLine) ValueForTime(msec int) float64 {
	defer qt.Recovering("QTimeLine::valueForTime")

	if ptr.Pointer() != nil {
		return float64(C.QTimeLine_ValueForTime(ptr.Pointer(), C.int(msec)))
	}
	return 0
}

func (ptr *QTimeLine) DestroyQTimeLine() {
	defer qt.Recovering("QTimeLine::~QTimeLine")

	if ptr.Pointer() != nil {
		C.QTimeLine_DestroyQTimeLine(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QTimeLine) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QTimeLine::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTimeLine) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTimeLine::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTimeLineChildEvent
func callbackQTimeLineChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTimeLine::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQTimeLineFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QTimeLine) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QTimeLine::childEvent")

	if ptr.Pointer() != nil {
		C.QTimeLine_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QTimeLine) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QTimeLine::childEvent")

	if ptr.Pointer() != nil {
		C.QTimeLine_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QTimeLine) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QTimeLine::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTimeLine) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTimeLine::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTimeLineCustomEvent
func callbackQTimeLineCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTimeLine::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQTimeLineFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QTimeLine) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QTimeLine::customEvent")

	if ptr.Pointer() != nil {
		C.QTimeLine_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QTimeLine) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QTimeLine::customEvent")

	if ptr.Pointer() != nil {
		C.QTimeLine_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QTimeZone struct {
	ptr unsafe.Pointer
}

type QTimeZone_ITF interface {
	QTimeZone_PTR() *QTimeZone
}

func (p *QTimeZone) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTimeZone) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTimeZone(ptr QTimeZone_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTimeZone_PTR().Pointer()
	}
	return nil
}

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

func newQTimeZoneFromPointer(ptr unsafe.Pointer) *QTimeZone {
	var n = NewQTimeZoneFromPointer(ptr)
	return n
}

func (ptr *QTimeZone) QTimeZone_PTR() *QTimeZone {
	return ptr
}

//QTimeZone::NameType
type QTimeZone__NameType int64

const (
	QTimeZone__DefaultName = QTimeZone__NameType(0)
	QTimeZone__LongName    = QTimeZone__NameType(1)
	QTimeZone__ShortName   = QTimeZone__NameType(2)
	QTimeZone__OffsetName  = QTimeZone__NameType(3)
)

//QTimeZone::TimeType
type QTimeZone__TimeType int64

const (
	QTimeZone__StandardTime = QTimeZone__TimeType(0)
	QTimeZone__DaylightTime = QTimeZone__TimeType(1)
	QTimeZone__GenericTime  = QTimeZone__TimeType(2)
)

func NewQTimeZone() *QTimeZone {
	defer qt.Recovering("QTimeZone::QTimeZone")

	return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone())
}

func NewQTimeZone2(ianaId string) *QTimeZone {
	defer qt.Recovering("QTimeZone::QTimeZone")

	return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone2(C.CString(ianaId)))
}

func NewQTimeZone4(ianaId string, offsetSeconds int, name string, abbreviation string, country QLocale__Country, comment string) *QTimeZone {
	defer qt.Recovering("QTimeZone::QTimeZone")

	return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone4(C.CString(ianaId), C.int(offsetSeconds), C.CString(name), C.CString(abbreviation), C.int(country), C.CString(comment)))
}

func NewQTimeZone5(other QTimeZone_ITF) *QTimeZone {
	defer qt.Recovering("QTimeZone::QTimeZone")

	return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone5(PointerFromQTimeZone(other)))
}

func NewQTimeZone3(offsetSeconds int) *QTimeZone {
	defer qt.Recovering("QTimeZone::QTimeZone")

	return newQTimeZoneFromPointer(C.QTimeZone_NewQTimeZone3(C.int(offsetSeconds)))
}

func (ptr *QTimeZone) Abbreviation(atDateTime QDateTime_ITF) string {
	defer qt.Recovering("QTimeZone::abbreviation")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTimeZone_Abbreviation(ptr.Pointer(), PointerFromQDateTime(atDateTime)))
	}
	return ""
}

func (ptr *QTimeZone) Comment() string {
	defer qt.Recovering("QTimeZone::comment")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTimeZone_Comment(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTimeZone) Country() QLocale__Country {
	defer qt.Recovering("QTimeZone::country")

	if ptr.Pointer() != nil {
		return QLocale__Country(C.QTimeZone_Country(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimeZone) DaylightTimeOffset(atDateTime QDateTime_ITF) int {
	defer qt.Recovering("QTimeZone::daylightTimeOffset")

	if ptr.Pointer() != nil {
		return int(C.QTimeZone_DaylightTimeOffset(ptr.Pointer(), PointerFromQDateTime(atDateTime)))
	}
	return 0
}

func (ptr *QTimeZone) DisplayName2(timeType QTimeZone__TimeType, nameType QTimeZone__NameType, locale QLocale_ITF) string {
	defer qt.Recovering("QTimeZone::displayName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTimeZone_DisplayName2(ptr.Pointer(), C.int(timeType), C.int(nameType), PointerFromQLocale(locale)))
	}
	return ""
}

func (ptr *QTimeZone) DisplayName(atDateTime QDateTime_ITF, nameType QTimeZone__NameType, locale QLocale_ITF) string {
	defer qt.Recovering("QTimeZone::displayName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTimeZone_DisplayName(ptr.Pointer(), PointerFromQDateTime(atDateTime), C.int(nameType), PointerFromQLocale(locale)))
	}
	return ""
}

func (ptr *QTimeZone) HasDaylightTime() bool {
	defer qt.Recovering("QTimeZone::hasDaylightTime")

	if ptr.Pointer() != nil {
		return C.QTimeZone_HasDaylightTime(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTimeZone) HasTransitions() bool {
	defer qt.Recovering("QTimeZone::hasTransitions")

	if ptr.Pointer() != nil {
		return C.QTimeZone_HasTransitions(ptr.Pointer()) != 0
	}
	return false
}

func QTimeZone_IanaIdToWindowsId(ianaId string) string {
	defer qt.Recovering("QTimeZone::ianaIdToWindowsId")

	return C.GoString(C.QTimeZone_QTimeZone_IanaIdToWindowsId(C.CString(ianaId)))
}

func (ptr *QTimeZone) Id() string {
	defer qt.Recovering("QTimeZone::id")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTimeZone_Id(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTimeZone) IsDaylightTime(atDateTime QDateTime_ITF) bool {
	defer qt.Recovering("QTimeZone::isDaylightTime")

	if ptr.Pointer() != nil {
		return C.QTimeZone_IsDaylightTime(ptr.Pointer(), PointerFromQDateTime(atDateTime)) != 0
	}
	return false
}

func QTimeZone_IsTimeZoneIdAvailable(ianaId string) bool {
	defer qt.Recovering("QTimeZone::isTimeZoneIdAvailable")

	return C.QTimeZone_QTimeZone_IsTimeZoneIdAvailable(C.CString(ianaId)) != 0
}

func (ptr *QTimeZone) IsValid() bool {
	defer qt.Recovering("QTimeZone::isValid")

	if ptr.Pointer() != nil {
		return C.QTimeZone_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTimeZone) OffsetFromUtc(atDateTime QDateTime_ITF) int {
	defer qt.Recovering("QTimeZone::offsetFromUtc")

	if ptr.Pointer() != nil {
		return int(C.QTimeZone_OffsetFromUtc(ptr.Pointer(), PointerFromQDateTime(atDateTime)))
	}
	return 0
}

func (ptr *QTimeZone) StandardTimeOffset(atDateTime QDateTime_ITF) int {
	defer qt.Recovering("QTimeZone::standardTimeOffset")

	if ptr.Pointer() != nil {
		return int(C.QTimeZone_StandardTimeOffset(ptr.Pointer(), PointerFromQDateTime(atDateTime)))
	}
	return 0
}

func (ptr *QTimeZone) Swap(other QTimeZone_ITF) {
	defer qt.Recovering("QTimeZone::swap")

	if ptr.Pointer() != nil {
		C.QTimeZone_Swap(ptr.Pointer(), PointerFromQTimeZone(other))
	}
}

func QTimeZone_SystemTimeZone() *QTimeZone {
	defer qt.Recovering("QTimeZone::systemTimeZone")

	return NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_SystemTimeZone())
}

func QTimeZone_SystemTimeZoneId() string {
	defer qt.Recovering("QTimeZone::systemTimeZoneId")

	return C.GoString(C.QTimeZone_QTimeZone_SystemTimeZoneId())
}

func QTimeZone_Utc() *QTimeZone {
	defer qt.Recovering("QTimeZone::utc")

	return NewQTimeZoneFromPointer(C.QTimeZone_QTimeZone_Utc())
}

func QTimeZone_WindowsIdToDefaultIanaId(windowsId string) string {
	defer qt.Recovering("QTimeZone::windowsIdToDefaultIanaId")

	return C.GoString(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId(C.CString(windowsId)))
}

func QTimeZone_WindowsIdToDefaultIanaId2(windowsId string, country QLocale__Country) string {
	defer qt.Recovering("QTimeZone::windowsIdToDefaultIanaId")

	return C.GoString(C.QTimeZone_QTimeZone_WindowsIdToDefaultIanaId2(C.CString(windowsId), C.int(country)))
}

func (ptr *QTimeZone) DestroyQTimeZone() {
	defer qt.Recovering("QTimeZone::~QTimeZone")

	if ptr.Pointer() != nil {
		C.QTimeZone_DestroyQTimeZone(ptr.Pointer())
	}
}

type QTimer struct {
	QObject
}

type QTimer_ITF interface {
	QObject_ITF
	QTimer_PTR() *QTimer
}

func PointerFromQTimer(ptr QTimer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTimer_PTR().Pointer()
	}
	return nil
}

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

func newQTimerFromPointer(ptr unsafe.Pointer) *QTimer {
	var n = NewQTimerFromPointer(ptr)
	for len(n.ObjectName()) < len("QTimer_") {
		n.SetObjectName("QTimer_" + qt.Identifier())
	}
	return n
}

func (ptr *QTimer) QTimer_PTR() *QTimer {
	return ptr
}

func (ptr *QTimer) RemainingTime() int {
	defer qt.Recovering("QTimer::remainingTime")

	if ptr.Pointer() != nil {
		return int(C.QTimer_RemainingTime(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimer) SetInterval(msec int) {
	defer qt.Recovering("QTimer::setInterval")

	if ptr.Pointer() != nil {
		C.QTimer_SetInterval(ptr.Pointer(), C.int(msec))
	}
}

func NewQTimer(parent QObject_ITF) *QTimer {
	defer qt.Recovering("QTimer::QTimer")

	return newQTimerFromPointer(C.QTimer_NewQTimer(PointerFromQObject(parent)))
}

func (ptr *QTimer) Interval() int {
	defer qt.Recovering("QTimer::interval")

	if ptr.Pointer() != nil {
		return int(C.QTimer_Interval(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimer) IsActive() bool {
	defer qt.Recovering("QTimer::isActive")

	if ptr.Pointer() != nil {
		return C.QTimer_IsActive(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTimer) IsSingleShot() bool {
	defer qt.Recovering("QTimer::isSingleShot")

	if ptr.Pointer() != nil {
		return C.QTimer_IsSingleShot(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTimer) SetSingleShot(singleShot bool) {
	defer qt.Recovering("QTimer::setSingleShot")

	if ptr.Pointer() != nil {
		C.QTimer_SetSingleShot(ptr.Pointer(), C.int(qt.GoBoolToInt(singleShot)))
	}
}

func (ptr *QTimer) SetTimerType(atype Qt__TimerType) {
	defer qt.Recovering("QTimer::setTimerType")

	if ptr.Pointer() != nil {
		C.QTimer_SetTimerType(ptr.Pointer(), C.int(atype))
	}
}

func QTimer_SingleShot2(msec int, timerType Qt__TimerType, receiver QObject_ITF, member string) {
	defer qt.Recovering("QTimer::singleShot")

	C.QTimer_QTimer_SingleShot2(C.int(msec), C.int(timerType), PointerFromQObject(receiver), C.CString(member))
}

func QTimer_SingleShot(msec int, receiver QObject_ITF, member string) {
	defer qt.Recovering("QTimer::singleShot")

	C.QTimer_QTimer_SingleShot(C.int(msec), PointerFromQObject(receiver), C.CString(member))
}

func (ptr *QTimer) Start2() {
	defer qt.Recovering("QTimer::start")

	if ptr.Pointer() != nil {
		C.QTimer_Start2(ptr.Pointer())
	}
}

func (ptr *QTimer) Start(msec int) {
	defer qt.Recovering("QTimer::start")

	if ptr.Pointer() != nil {
		C.QTimer_Start(ptr.Pointer(), C.int(msec))
	}
}

func (ptr *QTimer) Stop() {
	defer qt.Recovering("QTimer::stop")

	if ptr.Pointer() != nil {
		C.QTimer_Stop(ptr.Pointer())
	}
}

func (ptr *QTimer) ConnectTimeout(f func()) {
	defer qt.Recovering("connect QTimer::timeout")

	if ptr.Pointer() != nil {
		C.QTimer_ConnectTimeout(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "timeout", f)
	}
}

func (ptr *QTimer) DisconnectTimeout() {
	defer qt.Recovering("disconnect QTimer::timeout")

	if ptr.Pointer() != nil {
		C.QTimer_DisconnectTimeout(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "timeout")
	}
}

//export callbackQTimerTimeout
func callbackQTimerTimeout(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QTimer::timeout")

	if signal := qt.GetSignal(C.GoString(ptrName), "timeout"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QTimer) ConnectTimerEvent(f func(e *QTimerEvent)) {
	defer qt.Recovering("connect QTimer::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTimer) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTimer::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTimerTimerEvent
func callbackQTimerTimerEvent(ptr unsafe.Pointer, ptrName *C.char, e unsafe.Pointer) {
	defer qt.Recovering("callback QTimer::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(e))
	} else {
		NewQTimerFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(e))
	}
}

func (ptr *QTimer) TimerEvent(e QTimerEvent_ITF) {
	defer qt.Recovering("QTimer::timerEvent")

	if ptr.Pointer() != nil {
		C.QTimer_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(e))
	}
}

func (ptr *QTimer) TimerEventDefault(e QTimerEvent_ITF) {
	defer qt.Recovering("QTimer::timerEvent")

	if ptr.Pointer() != nil {
		C.QTimer_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(e))
	}
}

func (ptr *QTimer) TimerId() int {
	defer qt.Recovering("QTimer::timerId")

	if ptr.Pointer() != nil {
		return int(C.QTimer_TimerId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimer) TimerType() Qt__TimerType {
	defer qt.Recovering("QTimer::timerType")

	if ptr.Pointer() != nil {
		return Qt__TimerType(C.QTimer_TimerType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTimer) DestroyQTimer() {
	defer qt.Recovering("QTimer::~QTimer")

	if ptr.Pointer() != nil {
		C.QTimer_DestroyQTimer(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QTimer) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QTimer::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTimer) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTimer::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTimerChildEvent
func callbackQTimerChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTimer::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQTimerFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QTimer) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QTimer::childEvent")

	if ptr.Pointer() != nil {
		C.QTimer_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QTimer) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QTimer::childEvent")

	if ptr.Pointer() != nil {
		C.QTimer_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QTimer) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QTimer::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTimer) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTimer::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTimerCustomEvent
func callbackQTimerCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTimer::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQTimerFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QTimer) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QTimer::customEvent")

	if ptr.Pointer() != nil {
		C.QTimer_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QTimer) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QTimer::customEvent")

	if ptr.Pointer() != nil {
		C.QTimer_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QTimerEvent struct {
	QEvent
}

type QTimerEvent_ITF interface {
	QEvent_ITF
	QTimerEvent_PTR() *QTimerEvent
}

func PointerFromQTimerEvent(ptr QTimerEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTimerEvent_PTR().Pointer()
	}
	return nil
}

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

func newQTimerEventFromPointer(ptr unsafe.Pointer) *QTimerEvent {
	var n = NewQTimerEventFromPointer(ptr)
	return n
}

func (ptr *QTimerEvent) QTimerEvent_PTR() *QTimerEvent {
	return ptr
}

func NewQTimerEvent(timerId int) *QTimerEvent {
	defer qt.Recovering("QTimerEvent::QTimerEvent")

	return newQTimerEventFromPointer(C.QTimerEvent_NewQTimerEvent(C.int(timerId)))
}

func (ptr *QTimerEvent) TimerId() int {
	defer qt.Recovering("QTimerEvent::timerId")

	if ptr.Pointer() != nil {
		return int(C.QTimerEvent_TimerId(ptr.Pointer()))
	}
	return 0
}

type QTranslator struct {
	QObject
}

type QTranslator_ITF interface {
	QObject_ITF
	QTranslator_PTR() *QTranslator
}

func PointerFromQTranslator(ptr QTranslator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTranslator_PTR().Pointer()
	}
	return nil
}

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

func newQTranslatorFromPointer(ptr unsafe.Pointer) *QTranslator {
	var n = NewQTranslatorFromPointer(ptr)
	for len(n.ObjectName()) < len("QTranslator_") {
		n.SetObjectName("QTranslator_" + qt.Identifier())
	}
	return n
}

func (ptr *QTranslator) QTranslator_PTR() *QTranslator {
	return ptr
}

func NewQTranslator(parent QObject_ITF) *QTranslator {
	defer qt.Recovering("QTranslator::QTranslator")

	return newQTranslatorFromPointer(C.QTranslator_NewQTranslator(PointerFromQObject(parent)))
}

func (ptr *QTranslator) IsEmpty() bool {
	defer qt.Recovering("QTranslator::isEmpty")

	if ptr.Pointer() != nil {
		return C.QTranslator_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTranslator) Load2(locale QLocale_ITF, filename string, prefix string, directory string, suffix string) bool {
	defer qt.Recovering("QTranslator::load")

	if ptr.Pointer() != nil {
		return C.QTranslator_Load2(ptr.Pointer(), PointerFromQLocale(locale), C.CString(filename), C.CString(prefix), C.CString(directory), C.CString(suffix)) != 0
	}
	return false
}

func (ptr *QTranslator) Load(filename string, directory string, search_delimiters string, suffix string) bool {
	defer qt.Recovering("QTranslator::load")

	if ptr.Pointer() != nil {
		return C.QTranslator_Load(ptr.Pointer(), C.CString(filename), C.CString(directory), C.CString(search_delimiters), C.CString(suffix)) != 0
	}
	return false
}

func (ptr *QTranslator) Translate(context string, sourceText string, disambiguation string, n int) string {
	defer qt.Recovering("QTranslator::translate")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTranslator_Translate(ptr.Pointer(), C.CString(context), C.CString(sourceText), C.CString(disambiguation), C.int(n)))
	}
	return ""
}

func (ptr *QTranslator) DestroyQTranslator() {
	defer qt.Recovering("QTranslator::~QTranslator")

	if ptr.Pointer() != nil {
		C.QTranslator_DestroyQTranslator(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QTranslator) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QTranslator::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTranslator) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTranslator::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTranslatorTimerEvent
func callbackQTranslatorTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTranslator::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQTranslatorFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QTranslator) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QTranslator::timerEvent")

	if ptr.Pointer() != nil {
		C.QTranslator_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QTranslator) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QTranslator::timerEvent")

	if ptr.Pointer() != nil {
		C.QTranslator_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QTranslator) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QTranslator::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTranslator) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTranslator::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTranslatorChildEvent
func callbackQTranslatorChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTranslator::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQTranslatorFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QTranslator) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QTranslator::childEvent")

	if ptr.Pointer() != nil {
		C.QTranslator_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QTranslator) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QTranslator::childEvent")

	if ptr.Pointer() != nil {
		C.QTranslator_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QTranslator) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QTranslator::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTranslator) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTranslator::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTranslatorCustomEvent
func callbackQTranslatorCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTranslator::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQTranslatorFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QTranslator) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QTranslator::customEvent")

	if ptr.Pointer() != nil {
		C.QTranslator_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QTranslator) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QTranslator::customEvent")

	if ptr.Pointer() != nil {
		C.QTranslator_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QUnhandledException struct {
	QException
}

type QUnhandledException_ITF interface {
	QException_ITF
	QUnhandledException_PTR() *QUnhandledException
}

func PointerFromQUnhandledException(ptr QUnhandledException_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUnhandledException_PTR().Pointer()
	}
	return nil
}

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

func newQUnhandledExceptionFromPointer(ptr unsafe.Pointer) *QUnhandledException {
	var n = NewQUnhandledExceptionFromPointer(ptr)
	return n
}

func (ptr *QUnhandledException) QUnhandledException_PTR() *QUnhandledException {
	return ptr
}

type QUnicodeTables struct {
	ptr unsafe.Pointer
}

type QUnicodeTables_ITF interface {
	QUnicodeTables_PTR() *QUnicodeTables
}

func (p *QUnicodeTables) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QUnicodeTables) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQUnicodeTables(ptr QUnicodeTables_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUnicodeTables_PTR().Pointer()
	}
	return nil
}

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

func newQUnicodeTablesFromPointer(ptr unsafe.Pointer) *QUnicodeTables {
	var n = NewQUnicodeTablesFromPointer(ptr)
	return n
}

func (ptr *QUnicodeTables) QUnicodeTables_PTR() *QUnicodeTables {
	return ptr
}

//QUnicodeTables::GraphemeBreakClass
type QUnicodeTables__GraphemeBreakClass int64

const (
	QUnicodeTables__GraphemeBreak_Other             = QUnicodeTables__GraphemeBreakClass(0)
	QUnicodeTables__GraphemeBreak_CR                = QUnicodeTables__GraphemeBreakClass(1)
	QUnicodeTables__GraphemeBreak_LF                = QUnicodeTables__GraphemeBreakClass(2)
	QUnicodeTables__GraphemeBreak_Control           = QUnicodeTables__GraphemeBreakClass(3)
	QUnicodeTables__GraphemeBreak_Extend            = QUnicodeTables__GraphemeBreakClass(4)
	QUnicodeTables__GraphemeBreak_RegionalIndicator = QUnicodeTables__GraphemeBreakClass(5)
	QUnicodeTables__GraphemeBreak_Prepend           = QUnicodeTables__GraphemeBreakClass(6)
	QUnicodeTables__GraphemeBreak_SpacingMark       = QUnicodeTables__GraphemeBreakClass(7)
	QUnicodeTables__GraphemeBreak_L                 = QUnicodeTables__GraphemeBreakClass(8)
	QUnicodeTables__GraphemeBreak_V                 = QUnicodeTables__GraphemeBreakClass(9)
	QUnicodeTables__GraphemeBreak_T                 = QUnicodeTables__GraphemeBreakClass(10)
	QUnicodeTables__GraphemeBreak_LV                = QUnicodeTables__GraphemeBreakClass(11)
	QUnicodeTables__GraphemeBreak_LVT               = QUnicodeTables__GraphemeBreakClass(12)
)

//QUnicodeTables::LineBreakClass
type QUnicodeTables__LineBreakClass int64

const (
	QUnicodeTables__LineBreak_OP = QUnicodeTables__LineBreakClass(0)
	QUnicodeTables__LineBreak_CL = QUnicodeTables__LineBreakClass(1)
	QUnicodeTables__LineBreak_CP = QUnicodeTables__LineBreakClass(2)
	QUnicodeTables__LineBreak_QU = QUnicodeTables__LineBreakClass(3)
	QUnicodeTables__LineBreak_GL = QUnicodeTables__LineBreakClass(4)
	QUnicodeTables__LineBreak_NS = QUnicodeTables__LineBreakClass(5)
	QUnicodeTables__LineBreak_EX = QUnicodeTables__LineBreakClass(6)
	QUnicodeTables__LineBreak_SY = QUnicodeTables__LineBreakClass(7)
	QUnicodeTables__LineBreak_IS = QUnicodeTables__LineBreakClass(8)
	QUnicodeTables__LineBreak_PR = QUnicodeTables__LineBreakClass(9)
	QUnicodeTables__LineBreak_PO = QUnicodeTables__LineBreakClass(10)
	QUnicodeTables__LineBreak_NU = QUnicodeTables__LineBreakClass(11)
	QUnicodeTables__LineBreak_AL = QUnicodeTables__LineBreakClass(12)
	QUnicodeTables__LineBreak_HL = QUnicodeTables__LineBreakClass(13)
	QUnicodeTables__LineBreak_ID = QUnicodeTables__LineBreakClass(14)
	QUnicodeTables__LineBreak_IN = QUnicodeTables__LineBreakClass(15)
	QUnicodeTables__LineBreak_HY = QUnicodeTables__LineBreakClass(16)
	QUnicodeTables__LineBreak_BA = QUnicodeTables__LineBreakClass(17)
	QUnicodeTables__LineBreak_BB = QUnicodeTables__LineBreakClass(18)
	QUnicodeTables__LineBreak_B2 = QUnicodeTables__LineBreakClass(19)
	QUnicodeTables__LineBreak_ZW = QUnicodeTables__LineBreakClass(20)
	QUnicodeTables__LineBreak_CM = QUnicodeTables__LineBreakClass(21)
	QUnicodeTables__LineBreak_WJ = QUnicodeTables__LineBreakClass(22)
	QUnicodeTables__LineBreak_H2 = QUnicodeTables__LineBreakClass(23)
	QUnicodeTables__LineBreak_H3 = QUnicodeTables__LineBreakClass(24)
	QUnicodeTables__LineBreak_JL = QUnicodeTables__LineBreakClass(25)
	QUnicodeTables__LineBreak_JV = QUnicodeTables__LineBreakClass(26)
	QUnicodeTables__LineBreak_JT = QUnicodeTables__LineBreakClass(27)
	QUnicodeTables__LineBreak_RI = QUnicodeTables__LineBreakClass(28)
	QUnicodeTables__LineBreak_CB = QUnicodeTables__LineBreakClass(29)
	QUnicodeTables__LineBreak_SA = QUnicodeTables__LineBreakClass(30)
	QUnicodeTables__LineBreak_SG = QUnicodeTables__LineBreakClass(31)
	QUnicodeTables__LineBreak_SP = QUnicodeTables__LineBreakClass(32)
	QUnicodeTables__LineBreak_CR = QUnicodeTables__LineBreakClass(33)
	QUnicodeTables__LineBreak_LF = QUnicodeTables__LineBreakClass(34)
	QUnicodeTables__LineBreak_BK = QUnicodeTables__LineBreakClass(35)
)

//QUnicodeTables::SentenceBreakClass
type QUnicodeTables__SentenceBreakClass int64

const (
	QUnicodeTables__SentenceBreak_Other     = QUnicodeTables__SentenceBreakClass(0)
	QUnicodeTables__SentenceBreak_CR        = QUnicodeTables__SentenceBreakClass(1)
	QUnicodeTables__SentenceBreak_LF        = QUnicodeTables__SentenceBreakClass(2)
	QUnicodeTables__SentenceBreak_Sep       = QUnicodeTables__SentenceBreakClass(3)
	QUnicodeTables__SentenceBreak_Extend    = QUnicodeTables__SentenceBreakClass(4)
	QUnicodeTables__SentenceBreak_Sp        = QUnicodeTables__SentenceBreakClass(5)
	QUnicodeTables__SentenceBreak_Lower     = QUnicodeTables__SentenceBreakClass(6)
	QUnicodeTables__SentenceBreak_Upper     = QUnicodeTables__SentenceBreakClass(7)
	QUnicodeTables__SentenceBreak_OLetter   = QUnicodeTables__SentenceBreakClass(8)
	QUnicodeTables__SentenceBreak_Numeric   = QUnicodeTables__SentenceBreakClass(9)
	QUnicodeTables__SentenceBreak_ATerm     = QUnicodeTables__SentenceBreakClass(10)
	QUnicodeTables__SentenceBreak_SContinue = QUnicodeTables__SentenceBreakClass(11)
	QUnicodeTables__SentenceBreak_STerm     = QUnicodeTables__SentenceBreakClass(12)
	QUnicodeTables__SentenceBreak_Close     = QUnicodeTables__SentenceBreakClass(13)
)

//QUnicodeTables::WordBreakClass
type QUnicodeTables__WordBreakClass int64

const (
	QUnicodeTables__WordBreak_Other             = QUnicodeTables__WordBreakClass(0)
	QUnicodeTables__WordBreak_CR                = QUnicodeTables__WordBreakClass(1)
	QUnicodeTables__WordBreak_LF                = QUnicodeTables__WordBreakClass(2)
	QUnicodeTables__WordBreak_Newline           = QUnicodeTables__WordBreakClass(3)
	QUnicodeTables__WordBreak_Extend            = QUnicodeTables__WordBreakClass(4)
	QUnicodeTables__WordBreak_RegionalIndicator = QUnicodeTables__WordBreakClass(5)
	QUnicodeTables__WordBreak_Katakana          = QUnicodeTables__WordBreakClass(6)
	QUnicodeTables__WordBreak_HebrewLetter      = QUnicodeTables__WordBreakClass(7)
	QUnicodeTables__WordBreak_ALetter           = QUnicodeTables__WordBreakClass(8)
	QUnicodeTables__WordBreak_SingleQuote       = QUnicodeTables__WordBreakClass(9)
	QUnicodeTables__WordBreak_DoubleQuote       = QUnicodeTables__WordBreakClass(10)
	QUnicodeTables__WordBreak_MidNumLet         = QUnicodeTables__WordBreakClass(11)
	QUnicodeTables__WordBreak_MidLetter         = QUnicodeTables__WordBreakClass(12)
	QUnicodeTables__WordBreak_MidNum            = QUnicodeTables__WordBreakClass(13)
	QUnicodeTables__WordBreak_Numeric           = QUnicodeTables__WordBreakClass(14)
	QUnicodeTables__WordBreak_ExtendNumLet      = QUnicodeTables__WordBreakClass(15)
)

type QUnicodeTools struct {
	ptr unsafe.Pointer
}

type QUnicodeTools_ITF interface {
	QUnicodeTools_PTR() *QUnicodeTools
}

func (p *QUnicodeTools) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QUnicodeTools) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQUnicodeTools(ptr QUnicodeTools_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUnicodeTools_PTR().Pointer()
	}
	return nil
}

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

func newQUnicodeToolsFromPointer(ptr unsafe.Pointer) *QUnicodeTools {
	var n = NewQUnicodeToolsFromPointer(ptr)
	return n
}

func (ptr *QUnicodeTools) QUnicodeTools_PTR() *QUnicodeTools {
	return ptr
}

//QUnicodeTools::CharAttributeOption
type QUnicodeTools__CharAttributeOption int64

const (
	QUnicodeTools__GraphemeBreaks       = QUnicodeTools__CharAttributeOption(0x01)
	QUnicodeTools__WordBreaks           = QUnicodeTools__CharAttributeOption(0x02)
	QUnicodeTools__SentenceBreaks       = QUnicodeTools__CharAttributeOption(0x04)
	QUnicodeTools__LineBreaks           = QUnicodeTools__CharAttributeOption(0x08)
	QUnicodeTools__WhiteSpaces          = QUnicodeTools__CharAttributeOption(0x10)
	QUnicodeTools__DefaultOptionsCompat = QUnicodeTools__CharAttributeOption(QUnicodeTools__GraphemeBreaks | QUnicodeTools__LineBreaks | QUnicodeTools__WhiteSpaces)
	QUnicodeTools__DontClearAttributes  = QUnicodeTools__CharAttributeOption(0x1000)
)

type QUrl struct {
	ptr unsafe.Pointer
}

type QUrl_ITF interface {
	QUrl_PTR() *QUrl
}

func (p *QUrl) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QUrl) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQUrl(ptr QUrl_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUrl_PTR().Pointer()
	}
	return nil
}

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

func newQUrlFromPointer(ptr unsafe.Pointer) *QUrl {
	var n = NewQUrlFromPointer(ptr)
	return n
}

func (ptr *QUrl) QUrl_PTR() *QUrl {
	return ptr
}

//QUrl::ComponentFormattingOption
type QUrl__ComponentFormattingOption int64

const (
	QUrl__PrettyDecoded    = QUrl__ComponentFormattingOption(0x000000)
	QUrl__EncodeSpaces     = QUrl__ComponentFormattingOption(0x100000)
	QUrl__EncodeUnicode    = QUrl__ComponentFormattingOption(0x200000)
	QUrl__EncodeDelimiters = QUrl__ComponentFormattingOption(0x400000 | 0x800000)
	QUrl__EncodeReserved   = QUrl__ComponentFormattingOption(0x1000000)
	QUrl__DecodeReserved   = QUrl__ComponentFormattingOption(0x2000000)
	QUrl__FullyEncoded     = QUrl__ComponentFormattingOption(QUrl__EncodeSpaces | QUrl__EncodeUnicode | QUrl__EncodeDelimiters | QUrl__EncodeReserved)
	QUrl__FullyDecoded     = QUrl__ComponentFormattingOption(QUrl__FullyEncoded | QUrl__DecodeReserved | 0x4000000)
)

//QUrl::ParsingMode
type QUrl__ParsingMode int64

const (
	QUrl__TolerantMode = QUrl__ParsingMode(0)
	QUrl__StrictMode   = QUrl__ParsingMode(1)
	QUrl__DecodedMode  = QUrl__ParsingMode(2)
)

//QUrl::UrlFormattingOption
type QUrl__UrlFormattingOption int64

const (
	QUrl__None                  = QUrl__UrlFormattingOption(0x0)
	QUrl__RemoveScheme          = QUrl__UrlFormattingOption(0x1)
	QUrl__RemovePassword        = QUrl__UrlFormattingOption(0x2)
	QUrl__RemoveUserInfo        = QUrl__UrlFormattingOption(QUrl__RemovePassword | 0x4)
	QUrl__RemovePort            = QUrl__UrlFormattingOption(0x8)
	QUrl__RemoveAuthority       = QUrl__UrlFormattingOption(QUrl__RemoveUserInfo | QUrl__RemovePort | 0x10)
	QUrl__RemovePath            = QUrl__UrlFormattingOption(0x20)
	QUrl__RemoveQuery           = QUrl__UrlFormattingOption(0x40)
	QUrl__RemoveFragment        = QUrl__UrlFormattingOption(0x80)
	QUrl__PreferLocalFile       = QUrl__UrlFormattingOption(0x200)
	QUrl__StripTrailingSlash    = QUrl__UrlFormattingOption(0x400)
	QUrl__RemoveFilename        = QUrl__UrlFormattingOption(0x800)
	QUrl__NormalizePathSegments = QUrl__UrlFormattingOption(0x1000)
)

//QUrl::UserInputResolutionOption
type QUrl__UserInputResolutionOption int64

const (
	QUrl__DefaultResolution = QUrl__UserInputResolutionOption(0)
	QUrl__AssumeLocalFile   = QUrl__UserInputResolutionOption(1)
)

func QUrl_FromEncoded(input string, parsingMode QUrl__ParsingMode) *QUrl {
	defer qt.Recovering("QUrl::fromEncoded")

	return NewQUrlFromPointer(C.QUrl_QUrl_FromEncoded(C.CString(input), C.int(parsingMode)))
}

func NewQUrl() *QUrl {
	defer qt.Recovering("QUrl::QUrl")

	return newQUrlFromPointer(C.QUrl_NewQUrl())
}

func NewQUrl4(other QUrl_ITF) *QUrl {
	defer qt.Recovering("QUrl::QUrl")

	return newQUrlFromPointer(C.QUrl_NewQUrl4(PointerFromQUrl(other)))
}

func NewQUrl3(url string, parsingMode QUrl__ParsingMode) *QUrl {
	defer qt.Recovering("QUrl::QUrl")

	return newQUrlFromPointer(C.QUrl_NewQUrl3(C.CString(url), C.int(parsingMode)))
}

func NewQUrl2(other QUrl_ITF) *QUrl {
	defer qt.Recovering("QUrl::QUrl")

	return newQUrlFromPointer(C.QUrl_NewQUrl2(PointerFromQUrl(other)))
}

func (ptr *QUrl) Adjusted(options QUrl__UrlFormattingOption) *QUrl {
	defer qt.Recovering("QUrl::adjusted")

	if ptr.Pointer() != nil {
		return NewQUrlFromPointer(C.QUrl_Adjusted(ptr.Pointer(), C.int(options)))
	}
	return nil
}

func (ptr *QUrl) Authority(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::authority")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_Authority(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) Clear() {
	defer qt.Recovering("QUrl::clear")

	if ptr.Pointer() != nil {
		C.QUrl_Clear(ptr.Pointer())
	}
}

func (ptr *QUrl) ErrorString() string {
	defer qt.Recovering("QUrl::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_ErrorString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUrl) FileName(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_FileName(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) Fragment(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::fragment")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_Fragment(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func QUrl_FromAce(domain string) string {
	defer qt.Recovering("QUrl::fromAce")

	return C.GoString(C.QUrl_QUrl_FromAce(C.CString(domain)))
}

func QUrl_FromLocalFile(localFile string) *QUrl {
	defer qt.Recovering("QUrl::fromLocalFile")

	return NewQUrlFromPointer(C.QUrl_QUrl_FromLocalFile(C.CString(localFile)))
}

func QUrl_FromPercentEncoding(input string) string {
	defer qt.Recovering("QUrl::fromPercentEncoding")

	return C.GoString(C.QUrl_QUrl_FromPercentEncoding(C.CString(input)))
}

func QUrl_FromUserInput(userInput string) *QUrl {
	defer qt.Recovering("QUrl::fromUserInput")

	return NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput(C.CString(userInput)))
}

func QUrl_FromUserInput2(userInput string, workingDirectory string, options QUrl__UserInputResolutionOption) *QUrl {
	defer qt.Recovering("QUrl::fromUserInput")

	return NewQUrlFromPointer(C.QUrl_QUrl_FromUserInput2(C.CString(userInput), C.CString(workingDirectory), C.int(options)))
}

func (ptr *QUrl) HasFragment() bool {
	defer qt.Recovering("QUrl::hasFragment")

	if ptr.Pointer() != nil {
		return C.QUrl_HasFragment(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QUrl) HasQuery() bool {
	defer qt.Recovering("QUrl::hasQuery")

	if ptr.Pointer() != nil {
		return C.QUrl_HasQuery(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QUrl) Host(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::host")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_Host(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func QUrl_IdnWhitelist() []string {
	defer qt.Recovering("QUrl::idnWhitelist")

	return strings.Split(C.GoString(C.QUrl_QUrl_IdnWhitelist()), "|")
}

func (ptr *QUrl) IsEmpty() bool {
	defer qt.Recovering("QUrl::isEmpty")

	if ptr.Pointer() != nil {
		return C.QUrl_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QUrl) IsLocalFile() bool {
	defer qt.Recovering("QUrl::isLocalFile")

	if ptr.Pointer() != nil {
		return C.QUrl_IsLocalFile(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QUrl) IsParentOf(childUrl QUrl_ITF) bool {
	defer qt.Recovering("QUrl::isParentOf")

	if ptr.Pointer() != nil {
		return C.QUrl_IsParentOf(ptr.Pointer(), PointerFromQUrl(childUrl)) != 0
	}
	return false
}

func (ptr *QUrl) IsRelative() bool {
	defer qt.Recovering("QUrl::isRelative")

	if ptr.Pointer() != nil {
		return C.QUrl_IsRelative(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QUrl) IsValid() bool {
	defer qt.Recovering("QUrl::isValid")

	if ptr.Pointer() != nil {
		return C.QUrl_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QUrl) Matches(url QUrl_ITF, options QUrl__UrlFormattingOption) bool {
	defer qt.Recovering("QUrl::matches")

	if ptr.Pointer() != nil {
		return C.QUrl_Matches(ptr.Pointer(), PointerFromQUrl(url), C.int(options)) != 0
	}
	return false
}

func (ptr *QUrl) Password(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::password")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_Password(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) Path(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::path")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_Path(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) Port(defaultPort int) int {
	defer qt.Recovering("QUrl::port")

	if ptr.Pointer() != nil {
		return int(C.QUrl_Port(ptr.Pointer(), C.int(defaultPort)))
	}
	return 0
}

func (ptr *QUrl) Query(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::query")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_Query(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) Resolved(relative QUrl_ITF) *QUrl {
	defer qt.Recovering("QUrl::resolved")

	if ptr.Pointer() != nil {
		return NewQUrlFromPointer(C.QUrl_Resolved(ptr.Pointer(), PointerFromQUrl(relative)))
	}
	return nil
}

func (ptr *QUrl) Scheme() string {
	defer qt.Recovering("QUrl::scheme")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_Scheme(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUrl) SetAuthority(authority string, mode QUrl__ParsingMode) {
	defer qt.Recovering("QUrl::setAuthority")

	if ptr.Pointer() != nil {
		C.QUrl_SetAuthority(ptr.Pointer(), C.CString(authority), C.int(mode))
	}
}

func (ptr *QUrl) SetFragment(fragment string, mode QUrl__ParsingMode) {
	defer qt.Recovering("QUrl::setFragment")

	if ptr.Pointer() != nil {
		C.QUrl_SetFragment(ptr.Pointer(), C.CString(fragment), C.int(mode))
	}
}

func (ptr *QUrl) SetHost(host string, mode QUrl__ParsingMode) {
	defer qt.Recovering("QUrl::setHost")

	if ptr.Pointer() != nil {
		C.QUrl_SetHost(ptr.Pointer(), C.CString(host), C.int(mode))
	}
}

func QUrl_SetIdnWhitelist(list []string) {
	defer qt.Recovering("QUrl::setIdnWhitelist")

	C.QUrl_QUrl_SetIdnWhitelist(C.CString(strings.Join(list, "|")))
}

func (ptr *QUrl) SetPassword(password string, mode QUrl__ParsingMode) {
	defer qt.Recovering("QUrl::setPassword")

	if ptr.Pointer() != nil {
		C.QUrl_SetPassword(ptr.Pointer(), C.CString(password), C.int(mode))
	}
}

func (ptr *QUrl) SetPath(path string, mode QUrl__ParsingMode) {
	defer qt.Recovering("QUrl::setPath")

	if ptr.Pointer() != nil {
		C.QUrl_SetPath(ptr.Pointer(), C.CString(path), C.int(mode))
	}
}

func (ptr *QUrl) SetPort(port int) {
	defer qt.Recovering("QUrl::setPort")

	if ptr.Pointer() != nil {
		C.QUrl_SetPort(ptr.Pointer(), C.int(port))
	}
}

func (ptr *QUrl) SetQuery(query string, mode QUrl__ParsingMode) {
	defer qt.Recovering("QUrl::setQuery")

	if ptr.Pointer() != nil {
		C.QUrl_SetQuery(ptr.Pointer(), C.CString(query), C.int(mode))
	}
}

func (ptr *QUrl) SetQuery2(query QUrlQuery_ITF) {
	defer qt.Recovering("QUrl::setQuery")

	if ptr.Pointer() != nil {
		C.QUrl_SetQuery2(ptr.Pointer(), PointerFromQUrlQuery(query))
	}
}

func (ptr *QUrl) SetScheme(scheme string) {
	defer qt.Recovering("QUrl::setScheme")

	if ptr.Pointer() != nil {
		C.QUrl_SetScheme(ptr.Pointer(), C.CString(scheme))
	}
}

func (ptr *QUrl) SetUrl(url string, parsingMode QUrl__ParsingMode) {
	defer qt.Recovering("QUrl::setUrl")

	if ptr.Pointer() != nil {
		C.QUrl_SetUrl(ptr.Pointer(), C.CString(url), C.int(parsingMode))
	}
}

func (ptr *QUrl) SetUserInfo(userInfo string, mode QUrl__ParsingMode) {
	defer qt.Recovering("QUrl::setUserInfo")

	if ptr.Pointer() != nil {
		C.QUrl_SetUserInfo(ptr.Pointer(), C.CString(userInfo), C.int(mode))
	}
}

func (ptr *QUrl) SetUserName(userName string, mode QUrl__ParsingMode) {
	defer qt.Recovering("QUrl::setUserName")

	if ptr.Pointer() != nil {
		C.QUrl_SetUserName(ptr.Pointer(), C.CString(userName), C.int(mode))
	}
}

func (ptr *QUrl) Swap(other QUrl_ITF) {
	defer qt.Recovering("QUrl::swap")

	if ptr.Pointer() != nil {
		C.QUrl_Swap(ptr.Pointer(), PointerFromQUrl(other))
	}
}

func QUrl_ToAce(domain string) string {
	defer qt.Recovering("QUrl::toAce")

	return C.GoString(C.QUrl_QUrl_ToAce(C.CString(domain)))
}

func (ptr *QUrl) ToDisplayString(options QUrl__UrlFormattingOption) string {
	defer qt.Recovering("QUrl::toDisplayString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_ToDisplayString(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) ToEncoded(options QUrl__UrlFormattingOption) string {
	defer qt.Recovering("QUrl::toEncoded")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_ToEncoded(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) ToLocalFile() string {
	defer qt.Recovering("QUrl::toLocalFile")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_ToLocalFile(ptr.Pointer()))
	}
	return ""
}

func QUrl_ToPercentEncoding(input string, exclude string, include string) string {
	defer qt.Recovering("QUrl::toPercentEncoding")

	return C.GoString(C.QUrl_QUrl_ToPercentEncoding(C.CString(input), C.CString(exclude), C.CString(include)))
}

func (ptr *QUrl) ToString(options QUrl__UrlFormattingOption) string {
	defer qt.Recovering("QUrl::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_ToString(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) TopLevelDomain(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::topLevelDomain")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_TopLevelDomain(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) Url(options QUrl__UrlFormattingOption) string {
	defer qt.Recovering("QUrl::url")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_Url(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) UserInfo(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::userInfo")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_UserInfo(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) UserName(options QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrl::userName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrl_UserName(ptr.Pointer(), C.int(options)))
	}
	return ""
}

func (ptr *QUrl) DestroyQUrl() {
	defer qt.Recovering("QUrl::~QUrl")

	if ptr.Pointer() != nil {
		C.QUrl_DestroyQUrl(ptr.Pointer())
	}
}

type QUrlQuery struct {
	ptr unsafe.Pointer
}

type QUrlQuery_ITF interface {
	QUrlQuery_PTR() *QUrlQuery
}

func (p *QUrlQuery) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QUrlQuery) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQUrlQuery(ptr QUrlQuery_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUrlQuery_PTR().Pointer()
	}
	return nil
}

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

func newQUrlQueryFromPointer(ptr unsafe.Pointer) *QUrlQuery {
	var n = NewQUrlQueryFromPointer(ptr)
	return n
}

func (ptr *QUrlQuery) QUrlQuery_PTR() *QUrlQuery {
	return ptr
}

func NewQUrlQuery() *QUrlQuery {
	defer qt.Recovering("QUrlQuery::QUrlQuery")

	return newQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery())
}

func NewQUrlQuery3(queryString string) *QUrlQuery {
	defer qt.Recovering("QUrlQuery::QUrlQuery")

	return newQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery3(C.CString(queryString)))
}

func NewQUrlQuery2(url QUrl_ITF) *QUrlQuery {
	defer qt.Recovering("QUrlQuery::QUrlQuery")

	return newQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery2(PointerFromQUrl(url)))
}

func NewQUrlQuery4(other QUrlQuery_ITF) *QUrlQuery {
	defer qt.Recovering("QUrlQuery::QUrlQuery")

	return newQUrlQueryFromPointer(C.QUrlQuery_NewQUrlQuery4(PointerFromQUrlQuery(other)))
}

func (ptr *QUrlQuery) AddQueryItem(key string, value string) {
	defer qt.Recovering("QUrlQuery::addQueryItem")

	if ptr.Pointer() != nil {
		C.QUrlQuery_AddQueryItem(ptr.Pointer(), C.CString(key), C.CString(value))
	}
}

func (ptr *QUrlQuery) AllQueryItemValues(key string, encoding QUrl__ComponentFormattingOption) []string {
	defer qt.Recovering("QUrlQuery::allQueryItemValues")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QUrlQuery_AllQueryItemValues(ptr.Pointer(), C.CString(key), C.int(encoding))), "|")
	}
	return make([]string, 0)
}

func (ptr *QUrlQuery) Clear() {
	defer qt.Recovering("QUrlQuery::clear")

	if ptr.Pointer() != nil {
		C.QUrlQuery_Clear(ptr.Pointer())
	}
}

func (ptr *QUrlQuery) IsEmpty() bool {
	defer qt.Recovering("QUrlQuery::isEmpty")

	if ptr.Pointer() != nil {
		return C.QUrlQuery_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QUrlQuery) Query(encoding QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrlQuery::query")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrlQuery_Query(ptr.Pointer(), C.int(encoding)))
	}
	return ""
}

func (ptr *QUrlQuery) RemoveAllQueryItems(key string) {
	defer qt.Recovering("QUrlQuery::removeAllQueryItems")

	if ptr.Pointer() != nil {
		C.QUrlQuery_RemoveAllQueryItems(ptr.Pointer(), C.CString(key))
	}
}

func (ptr *QUrlQuery) RemoveQueryItem(key string) {
	defer qt.Recovering("QUrlQuery::removeQueryItem")

	if ptr.Pointer() != nil {
		C.QUrlQuery_RemoveQueryItem(ptr.Pointer(), C.CString(key))
	}
}

func (ptr *QUrlQuery) SetQuery(queryString string) {
	defer qt.Recovering("QUrlQuery::setQuery")

	if ptr.Pointer() != nil {
		C.QUrlQuery_SetQuery(ptr.Pointer(), C.CString(queryString))
	}
}

func (ptr *QUrlQuery) SetQueryDelimiters(valueDelimiter QChar_ITF, pairDelimiter QChar_ITF) {
	defer qt.Recovering("QUrlQuery::setQueryDelimiters")

	if ptr.Pointer() != nil {
		C.QUrlQuery_SetQueryDelimiters(ptr.Pointer(), PointerFromQChar(valueDelimiter), PointerFromQChar(pairDelimiter))
	}
}

func (ptr *QUrlQuery) Swap(other QUrlQuery_ITF) {
	defer qt.Recovering("QUrlQuery::swap")

	if ptr.Pointer() != nil {
		C.QUrlQuery_Swap(ptr.Pointer(), PointerFromQUrlQuery(other))
	}
}

func (ptr *QUrlQuery) ToString(encoding QUrl__ComponentFormattingOption) string {
	defer qt.Recovering("QUrlQuery::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUrlQuery_ToString(ptr.Pointer(), C.int(encoding)))
	}
	return ""
}

func (ptr *QUrlQuery) DestroyQUrlQuery() {
	defer qt.Recovering("QUrlQuery::~QUrlQuery")

	if ptr.Pointer() != nil {
		C.QUrlQuery_DestroyQUrlQuery(ptr.Pointer())
	}
}

type QUuid struct {
	ptr unsafe.Pointer
}

type QUuid_ITF interface {
	QUuid_PTR() *QUuid
}

func (p *QUuid) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QUuid) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQUuid(ptr QUuid_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUuid_PTR().Pointer()
	}
	return nil
}

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

func newQUuidFromPointer(ptr unsafe.Pointer) *QUuid {
	var n = NewQUuidFromPointer(ptr)
	return n
}

func (ptr *QUuid) QUuid_PTR() *QUuid {
	return ptr
}

//QUuid::Variant
type QUuid__Variant int64

const (
	QUuid__VarUnknown = QUuid__Variant(-1)
	QUuid__NCS        = QUuid__Variant(0)
	QUuid__DCE        = QUuid__Variant(2)
	QUuid__Microsoft  = QUuid__Variant(6)
	QUuid__Reserved   = QUuid__Variant(7)
)

//QUuid::Version
type QUuid__Version int64

const (
	QUuid__VerUnknown    = QUuid__Version(-1)
	QUuid__Time          = QUuid__Version(1)
	QUuid__EmbeddedPOSIX = QUuid__Version(2)
	QUuid__Md5           = QUuid__Version(3)
	QUuid__Name          = QUuid__Version(QUuid__Md5)
	QUuid__Random        = QUuid__Version(4)
	QUuid__Sha1          = QUuid__Version(5)
)

func (ptr *QUuid) Variant() QUuid__Variant {
	defer qt.Recovering("QUuid::variant")

	if ptr.Pointer() != nil {
		return QUuid__Variant(C.QUuid_Variant(ptr.Pointer()))
	}
	return 0
}

func (ptr *QUuid) Version() QUuid__Version {
	defer qt.Recovering("QUuid::version")

	if ptr.Pointer() != nil {
		return QUuid__Version(C.QUuid_Version(ptr.Pointer()))
	}
	return 0
}

func NewQUuid() *QUuid {
	defer qt.Recovering("QUuid::QUuid")

	return newQUuidFromPointer(C.QUuid_NewQUuid())
}

func NewQUuid5(text string) *QUuid {
	defer qt.Recovering("QUuid::QUuid")

	return newQUuidFromPointer(C.QUuid_NewQUuid5(C.CString(text)))
}

func NewQUuid3(text string) *QUuid {
	defer qt.Recovering("QUuid::QUuid")

	return newQUuidFromPointer(C.QUuid_NewQUuid3(C.CString(text)))
}

func (ptr *QUuid) IsNull() bool {
	defer qt.Recovering("QUuid::isNull")

	if ptr.Pointer() != nil {
		return C.QUuid_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QUuid) ToByteArray() string {
	defer qt.Recovering("QUuid::toByteArray")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUuid_ToByteArray(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUuid) ToRfc4122() string {
	defer qt.Recovering("QUuid::toRfc4122")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUuid_ToRfc4122(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUuid) ToString() string {
	defer qt.Recovering("QUuid::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QUuid_ToString(ptr.Pointer()))
	}
	return ""
}

type QVarLengthArray struct {
	ptr unsafe.Pointer
}

type QVarLengthArray_ITF interface {
	QVarLengthArray_PTR() *QVarLengthArray
}

func (p *QVarLengthArray) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QVarLengthArray) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQVarLengthArray(ptr QVarLengthArray_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVarLengthArray_PTR().Pointer()
	}
	return nil
}

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

func newQVarLengthArrayFromPointer(ptr unsafe.Pointer) *QVarLengthArray {
	var n = NewQVarLengthArrayFromPointer(ptr)
	return n
}

func (ptr *QVarLengthArray) QVarLengthArray_PTR() *QVarLengthArray {
	return ptr
}

type QVariant struct {
	ptr unsafe.Pointer
}

type QVariant_ITF interface {
	QVariant_PTR() *QVariant
}

func (p *QVariant) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QVariant) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQVariant(ptr QVariant_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVariant_PTR().Pointer()
	}
	return nil
}

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

func newQVariantFromPointer(ptr unsafe.Pointer) *QVariant {
	var n = NewQVariantFromPointer(ptr)
	return n
}

func (ptr *QVariant) QVariant_PTR() *QVariant {
	return ptr
}

func NewQVariant20(c QChar_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant20(PointerFromQChar(c)))
}

func NewQVariant18(val QLatin1String_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant18(PointerFromQLatin1String(val)))
}

func NewQVariant11(val bool) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant11(C.int(qt.GoBoolToInt(val))))
}

func NewQVariant16(val QBitArray_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant16(PointerFromQBitArray(val)))
}

func NewQVariant15(val string) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant15(C.CString(val)))
}

func NewQVariant21(val QDate_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant21(PointerFromQDate(val)))
}

func NewQVariant23(val QDateTime_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant23(PointerFromQDateTime(val)))
}

func NewQVariant39(val QEasingCurve_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant39(PointerFromQEasingCurve(val)))
}

func NewQVariant45(val QJsonArray_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant45(PointerFromQJsonArray(val)))
}

func NewQVariant46(val QJsonDocument_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant46(PointerFromQJsonDocument(val)))
}

func NewQVariant44(val QJsonObject_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant44(PointerFromQJsonObject(val)))
}

func NewQVariant43(val QJsonValue_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant43(PointerFromQJsonValue(val)))
}

func NewQVariant31(val QLine_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant31(PointerFromQLine(val)))
}

func NewQVariant32(val QLineF_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant32(PointerFromQLineF(val)))
}

func NewQVariant35(l QLocale_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant35(PointerFromQLocale(l)))
}

func NewQVariant41(val QModelIndex_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant41(PointerFromQModelIndex(val)))
}

func NewQVariant42(val QPersistentModelIndex_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant42(PointerFromQPersistentModelIndex(val)))
}

func NewQVariant29(val QPoint_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant29(PointerFromQPoint(val)))
}

func NewQVariant30(val QPointF_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant30(PointerFromQPointF(val)))
}

func NewQVariant33(val QRect_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant33(PointerFromQRect(val)))
}

func NewQVariant34(val QRectF_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant34(PointerFromQRectF(val)))
}

func NewQVariant36(regExp QRegExp_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant36(PointerFromQRegExp(regExp)))
}

func NewQVariant37(re QRegularExpression_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant37(PointerFromQRegularExpression(re)))
}

func NewQVariant27(val QSize_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant27(PointerFromQSize(val)))
}

func NewQVariant28(val QSizeF_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant28(PointerFromQSizeF(val)))
}

func NewQVariant17(val string) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant17(C.CString(val)))
}

func NewQVariant19(val []string) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant19(C.CString(strings.Join(val, "|"))))
}

func NewQVariant22(val QTime_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant22(PointerFromQTime(val)))
}

func NewQVariant38(val QUrl_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant38(PointerFromQUrl(val)))
}

func NewQVariant40(val QUuid_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant40(PointerFromQUuid(val)))
}

func NewQVariant5(p QVariant_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant5(PointerFromQVariant(p)))
}

func NewQVariant14(val string) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant14(C.CString(val)))
}

func NewQVariant3(typeId int, copy unsafe.Pointer) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant3(C.int(typeId), copy))
}

func NewQVariant7(val int) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant7(C.int(val)))
}

func (ptr *QVariant) ToByteArray() string {
	defer qt.Recovering("QVariant::toByteArray")

	if ptr.Pointer() != nil {
		return C.GoString(C.QVariant_ToByteArray(ptr.Pointer()))
	}
	return ""
}

func (ptr *QVariant) ToDateTime() *QDateTime {
	defer qt.Recovering("QVariant::toDateTime")

	if ptr.Pointer() != nil {
		return NewQDateTimeFromPointer(C.QVariant_ToDateTime(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToEasingCurve() *QEasingCurve {
	defer qt.Recovering("QVariant::toEasingCurve")

	if ptr.Pointer() != nil {
		return NewQEasingCurveFromPointer(C.QVariant_ToEasingCurve(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToLocale() *QLocale {
	defer qt.Recovering("QVariant::toLocale")

	if ptr.Pointer() != nil {
		return NewQLocaleFromPointer(C.QVariant_ToLocale(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToPoint() *QPoint {
	defer qt.Recovering("QVariant::toPoint")

	if ptr.Pointer() != nil {
		return NewQPointFromPointer(C.QVariant_ToPoint(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToRect() *QRect {
	defer qt.Recovering("QVariant::toRect")

	if ptr.Pointer() != nil {
		return NewQRectFromPointer(C.QVariant_ToRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToRegExp() *QRegExp {
	defer qt.Recovering("QVariant::toRegExp")

	if ptr.Pointer() != nil {
		return NewQRegExpFromPointer(C.QVariant_ToRegExp(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToRegularExpression() *QRegularExpression {
	defer qt.Recovering("QVariant::toRegularExpression")

	if ptr.Pointer() != nil {
		return NewQRegularExpressionFromPointer(C.QVariant_ToRegularExpression(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToSize() *QSize {
	defer qt.Recovering("QVariant::toSize")

	if ptr.Pointer() != nil {
		return NewQSizeFromPointer(C.QVariant_ToSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToStringList() []string {
	defer qt.Recovering("QVariant::toStringList")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QVariant_ToStringList(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QVariant) ToUrl() *QUrl {
	defer qt.Recovering("QVariant::toUrl")

	if ptr.Pointer() != nil {
		return NewQUrlFromPointer(C.QVariant_ToUrl(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) DestroyQVariant() {
	defer qt.Recovering("QVariant::~QVariant")

	if ptr.Pointer() != nil {
		C.QVariant_DestroyQVariant(ptr.Pointer())
	}
}

func NewQVariant() *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant())
}

func NewQVariant6(s QDataStream_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant6(PointerFromQDataStream(s)))
}

func NewQVariant47(other QVariant_ITF) *QVariant {
	defer qt.Recovering("QVariant::QVariant")

	return newQVariantFromPointer(C.QVariant_NewQVariant47(PointerFromQVariant(other)))
}

func (ptr *QVariant) Clear() {
	defer qt.Recovering("QVariant::clear")

	if ptr.Pointer() != nil {
		C.QVariant_Clear(ptr.Pointer())
	}
}

func (ptr *QVariant) Convert(targetTypeId int) bool {
	defer qt.Recovering("QVariant::convert")

	if ptr.Pointer() != nil {
		return C.QVariant_Convert(ptr.Pointer(), C.int(targetTypeId)) != 0
	}
	return false
}

func (ptr *QVariant) IsNull() bool {
	defer qt.Recovering("QVariant::isNull")

	if ptr.Pointer() != nil {
		return C.QVariant_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QVariant) IsValid() bool {
	defer qt.Recovering("QVariant::isValid")

	if ptr.Pointer() != nil {
		return C.QVariant_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QVariant) Swap(other QVariant_ITF) {
	defer qt.Recovering("QVariant::swap")

	if ptr.Pointer() != nil {
		C.QVariant_Swap(ptr.Pointer(), PointerFromQVariant(other))
	}
}

func (ptr *QVariant) ToBitArray() *QBitArray {
	defer qt.Recovering("QVariant::toBitArray")

	if ptr.Pointer() != nil {
		return NewQBitArrayFromPointer(C.QVariant_ToBitArray(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToBool() bool {
	defer qt.Recovering("QVariant::toBool")

	if ptr.Pointer() != nil {
		return C.QVariant_ToBool(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QVariant) ToInt(ok bool) int {
	defer qt.Recovering("QVariant::toInt")

	if ptr.Pointer() != nil {
		return int(C.QVariant_ToInt(ptr.Pointer(), C.int(qt.GoBoolToInt(ok))))
	}
	return 0
}

func (ptr *QVariant) ToJsonArray() *QJsonArray {
	defer qt.Recovering("QVariant::toJsonArray")

	if ptr.Pointer() != nil {
		return NewQJsonArrayFromPointer(C.QVariant_ToJsonArray(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToJsonDocument() *QJsonDocument {
	defer qt.Recovering("QVariant::toJsonDocument")

	if ptr.Pointer() != nil {
		return NewQJsonDocumentFromPointer(C.QVariant_ToJsonDocument(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToJsonObject() *QJsonObject {
	defer qt.Recovering("QVariant::toJsonObject")

	if ptr.Pointer() != nil {
		return NewQJsonObjectFromPointer(C.QVariant_ToJsonObject(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToJsonValue() *QJsonValue {
	defer qt.Recovering("QVariant::toJsonValue")

	if ptr.Pointer() != nil {
		return NewQJsonValueFromPointer(C.QVariant_ToJsonValue(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToPersistentModelIndex() *QPersistentModelIndex {
	defer qt.Recovering("QVariant::toPersistentModelIndex")

	if ptr.Pointer() != nil {
		return NewQPersistentModelIndexFromPointer(C.QVariant_ToPersistentModelIndex(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariant) ToReal(ok bool) float64 {
	defer qt.Recovering("QVariant::toReal")

	if ptr.Pointer() != nil {
		return float64(C.QVariant_ToReal(ptr.Pointer(), C.int(qt.GoBoolToInt(ok))))
	}
	return 0
}

func (ptr *QVariant) ToString() string {
	defer qt.Recovering("QVariant::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QVariant_ToString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QVariant) UserType() int {
	defer qt.Recovering("QVariant::userType")

	if ptr.Pointer() != nil {
		return int(C.QVariant_UserType(ptr.Pointer()))
	}
	return 0
}

type QVariantAnimation struct {
	QAbstractAnimation
}

type QVariantAnimation_ITF interface {
	QAbstractAnimation_ITF
	QVariantAnimation_PTR() *QVariantAnimation
}

func PointerFromQVariantAnimation(ptr QVariantAnimation_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVariantAnimation_PTR().Pointer()
	}
	return nil
}

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

func newQVariantAnimationFromPointer(ptr unsafe.Pointer) *QVariantAnimation {
	var n = NewQVariantAnimationFromPointer(ptr)
	for len(n.ObjectName()) < len("QVariantAnimation_") {
		n.SetObjectName("QVariantAnimation_" + qt.Identifier())
	}
	return n
}

func (ptr *QVariantAnimation) QVariantAnimation_PTR() *QVariantAnimation {
	return ptr
}

func (ptr *QVariantAnimation) CurrentValue() *QVariant {
	defer qt.Recovering("QVariantAnimation::currentValue")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QVariantAnimation_CurrentValue(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariantAnimation) Duration() int {
	defer qt.Recovering("QVariantAnimation::duration")

	if ptr.Pointer() != nil {
		return int(C.QVariantAnimation_Duration(ptr.Pointer()))
	}
	return 0
}

func (ptr *QVariantAnimation) EasingCurve() *QEasingCurve {
	defer qt.Recovering("QVariantAnimation::easingCurve")

	if ptr.Pointer() != nil {
		return NewQEasingCurveFromPointer(C.QVariantAnimation_EasingCurve(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariantAnimation) EndValue() *QVariant {
	defer qt.Recovering("QVariantAnimation::endValue")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QVariantAnimation_EndValue(ptr.Pointer()))
	}
	return nil
}

func (ptr *QVariantAnimation) SetDuration(msecs int) {
	defer qt.Recovering("QVariantAnimation::setDuration")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetDuration(ptr.Pointer(), C.int(msecs))
	}
}

func (ptr *QVariantAnimation) SetEasingCurve(easing QEasingCurve_ITF) {
	defer qt.Recovering("QVariantAnimation::setEasingCurve")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetEasingCurve(ptr.Pointer(), PointerFromQEasingCurve(easing))
	}
}

func (ptr *QVariantAnimation) SetEndValue(value QVariant_ITF) {
	defer qt.Recovering("QVariantAnimation::setEndValue")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetEndValue(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) SetStartValue(value QVariant_ITF) {
	defer qt.Recovering("QVariantAnimation::setStartValue")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetStartValue(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) StartValue() *QVariant {
	defer qt.Recovering("QVariantAnimation::startValue")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QVariantAnimation_StartValue(ptr.Pointer()))
	}
	return nil
}

func NewQVariantAnimation(parent QObject_ITF) *QVariantAnimation {
	defer qt.Recovering("QVariantAnimation::QVariantAnimation")

	return newQVariantAnimationFromPointer(C.QVariantAnimation_NewQVariantAnimation(PointerFromQObject(parent)))
}

func (ptr *QVariantAnimation) KeyValueAt(step float64) *QVariant {
	defer qt.Recovering("QVariantAnimation::keyValueAt")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QVariantAnimation_KeyValueAt(ptr.Pointer(), C.double(step)))
	}
	return nil
}

func (ptr *QVariantAnimation) Event(event QEvent_ITF) bool {
	defer qt.Recovering("QVariantAnimation::event")

	if ptr.Pointer() != nil {
		return C.QVariantAnimation_Event(ptr.Pointer(), PointerFromQEvent(event)) != 0
	}
	return false
}

func (ptr *QVariantAnimation) Interpolated(from QVariant_ITF, to QVariant_ITF, progress float64) *QVariant {
	defer qt.Recovering("QVariantAnimation::interpolated")

	if ptr.Pointer() != nil {
		return NewQVariantFromPointer(C.QVariantAnimation_Interpolated(ptr.Pointer(), PointerFromQVariant(from), PointerFromQVariant(to), C.double(progress)))
	}
	return nil
}

func (ptr *QVariantAnimation) SetKeyValueAt(step float64, value QVariant_ITF) {
	defer qt.Recovering("QVariantAnimation::setKeyValueAt")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_SetKeyValueAt(ptr.Pointer(), C.double(step), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) ConnectUpdateCurrentTime(f func(v int)) {
	defer qt.Recovering("connect QVariantAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
	}
}

func (ptr *QVariantAnimation) DisconnectUpdateCurrentTime() {
	defer qt.Recovering("disconnect QVariantAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {

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

//export callbackQVariantAnimationUpdateCurrentTime
func callbackQVariantAnimationUpdateCurrentTime(ptr unsafe.Pointer, ptrName *C.char, v C.int) {
	defer qt.Recovering("callback QVariantAnimation::updateCurrentTime")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
		signal.(func(int))(int(v))
	} else {
		NewQVariantAnimationFromPointer(ptr).UpdateCurrentTimeDefault(int(v))
	}
}

func (ptr *QVariantAnimation) UpdateCurrentTime(v int) {
	defer qt.Recovering("QVariantAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateCurrentTime(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QVariantAnimation) UpdateCurrentTimeDefault(v int) {
	defer qt.Recovering("QVariantAnimation::updateCurrentTime")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateCurrentTimeDefault(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QVariantAnimation) ConnectUpdateCurrentValue(f func(value *QVariant)) {
	defer qt.Recovering("connect QVariantAnimation::updateCurrentValue")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateCurrentValue", f)
	}
}

func (ptr *QVariantAnimation) DisconnectUpdateCurrentValue() {
	defer qt.Recovering("disconnect QVariantAnimation::updateCurrentValue")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentValue")
	}
}

//export callbackQVariantAnimationUpdateCurrentValue
func callbackQVariantAnimationUpdateCurrentValue(ptr unsafe.Pointer, ptrName *C.char, value unsafe.Pointer) {
	defer qt.Recovering("callback QVariantAnimation::updateCurrentValue")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentValue"); signal != nil {
		signal.(func(*QVariant))(NewQVariantFromPointer(value))
	} else {
		NewQVariantAnimationFromPointer(ptr).UpdateCurrentValueDefault(NewQVariantFromPointer(value))
	}
}

func (ptr *QVariantAnimation) UpdateCurrentValue(value QVariant_ITF) {
	defer qt.Recovering("QVariantAnimation::updateCurrentValue")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateCurrentValue(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) UpdateCurrentValueDefault(value QVariant_ITF) {
	defer qt.Recovering("QVariantAnimation::updateCurrentValue")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateCurrentValueDefault(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
	defer qt.Recovering("connect QVariantAnimation::updateState")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
	}
}

func (ptr *QVariantAnimation) DisconnectUpdateState() {
	defer qt.Recovering("disconnect QVariantAnimation::updateState")

	if ptr.Pointer() != nil {

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

//export callbackQVariantAnimationUpdateState
func callbackQVariantAnimationUpdateState(ptr unsafe.Pointer, ptrName *C.char, newState C.int, oldState C.int) {
	defer qt.Recovering("callback QVariantAnimation::updateState")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
		signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	} else {
		NewQVariantAnimationFromPointer(ptr).UpdateStateDefault(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
	}
}

func (ptr *QVariantAnimation) UpdateState(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QVariantAnimation::updateState")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateState(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QVariantAnimation) UpdateStateDefault(newState QAbstractAnimation__State, oldState QAbstractAnimation__State) {
	defer qt.Recovering("QVariantAnimation::updateState")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateStateDefault(ptr.Pointer(), C.int(newState), C.int(oldState))
	}
}

func (ptr *QVariantAnimation) ConnectValueChanged(f func(value *QVariant)) {
	defer qt.Recovering("connect QVariantAnimation::valueChanged")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_ConnectValueChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "valueChanged", f)
	}
}

func (ptr *QVariantAnimation) DisconnectValueChanged() {
	defer qt.Recovering("disconnect QVariantAnimation::valueChanged")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_DisconnectValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "valueChanged")
	}
}

//export callbackQVariantAnimationValueChanged
func callbackQVariantAnimationValueChanged(ptr unsafe.Pointer, ptrName *C.char, value unsafe.Pointer) {
	defer qt.Recovering("callback QVariantAnimation::valueChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "valueChanged"); signal != nil {
		signal.(func(*QVariant))(NewQVariantFromPointer(value))
	}

}

func (ptr *QVariantAnimation) ValueChanged(value QVariant_ITF) {
	defer qt.Recovering("QVariantAnimation::valueChanged")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_ValueChanged(ptr.Pointer(), PointerFromQVariant(value))
	}
}

func (ptr *QVariantAnimation) DestroyQVariantAnimation() {
	defer qt.Recovering("QVariantAnimation::~QVariantAnimation")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_DestroyQVariantAnimation(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QVariantAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
	defer qt.Recovering("connect QVariantAnimation::updateDirection")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
	}
}

func (ptr *QVariantAnimation) DisconnectUpdateDirection() {
	defer qt.Recovering("disconnect QVariantAnimation::updateDirection")

	if ptr.Pointer() != nil {

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

//export callbackQVariantAnimationUpdateDirection
func callbackQVariantAnimationUpdateDirection(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
	defer qt.Recovering("callback QVariantAnimation::updateDirection")

	if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
	} else {
		NewQVariantAnimationFromPointer(ptr).UpdateDirectionDefault(QAbstractAnimation__Direction(direction))
	}
}

func (ptr *QVariantAnimation) UpdateDirection(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QVariantAnimation::updateDirection")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QVariantAnimation) UpdateDirectionDefault(direction QAbstractAnimation__Direction) {
	defer qt.Recovering("QVariantAnimation::updateDirection")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_UpdateDirectionDefault(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QVariantAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
	defer qt.Recovering("connect QVariantAnimation::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QVariantAnimation) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QVariantAnimation::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQVariantAnimationTimerEvent
func callbackQVariantAnimationTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QVariantAnimation::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
	} else {
		NewQVariantAnimationFromPointer(ptr).TimerEventDefault(NewQTimerEventFromPointer(event))
	}
}

func (ptr *QVariantAnimation) TimerEvent(event QTimerEvent_ITF) {
	defer qt.Recovering("QVariantAnimation::timerEvent")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_TimerEvent(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QVariantAnimation) TimerEventDefault(event QTimerEvent_ITF) {
	defer qt.Recovering("QVariantAnimation::timerEvent")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_TimerEventDefault(ptr.Pointer(), PointerFromQTimerEvent(event))
	}
}

func (ptr *QVariantAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
	defer qt.Recovering("connect QVariantAnimation::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QVariantAnimation) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QVariantAnimation::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQVariantAnimationChildEvent
func callbackQVariantAnimationChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QVariantAnimation::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
	} else {
		NewQVariantAnimationFromPointer(ptr).ChildEventDefault(NewQChildEventFromPointer(event))
	}
}

func (ptr *QVariantAnimation) ChildEvent(event QChildEvent_ITF) {
	defer qt.Recovering("QVariantAnimation::childEvent")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_ChildEvent(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QVariantAnimation) ChildEventDefault(event QChildEvent_ITF) {
	defer qt.Recovering("QVariantAnimation::childEvent")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_ChildEventDefault(ptr.Pointer(), PointerFromQChildEvent(event))
	}
}

func (ptr *QVariantAnimation) ConnectCustomEvent(f func(event *QEvent)) {
	defer qt.Recovering("connect QVariantAnimation::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QVariantAnimation) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QVariantAnimation::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQVariantAnimationCustomEvent
func callbackQVariantAnimationCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QVariantAnimation::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*QEvent))(NewQEventFromPointer(event))
	} else {
		NewQVariantAnimationFromPointer(ptr).CustomEventDefault(NewQEventFromPointer(event))
	}
}

func (ptr *QVariantAnimation) CustomEvent(event QEvent_ITF) {
	defer qt.Recovering("QVariantAnimation::customEvent")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_CustomEvent(ptr.Pointer(), PointerFromQEvent(event))
	}
}

func (ptr *QVariantAnimation) CustomEventDefault(event QEvent_ITF) {
	defer qt.Recovering("QVariantAnimation::customEvent")

	if ptr.Pointer() != nil {
		C.QVariantAnimation_CustomEventDefault(ptr.Pointer(), PointerFromQEvent(event))
	}
}

type QVector struct {
	ptr unsafe.Pointer
}

type QVector_ITF interface {
	QVector_PTR() *QVector
}

func (p *QVector) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QVector) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQVector(ptr QVector_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVector_PTR().Pointer()
	}
	return nil
}

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

func newQVectorFromPointer(ptr unsafe.Pointer) *QVector {
	var n = NewQVectorFromPointer(ptr)
	return n
}

func (ptr *QVector) QVector_PTR() *QVector {
	return ptr
}

type QVectorIterator struct {
	ptr unsafe.Pointer
}

type QVectorIterator_ITF interface {
	QVectorIterator_PTR() *QVectorIterator
}

func (p *QVectorIterator) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QVectorIterator) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQVectorIterator(ptr QVectorIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVectorIterator_PTR().Pointer()
	}
	return nil
}

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

func newQVectorIteratorFromPointer(ptr unsafe.Pointer) *QVectorIterator {
	var n = NewQVectorIteratorFromPointer(ptr)
	return n
}

func (ptr *QVectorIterator) QVectorIterator_PTR() *QVectorIterator {
	return ptr
}

type QWaitCondition struct {
	ptr unsafe.Pointer
}

type QWaitCondition_ITF interface {
	QWaitCondition_PTR() *QWaitCondition
}

func (p *QWaitCondition) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QWaitCondition) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQWaitCondition(ptr QWaitCondition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWaitCondition_PTR().Pointer()
	}
	return nil
}

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

func newQWaitConditionFromPointer(ptr unsafe.Pointer) *QWaitCondition {
	var n = NewQWaitConditionFromPointer(ptr)
	return n
}

func (ptr *QWaitCondition) QWaitCondition_PTR() *QWaitCondition {
	return ptr
}

func NewQWaitCondition() *QWaitCondition {
	defer qt.Recovering("QWaitCondition::QWaitCondition")

	return newQWaitConditionFromPointer(C.QWaitCondition_NewQWaitCondition())
}

func (ptr *QWaitCondition) WakeAll() {
	defer qt.Recovering("QWaitCondition::wakeAll")

	if ptr.Pointer() != nil {
		C.QWaitCondition_WakeAll(ptr.Pointer())
	}
}

func (ptr *QWaitCondition) WakeOne() {
	defer qt.Recovering("QWaitCondition::wakeOne")

	if ptr.Pointer() != nil {
		C.QWaitCondition_WakeOne(ptr.Pointer())
	}
}

func (ptr *QWaitCondition) DestroyQWaitCondition() {
	defer qt.Recovering("QWaitCondition::~QWaitCondition")

	if ptr.Pointer() != nil {
		C.QWaitCondition_DestroyQWaitCondition(ptr.Pointer())
	}
}

type QWeakPointer struct {
	ptr unsafe.Pointer
}

type QWeakPointer_ITF interface {
	QWeakPointer_PTR() *QWeakPointer
}

func (p *QWeakPointer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QWeakPointer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQWeakPointer(ptr QWeakPointer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWeakPointer_PTR().Pointer()
	}
	return nil
}

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

func newQWeakPointerFromPointer(ptr unsafe.Pointer) *QWeakPointer {
	var n = NewQWeakPointerFromPointer(ptr)
	return n
}

func (ptr *QWeakPointer) QWeakPointer_PTR() *QWeakPointer {
	return ptr
}

type QWinEventNotifier struct {
	QObject
}

type QWinEventNotifier_ITF interface {
	QObject_ITF
	QWinEventNotifier_PTR() *QWinEventNotifier
}

func PointerFromQWinEventNotifier(ptr QWinEventNotifier_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWinEventNotifier_PTR().Pointer()
	}
	return nil
}

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

func newQWinEventNotifierFromPointer(ptr unsafe.Pointer) *QWinEventNotifier {
	var n = NewQWinEventNotifierFromPointer(ptr)
	for len(n.ObjectName()) < len("QWinEventNotifier_") {
		n.SetObjectName("QWinEventNotifier_" + qt.Identifier())
	}
	return n
}

func (ptr *QWinEventNotifier) QWinEventNotifier_PTR() *QWinEventNotifier {
	return ptr
}

type QWriteLocker struct {
	ptr unsafe.Pointer
}

type QWriteLocker_ITF interface {
	QWriteLocker_PTR() *QWriteLocker
}

func (p *QWriteLocker) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QWriteLocker) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQWriteLocker(ptr QWriteLocker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWriteLocker_PTR().Pointer()
	}
	return nil
}

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

func newQWriteLockerFromPointer(ptr unsafe.Pointer) *QWriteLocker {
	var n = NewQWriteLockerFromPointer(ptr)
	return n
}

func (ptr *QWriteLocker) QWriteLocker_PTR() *QWriteLocker {
	return ptr
}

func NewQWriteLocker(lock QReadWriteLock_ITF) *QWriteLocker {
	defer qt.Recovering("QWriteLocker::QWriteLocker")

	return newQWriteLockerFromPointer(C.QWriteLocker_NewQWriteLocker(PointerFromQReadWriteLock(lock)))
}

func (ptr *QWriteLocker) ReadWriteLock() *QReadWriteLock {
	defer qt.Recovering("QWriteLocker::readWriteLock")

	if ptr.Pointer() != nil {
		return NewQReadWriteLockFromPointer(C.QWriteLocker_ReadWriteLock(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWriteLocker) Relock() {
	defer qt.Recovering("QWriteLocker::relock")

	if ptr.Pointer() != nil {
		C.QWriteLocker_Relock(ptr.Pointer())
	}
}

func (ptr *QWriteLocker) Unlock() {
	defer qt.Recovering("QWriteLocker::unlock")

	if ptr.Pointer() != nil {
		C.QWriteLocker_Unlock(ptr.Pointer())
	}
}

func (ptr *QWriteLocker) DestroyQWriteLocker() {
	defer qt.Recovering("QWriteLocker::~QWriteLocker")

	if ptr.Pointer() != nil {
		C.QWriteLocker_DestroyQWriteLocker(ptr.Pointer())
	}
}

type QXmlStreamAttribute struct {
	ptr unsafe.Pointer
}

type QXmlStreamAttribute_ITF interface {
	QXmlStreamAttribute_PTR() *QXmlStreamAttribute
}

func (p *QXmlStreamAttribute) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QXmlStreamAttribute) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQXmlStreamAttribute(ptr QXmlStreamAttribute_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamAttribute_PTR().Pointer()
	}
	return nil
}

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

func newQXmlStreamAttributeFromPointer(ptr unsafe.Pointer) *QXmlStreamAttribute {
	var n = NewQXmlStreamAttributeFromPointer(ptr)
	return n
}

func (ptr *QXmlStreamAttribute) QXmlStreamAttribute_PTR() *QXmlStreamAttribute {
	return ptr
}

func NewQXmlStreamAttribute() *QXmlStreamAttribute {
	defer qt.Recovering("QXmlStreamAttribute::QXmlStreamAttribute")

	return newQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute())
}

func NewQXmlStreamAttribute3(namespaceUri string, name string, value string) *QXmlStreamAttribute {
	defer qt.Recovering("QXmlStreamAttribute::QXmlStreamAttribute")

	return newQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute3(C.CString(namespaceUri), C.CString(name), C.CString(value)))
}

func NewQXmlStreamAttribute2(qualifiedName string, value string) *QXmlStreamAttribute {
	defer qt.Recovering("QXmlStreamAttribute::QXmlStreamAttribute")

	return newQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute2(C.CString(qualifiedName), C.CString(value)))
}

func NewQXmlStreamAttribute4(other QXmlStreamAttribute_ITF) *QXmlStreamAttribute {
	defer qt.Recovering("QXmlStreamAttribute::QXmlStreamAttribute")

	return newQXmlStreamAttributeFromPointer(C.QXmlStreamAttribute_NewQXmlStreamAttribute4(PointerFromQXmlStreamAttribute(other)))
}

func (ptr *QXmlStreamAttribute) IsDefault() bool {
	defer qt.Recovering("QXmlStreamAttribute::isDefault")

	if ptr.Pointer() != nil {
		return C.QXmlStreamAttribute_IsDefault(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamAttribute) Name() *QStringRef {
	defer qt.Recovering("QXmlStreamAttribute::name")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttribute_Name(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamAttribute) NamespaceUri() *QStringRef {
	defer qt.Recovering("QXmlStreamAttribute::namespaceUri")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttribute_NamespaceUri(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamAttribute) Prefix() *QStringRef {
	defer qt.Recovering("QXmlStreamAttribute::prefix")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttribute_Prefix(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamAttribute) QualifiedName() *QStringRef {
	defer qt.Recovering("QXmlStreamAttribute::qualifiedName")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttribute_QualifiedName(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamAttribute) Value() *QStringRef {
	defer qt.Recovering("QXmlStreamAttribute::value")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttribute_Value(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamAttribute) DestroyQXmlStreamAttribute() {
	defer qt.Recovering("QXmlStreamAttribute::~QXmlStreamAttribute")

	if ptr.Pointer() != nil {
		C.QXmlStreamAttribute_DestroyQXmlStreamAttribute(ptr.Pointer())
	}
}

type QXmlStreamAttributes struct {
	QVector
}

type QXmlStreamAttributes_ITF interface {
	QVector_ITF
	QXmlStreamAttributes_PTR() *QXmlStreamAttributes
}

func PointerFromQXmlStreamAttributes(ptr QXmlStreamAttributes_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamAttributes_PTR().Pointer()
	}
	return nil
}

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

func newQXmlStreamAttributesFromPointer(ptr unsafe.Pointer) *QXmlStreamAttributes {
	var n = NewQXmlStreamAttributesFromPointer(ptr)
	return n
}

func (ptr *QXmlStreamAttributes) QXmlStreamAttributes_PTR() *QXmlStreamAttributes {
	return ptr
}

func NewQXmlStreamAttributes() *QXmlStreamAttributes {
	defer qt.Recovering("QXmlStreamAttributes::QXmlStreamAttributes")

	return newQXmlStreamAttributesFromPointer(C.QXmlStreamAttributes_NewQXmlStreamAttributes())
}

func (ptr *QXmlStreamAttributes) Append(namespaceUri string, name string, value string) {
	defer qt.Recovering("QXmlStreamAttributes::append")

	if ptr.Pointer() != nil {
		C.QXmlStreamAttributes_Append(ptr.Pointer(), C.CString(namespaceUri), C.CString(name), C.CString(value))
	}
}

func (ptr *QXmlStreamAttributes) Append2(qualifiedName string, value string) {
	defer qt.Recovering("QXmlStreamAttributes::append")

	if ptr.Pointer() != nil {
		C.QXmlStreamAttributes_Append2(ptr.Pointer(), C.CString(qualifiedName), C.CString(value))
	}
}

func (ptr *QXmlStreamAttributes) HasAttribute2(qualifiedName QLatin1String_ITF) bool {
	defer qt.Recovering("QXmlStreamAttributes::hasAttribute")

	if ptr.Pointer() != nil {
		return C.QXmlStreamAttributes_HasAttribute2(ptr.Pointer(), PointerFromQLatin1String(qualifiedName)) != 0
	}
	return false
}

func (ptr *QXmlStreamAttributes) HasAttribute3(namespaceUri string, name string) bool {
	defer qt.Recovering("QXmlStreamAttributes::hasAttribute")

	if ptr.Pointer() != nil {
		return C.QXmlStreamAttributes_HasAttribute3(ptr.Pointer(), C.CString(namespaceUri), C.CString(name)) != 0
	}
	return false
}

func (ptr *QXmlStreamAttributes) HasAttribute(qualifiedName string) bool {
	defer qt.Recovering("QXmlStreamAttributes::hasAttribute")

	if ptr.Pointer() != nil {
		return C.QXmlStreamAttributes_HasAttribute(ptr.Pointer(), C.CString(qualifiedName)) != 0
	}
	return false
}

func (ptr *QXmlStreamAttributes) Value3(namespaceUri QLatin1String_ITF, name QLatin1String_ITF) *QStringRef {
	defer qt.Recovering("QXmlStreamAttributes::value")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value3(ptr.Pointer(), PointerFromQLatin1String(namespaceUri), PointerFromQLatin1String(name)))
	}
	return nil
}

func (ptr *QXmlStreamAttributes) Value5(qualifiedName QLatin1String_ITF) *QStringRef {
	defer qt.Recovering("QXmlStreamAttributes::value")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value5(ptr.Pointer(), PointerFromQLatin1String(qualifiedName)))
	}
	return nil
}

func (ptr *QXmlStreamAttributes) Value2(namespaceUri string, name QLatin1String_ITF) *QStringRef {
	defer qt.Recovering("QXmlStreamAttributes::value")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value2(ptr.Pointer(), C.CString(namespaceUri), PointerFromQLatin1String(name)))
	}
	return nil
}

func (ptr *QXmlStreamAttributes) Value(namespaceUri string, name string) *QStringRef {
	defer qt.Recovering("QXmlStreamAttributes::value")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value(ptr.Pointer(), C.CString(namespaceUri), C.CString(name)))
	}
	return nil
}

func (ptr *QXmlStreamAttributes) Value4(qualifiedName string) *QStringRef {
	defer qt.Recovering("QXmlStreamAttributes::value")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamAttributes_Value4(ptr.Pointer(), C.CString(qualifiedName)))
	}
	return nil
}

type QXmlStreamEntityDeclaration struct {
	ptr unsafe.Pointer
}

type QXmlStreamEntityDeclaration_ITF interface {
	QXmlStreamEntityDeclaration_PTR() *QXmlStreamEntityDeclaration
}

func (p *QXmlStreamEntityDeclaration) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QXmlStreamEntityDeclaration) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQXmlStreamEntityDeclaration(ptr QXmlStreamEntityDeclaration_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamEntityDeclaration_PTR().Pointer()
	}
	return nil
}

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

func newQXmlStreamEntityDeclarationFromPointer(ptr unsafe.Pointer) *QXmlStreamEntityDeclaration {
	var n = NewQXmlStreamEntityDeclarationFromPointer(ptr)
	return n
}

func (ptr *QXmlStreamEntityDeclaration) QXmlStreamEntityDeclaration_PTR() *QXmlStreamEntityDeclaration {
	return ptr
}

func NewQXmlStreamEntityDeclaration() *QXmlStreamEntityDeclaration {
	defer qt.Recovering("QXmlStreamEntityDeclaration::QXmlStreamEntityDeclaration")

	return newQXmlStreamEntityDeclarationFromPointer(C.QXmlStreamEntityDeclaration_NewQXmlStreamEntityDeclaration())
}

func NewQXmlStreamEntityDeclaration2(other QXmlStreamEntityDeclaration_ITF) *QXmlStreamEntityDeclaration {
	defer qt.Recovering("QXmlStreamEntityDeclaration::QXmlStreamEntityDeclaration")

	return newQXmlStreamEntityDeclarationFromPointer(C.QXmlStreamEntityDeclaration_NewQXmlStreamEntityDeclaration2(PointerFromQXmlStreamEntityDeclaration(other)))
}

func (ptr *QXmlStreamEntityDeclaration) Name() *QStringRef {
	defer qt.Recovering("QXmlStreamEntityDeclaration::name")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_Name(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) NotationName() *QStringRef {
	defer qt.Recovering("QXmlStreamEntityDeclaration::notationName")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_NotationName(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) PublicId() *QStringRef {
	defer qt.Recovering("QXmlStreamEntityDeclaration::publicId")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_PublicId(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) SystemId() *QStringRef {
	defer qt.Recovering("QXmlStreamEntityDeclaration::systemId")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_SystemId(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) Value() *QStringRef {
	defer qt.Recovering("QXmlStreamEntityDeclaration::value")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamEntityDeclaration_Value(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamEntityDeclaration) DestroyQXmlStreamEntityDeclaration() {
	defer qt.Recovering("QXmlStreamEntityDeclaration::~QXmlStreamEntityDeclaration")

	if ptr.Pointer() != nil {
		C.QXmlStreamEntityDeclaration_DestroyQXmlStreamEntityDeclaration(ptr.Pointer())
	}
}

type QXmlStreamEntityResolver struct {
	ptr unsafe.Pointer
}

type QXmlStreamEntityResolver_ITF interface {
	QXmlStreamEntityResolver_PTR() *QXmlStreamEntityResolver
}

func (p *QXmlStreamEntityResolver) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QXmlStreamEntityResolver) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQXmlStreamEntityResolver(ptr QXmlStreamEntityResolver_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamEntityResolver_PTR().Pointer()
	}
	return nil
}

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

func newQXmlStreamEntityResolverFromPointer(ptr unsafe.Pointer) *QXmlStreamEntityResolver {
	var n = NewQXmlStreamEntityResolverFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QXmlStreamEntityResolver_") {
		n.SetObjectNameAbs("QXmlStreamEntityResolver_" + qt.Identifier())
	}
	return n
}

func (ptr *QXmlStreamEntityResolver) QXmlStreamEntityResolver_PTR() *QXmlStreamEntityResolver {
	return ptr
}

func (ptr *QXmlStreamEntityResolver) ResolveUndeclaredEntity(name string) string {
	defer qt.Recovering("QXmlStreamEntityResolver::resolveUndeclaredEntity")

	if ptr.Pointer() != nil {
		return C.GoString(C.QXmlStreamEntityResolver_ResolveUndeclaredEntity(ptr.Pointer(), C.CString(name)))
	}
	return ""
}

func (ptr *QXmlStreamEntityResolver) DestroyQXmlStreamEntityResolver() {
	defer qt.Recovering("QXmlStreamEntityResolver::~QXmlStreamEntityResolver")

	if ptr.Pointer() != nil {
		C.QXmlStreamEntityResolver_DestroyQXmlStreamEntityResolver(ptr.Pointer())
	}
}

func (ptr *QXmlStreamEntityResolver) ObjectNameAbs() string {
	defer qt.Recovering("QXmlStreamEntityResolver::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QXmlStreamEntityResolver_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QXmlStreamEntityResolver) SetObjectNameAbs(name string) {
	defer qt.Recovering("QXmlStreamEntityResolver::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QXmlStreamEntityResolver_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QXmlStreamNamespaceDeclaration struct {
	ptr unsafe.Pointer
}

type QXmlStreamNamespaceDeclaration_ITF interface {
	QXmlStreamNamespaceDeclaration_PTR() *QXmlStreamNamespaceDeclaration
}

func (p *QXmlStreamNamespaceDeclaration) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QXmlStreamNamespaceDeclaration) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQXmlStreamNamespaceDeclaration(ptr QXmlStreamNamespaceDeclaration_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamNamespaceDeclaration_PTR().Pointer()
	}
	return nil
}

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

func newQXmlStreamNamespaceDeclarationFromPointer(ptr unsafe.Pointer) *QXmlStreamNamespaceDeclaration {
	var n = NewQXmlStreamNamespaceDeclarationFromPointer(ptr)
	return n
}

func (ptr *QXmlStreamNamespaceDeclaration) QXmlStreamNamespaceDeclaration_PTR() *QXmlStreamNamespaceDeclaration {
	return ptr
}

func NewQXmlStreamNamespaceDeclaration() *QXmlStreamNamespaceDeclaration {
	defer qt.Recovering("QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration")

	return newQXmlStreamNamespaceDeclarationFromPointer(C.QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration())
}

func NewQXmlStreamNamespaceDeclaration3(prefix string, namespaceUri string) *QXmlStreamNamespaceDeclaration {
	defer qt.Recovering("QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration")

	return newQXmlStreamNamespaceDeclarationFromPointer(C.QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration3(C.CString(prefix), C.CString(namespaceUri)))
}

func NewQXmlStreamNamespaceDeclaration2(other QXmlStreamNamespaceDeclaration_ITF) *QXmlStreamNamespaceDeclaration {
	defer qt.Recovering("QXmlStreamNamespaceDeclaration::QXmlStreamNamespaceDeclaration")

	return newQXmlStreamNamespaceDeclarationFromPointer(C.QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration2(PointerFromQXmlStreamNamespaceDeclaration(other)))
}

func (ptr *QXmlStreamNamespaceDeclaration) NamespaceUri() *QStringRef {
	defer qt.Recovering("QXmlStreamNamespaceDeclaration::namespaceUri")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamNamespaceDeclaration_NamespaceUri(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamNamespaceDeclaration) Prefix() *QStringRef {
	defer qt.Recovering("QXmlStreamNamespaceDeclaration::prefix")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamNamespaceDeclaration_Prefix(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamNamespaceDeclaration) DestroyQXmlStreamNamespaceDeclaration() {
	defer qt.Recovering("QXmlStreamNamespaceDeclaration::~QXmlStreamNamespaceDeclaration")

	if ptr.Pointer() != nil {
		C.QXmlStreamNamespaceDeclaration_DestroyQXmlStreamNamespaceDeclaration(ptr.Pointer())
	}
}

type QXmlStreamNotationDeclaration struct {
	ptr unsafe.Pointer
}

type QXmlStreamNotationDeclaration_ITF interface {
	QXmlStreamNotationDeclaration_PTR() *QXmlStreamNotationDeclaration
}

func (p *QXmlStreamNotationDeclaration) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QXmlStreamNotationDeclaration) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQXmlStreamNotationDeclaration(ptr QXmlStreamNotationDeclaration_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamNotationDeclaration_PTR().Pointer()
	}
	return nil
}

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

func newQXmlStreamNotationDeclarationFromPointer(ptr unsafe.Pointer) *QXmlStreamNotationDeclaration {
	var n = NewQXmlStreamNotationDeclarationFromPointer(ptr)
	return n
}

func (ptr *QXmlStreamNotationDeclaration) QXmlStreamNotationDeclaration_PTR() *QXmlStreamNotationDeclaration {
	return ptr
}

func NewQXmlStreamNotationDeclaration() *QXmlStreamNotationDeclaration {
	defer qt.Recovering("QXmlStreamNotationDeclaration::QXmlStreamNotationDeclaration")

	return newQXmlStreamNotationDeclarationFromPointer(C.QXmlStreamNotationDeclaration_NewQXmlStreamNotationDeclaration())
}

func NewQXmlStreamNotationDeclaration2(other QXmlStreamNotationDeclaration_ITF) *QXmlStreamNotationDeclaration {
	defer qt.Recovering("QXmlStreamNotationDeclaration::QXmlStreamNotationDeclaration")

	return newQXmlStreamNotationDeclarationFromPointer(C.QXmlStreamNotationDeclaration_NewQXmlStreamNotationDeclaration2(PointerFromQXmlStreamNotationDeclaration(other)))
}

func (ptr *QXmlStreamNotationDeclaration) Name() *QStringRef {
	defer qt.Recovering("QXmlStreamNotationDeclaration::name")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamNotationDeclaration_Name(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamNotationDeclaration) PublicId() *QStringRef {
	defer qt.Recovering("QXmlStreamNotationDeclaration::publicId")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamNotationDeclaration_PublicId(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamNotationDeclaration) SystemId() *QStringRef {
	defer qt.Recovering("QXmlStreamNotationDeclaration::systemId")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamNotationDeclaration_SystemId(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamNotationDeclaration) DestroyQXmlStreamNotationDeclaration() {
	defer qt.Recovering("QXmlStreamNotationDeclaration::~QXmlStreamNotationDeclaration")

	if ptr.Pointer() != nil {
		C.QXmlStreamNotationDeclaration_DestroyQXmlStreamNotationDeclaration(ptr.Pointer())
	}
}

type QXmlStreamReader struct {
	ptr unsafe.Pointer
}

type QXmlStreamReader_ITF interface {
	QXmlStreamReader_PTR() *QXmlStreamReader
}

func (p *QXmlStreamReader) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QXmlStreamReader) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQXmlStreamReader(ptr QXmlStreamReader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamReader_PTR().Pointer()
	}
	return nil
}

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

func newQXmlStreamReaderFromPointer(ptr unsafe.Pointer) *QXmlStreamReader {
	var n = NewQXmlStreamReaderFromPointer(ptr)
	return n
}

func (ptr *QXmlStreamReader) QXmlStreamReader_PTR() *QXmlStreamReader {
	return ptr
}

//QXmlStreamReader::Error
type QXmlStreamReader__Error int64

const (
	QXmlStreamReader__NoError                     = QXmlStreamReader__Error(0)
	QXmlStreamReader__UnexpectedElementError      = QXmlStreamReader__Error(1)
	QXmlStreamReader__CustomError                 = QXmlStreamReader__Error(2)
	QXmlStreamReader__NotWellFormedError          = QXmlStreamReader__Error(3)
	QXmlStreamReader__PrematureEndOfDocumentError = QXmlStreamReader__Error(4)
)

//QXmlStreamReader::ReadElementTextBehaviour
type QXmlStreamReader__ReadElementTextBehaviour int64

const (
	QXmlStreamReader__ErrorOnUnexpectedElement = QXmlStreamReader__ReadElementTextBehaviour(0)
	QXmlStreamReader__IncludeChildElements     = QXmlStreamReader__ReadElementTextBehaviour(1)
	QXmlStreamReader__SkipChildElements        = QXmlStreamReader__ReadElementTextBehaviour(2)
)

//QXmlStreamReader::TokenType
type QXmlStreamReader__TokenType int64

const (
	QXmlStreamReader__NoToken               = QXmlStreamReader__TokenType(0)
	QXmlStreamReader__Invalid               = QXmlStreamReader__TokenType(1)
	QXmlStreamReader__StartDocument         = QXmlStreamReader__TokenType(2)
	QXmlStreamReader__EndDocument           = QXmlStreamReader__TokenType(3)
	QXmlStreamReader__StartElement          = QXmlStreamReader__TokenType(4)
	QXmlStreamReader__EndElement            = QXmlStreamReader__TokenType(5)
	QXmlStreamReader__Characters            = QXmlStreamReader__TokenType(6)
	QXmlStreamReader__Comment               = QXmlStreamReader__TokenType(7)
	QXmlStreamReader__DTD                   = QXmlStreamReader__TokenType(8)
	QXmlStreamReader__EntityReference       = QXmlStreamReader__TokenType(9)
	QXmlStreamReader__ProcessingInstruction = QXmlStreamReader__TokenType(10)
)

func (ptr *QXmlStreamReader) NamespaceProcessing() bool {
	defer qt.Recovering("QXmlStreamReader::namespaceProcessing")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_NamespaceProcessing(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) SetNamespaceProcessing(v bool) {
	defer qt.Recovering("QXmlStreamReader::setNamespaceProcessing")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_SetNamespaceProcessing(ptr.Pointer(), C.int(qt.GoBoolToInt(v)))
	}
}

func NewQXmlStreamReader() *QXmlStreamReader {
	defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")

	return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader())
}

func NewQXmlStreamReader2(device QIODevice_ITF) *QXmlStreamReader {
	defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")

	return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader2(PointerFromQIODevice(device)))
}

func NewQXmlStreamReader3(data string) *QXmlStreamReader {
	defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")

	return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader3(C.CString(data)))
}

func NewQXmlStreamReader4(data string) *QXmlStreamReader {
	defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")

	return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader4(C.CString(data)))
}

func NewQXmlStreamReader5(data string) *QXmlStreamReader {
	defer qt.Recovering("QXmlStreamReader::QXmlStreamReader")

	return newQXmlStreamReaderFromPointer(C.QXmlStreamReader_NewQXmlStreamReader5(C.CString(data)))
}

func (ptr *QXmlStreamReader) AddData(data string) {
	defer qt.Recovering("QXmlStreamReader::addData")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_AddData(ptr.Pointer(), C.CString(data))
	}
}

func (ptr *QXmlStreamReader) AddData2(data string) {
	defer qt.Recovering("QXmlStreamReader::addData")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_AddData2(ptr.Pointer(), C.CString(data))
	}
}

func (ptr *QXmlStreamReader) AddData3(data string) {
	defer qt.Recovering("QXmlStreamReader::addData")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_AddData3(ptr.Pointer(), C.CString(data))
	}
}

func (ptr *QXmlStreamReader) AddExtraNamespaceDeclaration(extraNamespaceDeclaration QXmlStreamNamespaceDeclaration_ITF) {
	defer qt.Recovering("QXmlStreamReader::addExtraNamespaceDeclaration")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_AddExtraNamespaceDeclaration(ptr.Pointer(), PointerFromQXmlStreamNamespaceDeclaration(extraNamespaceDeclaration))
	}
}

func (ptr *QXmlStreamReader) AtEnd() bool {
	defer qt.Recovering("QXmlStreamReader::atEnd")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_AtEnd(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) CharacterOffset() int64 {
	defer qt.Recovering("QXmlStreamReader::characterOffset")

	if ptr.Pointer() != nil {
		return int64(C.QXmlStreamReader_CharacterOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) Clear() {
	defer qt.Recovering("QXmlStreamReader::clear")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_Clear(ptr.Pointer())
	}
}

func (ptr *QXmlStreamReader) ColumnNumber() int64 {
	defer qt.Recovering("QXmlStreamReader::columnNumber")

	if ptr.Pointer() != nil {
		return int64(C.QXmlStreamReader_ColumnNumber(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) Device() *QIODevice {
	defer qt.Recovering("QXmlStreamReader::device")

	if ptr.Pointer() != nil {
		return NewQIODeviceFromPointer(C.QXmlStreamReader_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) DocumentEncoding() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::documentEncoding")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_DocumentEncoding(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) DocumentVersion() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::documentVersion")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_DocumentVersion(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) DtdName() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::dtdName")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_DtdName(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) DtdPublicId() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::dtdPublicId")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_DtdPublicId(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) DtdSystemId() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::dtdSystemId")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_DtdSystemId(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) EntityResolver() *QXmlStreamEntityResolver {
	defer qt.Recovering("QXmlStreamReader::entityResolver")

	if ptr.Pointer() != nil {
		return NewQXmlStreamEntityResolverFromPointer(C.QXmlStreamReader_EntityResolver(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) Error() QXmlStreamReader__Error {
	defer qt.Recovering("QXmlStreamReader::error")

	if ptr.Pointer() != nil {
		return QXmlStreamReader__Error(C.QXmlStreamReader_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) ErrorString() string {
	defer qt.Recovering("QXmlStreamReader::errorString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QXmlStreamReader_ErrorString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QXmlStreamReader) HasError() bool {
	defer qt.Recovering("QXmlStreamReader::hasError")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_HasError(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsCDATA() bool {
	defer qt.Recovering("QXmlStreamReader::isCDATA")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsCDATA(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsCharacters() bool {
	defer qt.Recovering("QXmlStreamReader::isCharacters")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsCharacters(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsComment() bool {
	defer qt.Recovering("QXmlStreamReader::isComment")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsComment(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsDTD() bool {
	defer qt.Recovering("QXmlStreamReader::isDTD")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsDTD(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsEndDocument() bool {
	defer qt.Recovering("QXmlStreamReader::isEndDocument")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsEndDocument(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsEndElement() bool {
	defer qt.Recovering("QXmlStreamReader::isEndElement")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsEndElement(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsEntityReference() bool {
	defer qt.Recovering("QXmlStreamReader::isEntityReference")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsEntityReference(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsProcessingInstruction() bool {
	defer qt.Recovering("QXmlStreamReader::isProcessingInstruction")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsProcessingInstruction(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsStandaloneDocument() bool {
	defer qt.Recovering("QXmlStreamReader::isStandaloneDocument")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsStandaloneDocument(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsStartDocument() bool {
	defer qt.Recovering("QXmlStreamReader::isStartDocument")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsStartDocument(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsStartElement() bool {
	defer qt.Recovering("QXmlStreamReader::isStartElement")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsStartElement(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) IsWhitespace() bool {
	defer qt.Recovering("QXmlStreamReader::isWhitespace")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_IsWhitespace(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) LineNumber() int64 {
	defer qt.Recovering("QXmlStreamReader::lineNumber")

	if ptr.Pointer() != nil {
		return int64(C.QXmlStreamReader_LineNumber(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) Name() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::name")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_Name(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) NamespaceUri() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::namespaceUri")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_NamespaceUri(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) Prefix() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::prefix")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_Prefix(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) ProcessingInstructionData() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::processingInstructionData")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_ProcessingInstructionData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) ProcessingInstructionTarget() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::processingInstructionTarget")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_ProcessingInstructionTarget(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) QualifiedName() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::qualifiedName")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_QualifiedName(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) RaiseError(message string) {
	defer qt.Recovering("QXmlStreamReader::raiseError")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_RaiseError(ptr.Pointer(), C.CString(message))
	}
}

func (ptr *QXmlStreamReader) ReadElementText(behaviour QXmlStreamReader__ReadElementTextBehaviour) string {
	defer qt.Recovering("QXmlStreamReader::readElementText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QXmlStreamReader_ReadElementText(ptr.Pointer(), C.int(behaviour)))
	}
	return ""
}

func (ptr *QXmlStreamReader) ReadNext() QXmlStreamReader__TokenType {
	defer qt.Recovering("QXmlStreamReader::readNext")

	if ptr.Pointer() != nil {
		return QXmlStreamReader__TokenType(C.QXmlStreamReader_ReadNext(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) ReadNextStartElement() bool {
	defer qt.Recovering("QXmlStreamReader::readNextStartElement")

	if ptr.Pointer() != nil {
		return C.QXmlStreamReader_ReadNextStartElement(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamReader) SetDevice(device QIODevice_ITF) {
	defer qt.Recovering("QXmlStreamReader::setDevice")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_SetDevice(ptr.Pointer(), PointerFromQIODevice(device))
	}
}

func (ptr *QXmlStreamReader) SetEntityResolver(resolver QXmlStreamEntityResolver_ITF) {
	defer qt.Recovering("QXmlStreamReader::setEntityResolver")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_SetEntityResolver(ptr.Pointer(), PointerFromQXmlStreamEntityResolver(resolver))
	}
}

func (ptr *QXmlStreamReader) SkipCurrentElement() {
	defer qt.Recovering("QXmlStreamReader::skipCurrentElement")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_SkipCurrentElement(ptr.Pointer())
	}
}

func (ptr *QXmlStreamReader) Text() *QStringRef {
	defer qt.Recovering("QXmlStreamReader::text")

	if ptr.Pointer() != nil {
		return NewQStringRefFromPointer(C.QXmlStreamReader_Text(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamReader) TokenString() string {
	defer qt.Recovering("QXmlStreamReader::tokenString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QXmlStreamReader_TokenString(ptr.Pointer()))
	}
	return ""
}

func (ptr *QXmlStreamReader) TokenType() QXmlStreamReader__TokenType {
	defer qt.Recovering("QXmlStreamReader::tokenType")

	if ptr.Pointer() != nil {
		return QXmlStreamReader__TokenType(C.QXmlStreamReader_TokenType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamReader) DestroyQXmlStreamReader() {
	defer qt.Recovering("QXmlStreamReader::~QXmlStreamReader")

	if ptr.Pointer() != nil {
		C.QXmlStreamReader_DestroyQXmlStreamReader(ptr.Pointer())
	}
}

type QXmlStreamWriter struct {
	ptr unsafe.Pointer
}

type QXmlStreamWriter_ITF interface {
	QXmlStreamWriter_PTR() *QXmlStreamWriter
}

func (p *QXmlStreamWriter) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QXmlStreamWriter) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQXmlStreamWriter(ptr QXmlStreamWriter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QXmlStreamWriter_PTR().Pointer()
	}
	return nil
}

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

func newQXmlStreamWriterFromPointer(ptr unsafe.Pointer) *QXmlStreamWriter {
	var n = NewQXmlStreamWriterFromPointer(ptr)
	return n
}

func (ptr *QXmlStreamWriter) QXmlStreamWriter_PTR() *QXmlStreamWriter {
	return ptr
}

func (ptr *QXmlStreamWriter) AutoFormattingIndent() int {
	defer qt.Recovering("QXmlStreamWriter::autoFormattingIndent")

	if ptr.Pointer() != nil {
		return int(C.QXmlStreamWriter_AutoFormattingIndent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QXmlStreamWriter) SetAutoFormattingIndent(spacesOrTabs int) {
	defer qt.Recovering("QXmlStreamWriter::setAutoFormattingIndent")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_SetAutoFormattingIndent(ptr.Pointer(), C.int(spacesOrTabs))
	}
}

func (ptr *QXmlStreamWriter) AutoFormatting() bool {
	defer qt.Recovering("QXmlStreamWriter::autoFormatting")

	if ptr.Pointer() != nil {
		return C.QXmlStreamWriter_AutoFormatting(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamWriter) Codec() *QTextCodec {
	defer qt.Recovering("QXmlStreamWriter::codec")

	if ptr.Pointer() != nil {
		return NewQTextCodecFromPointer(C.QXmlStreamWriter_Codec(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamWriter) Device() *QIODevice {
	defer qt.Recovering("QXmlStreamWriter::device")

	if ptr.Pointer() != nil {
		return NewQIODeviceFromPointer(C.QXmlStreamWriter_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QXmlStreamWriter) HasError() bool {
	defer qt.Recovering("QXmlStreamWriter::hasError")

	if ptr.Pointer() != nil {
		return C.QXmlStreamWriter_HasError(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QXmlStreamWriter) SetAutoFormatting(enable bool) {
	defer qt.Recovering("QXmlStreamWriter::setAutoFormatting")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_SetAutoFormatting(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QXmlStreamWriter) SetCodec(codec QTextCodec_ITF) {
	defer qt.Recovering("QXmlStreamWriter::setCodec")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_SetCodec(ptr.Pointer(), PointerFromQTextCodec(codec))
	}
}

func (ptr *QXmlStreamWriter) SetCodec2(codecName string) {
	defer qt.Recovering("QXmlStreamWriter::setCodec")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_SetCodec2(ptr.Pointer(), C.CString(codecName))
	}
}

func (ptr *QXmlStreamWriter) SetDevice(device QIODevice_ITF) {
	defer qt.Recovering("QXmlStreamWriter::setDevice")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_SetDevice(ptr.Pointer(), PointerFromQIODevice(device))
	}
}

func (ptr *QXmlStreamWriter) WriteAttribute(namespaceUri string, name string, value string) {
	defer qt.Recovering("QXmlStreamWriter::writeAttribute")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteAttribute(ptr.Pointer(), C.CString(namespaceUri), C.CString(name), C.CString(value))
	}
}

func (ptr *QXmlStreamWriter) WriteAttribute2(qualifiedName string, value string) {
	defer qt.Recovering("QXmlStreamWriter::writeAttribute")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteAttribute2(ptr.Pointer(), C.CString(qualifiedName), C.CString(value))
	}
}

func (ptr *QXmlStreamWriter) WriteAttribute3(attribute QXmlStreamAttribute_ITF) {
	defer qt.Recovering("QXmlStreamWriter::writeAttribute")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteAttribute3(ptr.Pointer(), PointerFromQXmlStreamAttribute(attribute))
	}
}

func (ptr *QXmlStreamWriter) WriteAttributes(attributes QXmlStreamAttributes_ITF) {
	defer qt.Recovering("QXmlStreamWriter::writeAttributes")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteAttributes(ptr.Pointer(), PointerFromQXmlStreamAttributes(attributes))
	}
}

func (ptr *QXmlStreamWriter) WriteCDATA(text string) {
	defer qt.Recovering("QXmlStreamWriter::writeCDATA")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteCDATA(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QXmlStreamWriter) WriteCharacters(text string) {
	defer qt.Recovering("QXmlStreamWriter::writeCharacters")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteCharacters(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QXmlStreamWriter) WriteComment(text string) {
	defer qt.Recovering("QXmlStreamWriter::writeComment")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteComment(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QXmlStreamWriter) WriteCurrentToken(reader QXmlStreamReader_ITF) {
	defer qt.Recovering("QXmlStreamWriter::writeCurrentToken")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteCurrentToken(ptr.Pointer(), PointerFromQXmlStreamReader(reader))
	}
}

func (ptr *QXmlStreamWriter) WriteDTD(dtd string) {
	defer qt.Recovering("QXmlStreamWriter::writeDTD")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteDTD(ptr.Pointer(), C.CString(dtd))
	}
}

func (ptr *QXmlStreamWriter) WriteDefaultNamespace(namespaceUri string) {
	defer qt.Recovering("QXmlStreamWriter::writeDefaultNamespace")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteDefaultNamespace(ptr.Pointer(), C.CString(namespaceUri))
	}
}

func (ptr *QXmlStreamWriter) WriteEmptyElement(namespaceUri string, name string) {
	defer qt.Recovering("QXmlStreamWriter::writeEmptyElement")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteEmptyElement(ptr.Pointer(), C.CString(namespaceUri), C.CString(name))
	}
}

func (ptr *QXmlStreamWriter) WriteEmptyElement2(qualifiedName string) {
	defer qt.Recovering("QXmlStreamWriter::writeEmptyElement")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteEmptyElement2(ptr.Pointer(), C.CString(qualifiedName))
	}
}

func (ptr *QXmlStreamWriter) WriteEndDocument() {
	defer qt.Recovering("QXmlStreamWriter::writeEndDocument")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteEndDocument(ptr.Pointer())
	}
}

func (ptr *QXmlStreamWriter) WriteEndElement() {
	defer qt.Recovering("QXmlStreamWriter::writeEndElement")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteEndElement(ptr.Pointer())
	}
}

func (ptr *QXmlStreamWriter) WriteEntityReference(name string) {
	defer qt.Recovering("QXmlStreamWriter::writeEntityReference")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteEntityReference(ptr.Pointer(), C.CString(name))
	}
}

func (ptr *QXmlStreamWriter) WriteNamespace(namespaceUri string, prefix string) {
	defer qt.Recovering("QXmlStreamWriter::writeNamespace")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteNamespace(ptr.Pointer(), C.CString(namespaceUri), C.CString(prefix))
	}
}

func (ptr *QXmlStreamWriter) WriteProcessingInstruction(target string, data string) {
	defer qt.Recovering("QXmlStreamWriter::writeProcessingInstruction")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteProcessingInstruction(ptr.Pointer(), C.CString(target), C.CString(data))
	}
}

func (ptr *QXmlStreamWriter) WriteStartDocument3() {
	defer qt.Recovering("QXmlStreamWriter::writeStartDocument")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteStartDocument3(ptr.Pointer())
	}
}

func (ptr *QXmlStreamWriter) WriteStartDocument(version string) {
	defer qt.Recovering("QXmlStreamWriter::writeStartDocument")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteStartDocument(ptr.Pointer(), C.CString(version))
	}
}

func (ptr *QXmlStreamWriter) WriteStartDocument2(version string, standalone bool) {
	defer qt.Recovering("QXmlStreamWriter::writeStartDocument")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteStartDocument2(ptr.Pointer(), C.CString(version), C.int(qt.GoBoolToInt(standalone)))
	}
}

func (ptr *QXmlStreamWriter) WriteStartElement(namespaceUri string, name string) {
	defer qt.Recovering("QXmlStreamWriter::writeStartElement")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteStartElement(ptr.Pointer(), C.CString(namespaceUri), C.CString(name))
	}
}

func (ptr *QXmlStreamWriter) WriteStartElement2(qualifiedName string) {
	defer qt.Recovering("QXmlStreamWriter::writeStartElement")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteStartElement2(ptr.Pointer(), C.CString(qualifiedName))
	}
}

func (ptr *QXmlStreamWriter) WriteTextElement(namespaceUri string, name string, text string) {
	defer qt.Recovering("QXmlStreamWriter::writeTextElement")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteTextElement(ptr.Pointer(), C.CString(namespaceUri), C.CString(name), C.CString(text))
	}
}

func (ptr *QXmlStreamWriter) WriteTextElement2(qualifiedName string, text string) {
	defer qt.Recovering("QXmlStreamWriter::writeTextElement")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_WriteTextElement2(ptr.Pointer(), C.CString(qualifiedName), C.CString(text))
	}
}

func (ptr *QXmlStreamWriter) DestroyQXmlStreamWriter() {
	defer qt.Recovering("QXmlStreamWriter::~QXmlStreamWriter")

	if ptr.Pointer() != nil {
		C.QXmlStreamWriter_DestroyQXmlStreamWriter(ptr.Pointer())
	}
}

//Qt::AlignmentFlag
type Qt__AlignmentFlag int64

const (
	Qt__AlignLeft            = Qt__AlignmentFlag(0x0001)
	Qt__AlignLeading         = Qt__AlignmentFlag(Qt__AlignLeft)
	Qt__AlignRight           = Qt__AlignmentFlag(0x0002)
	Qt__AlignTrailing        = Qt__AlignmentFlag(Qt__AlignRight)
	Qt__AlignHCenter         = Qt__AlignmentFlag(0x0004)
	Qt__AlignJustify         = Qt__AlignmentFlag(0x0008)
	Qt__AlignAbsolute        = Qt__AlignmentFlag(0x0010)
	Qt__AlignHorizontal_Mask = Qt__AlignmentFlag(Qt__AlignLeft | Qt__AlignRight | Qt__AlignHCenter | Qt__AlignJustify | Qt__AlignAbsolute)
	Qt__AlignTop             = Qt__AlignmentFlag(0x0020)
	Qt__AlignBottom          = Qt__AlignmentFlag(0x0040)
	Qt__AlignVCenter         = Qt__AlignmentFlag(0x0080)
	Qt__AlignBaseline        = Qt__AlignmentFlag(0x0100)
	Qt__AlignVertical_Mask   = Qt__AlignmentFlag(Qt__AlignTop | Qt__AlignBottom | Qt__AlignVCenter | Qt__AlignBaseline)
	Qt__AlignCenter          = Qt__AlignmentFlag(Qt__AlignVCenter | Qt__AlignHCenter)
)

//Qt::AnchorPoint
type Qt__AnchorPoint int64

const (
	Qt__AnchorLeft             = Qt__AnchorPoint(0)
	Qt__AnchorHorizontalCenter = Qt__AnchorPoint(1)
	Qt__AnchorRight            = Qt__AnchorPoint(2)
	Qt__AnchorTop              = Qt__AnchorPoint(3)
	Qt__AnchorVerticalCenter   = Qt__AnchorPoint(4)
	Qt__AnchorBottom           = Qt__AnchorPoint(5)
)

//Qt::ApplicationAttribute
type Qt__ApplicationAttribute int64

const (
	Qt__AA_ImmediateWidgetCreation                = Qt__ApplicationAttribute(0)
	Qt__AA_MSWindowsUseDirect3DByDefault          = Qt__ApplicationAttribute(1)
	Qt__AA_DontShowIconsInMenus                   = Qt__ApplicationAttribute(2)
	Qt__AA_NativeWindows                          = Qt__ApplicationAttribute(3)
	Qt__AA_DontCreateNativeWidgetSiblings         = Qt__ApplicationAttribute(4)
	Qt__AA_MacPluginApplication                   = Qt__ApplicationAttribute(5)
	Qt__AA_DontUseNativeMenuBar                   = Qt__ApplicationAttribute(6)
	Qt__AA_MacDontSwapCtrlAndMeta                 = Qt__ApplicationAttribute(7)
	Qt__AA_Use96Dpi                               = Qt__ApplicationAttribute(8)
	Qt__AA_X11InitThreads                         = Qt__ApplicationAttribute(10)
	Qt__AA_SynthesizeTouchForUnhandledMouseEvents = Qt__ApplicationAttribute(11)
	Qt__AA_SynthesizeMouseForUnhandledTouchEvents = Qt__ApplicationAttribute(12)
	Qt__AA_UseHighDpiPixmaps                      = Qt__ApplicationAttribute(13)
	Qt__AA_ForceRasterWidgets                     = Qt__ApplicationAttribute(14)
	Qt__AA_UseDesktopOpenGL                       = Qt__ApplicationAttribute(15)
	Qt__AA_UseOpenGLES                            = Qt__ApplicationAttribute(16)
	Qt__AA_UseSoftwareOpenGL                      = Qt__ApplicationAttribute(17)
	Qt__AA_ShareOpenGLContexts                    = Qt__ApplicationAttribute(18)
	Qt__AA_SetPalette                             = Qt__ApplicationAttribute(19)
	Qt__AA_AttributeCount                         = Qt__ApplicationAttribute(20)
)

//Qt::ApplicationState
type Qt__ApplicationState int64

const (
	Qt__ApplicationSuspended = Qt__ApplicationState(0x00000000)
	Qt__ApplicationHidden    = Qt__ApplicationState(0x00000001)
	Qt__ApplicationInactive  = Qt__ApplicationState(0x00000002)
	Qt__ApplicationActive    = Qt__ApplicationState(0x00000004)
)

//Qt::ArrowType
type Qt__ArrowType int64

const (
	Qt__NoArrow    = Qt__ArrowType(0)
	Qt__UpArrow    = Qt__ArrowType(1)
	Qt__DownArrow  = Qt__ArrowType(2)
	Qt__LeftArrow  = Qt__ArrowType(3)
	Qt__RightArrow = Qt__ArrowType(4)
)

//Qt::AspectRatioMode
type Qt__AspectRatioMode int64

const (
	Qt__IgnoreAspectRatio          = Qt__AspectRatioMode(0)
	Qt__KeepAspectRatio            = Qt__AspectRatioMode(1)
	Qt__KeepAspectRatioByExpanding = Qt__AspectRatioMode(2)
)

//Qt::Axis
type Qt__Axis int64

const (
	Qt__XAxis = Qt__Axis(0)
	Qt__YAxis = Qt__Axis(1)
	Qt__ZAxis = Qt__Axis(2)
)

//Qt::BGMode
type Qt__BGMode int64

const (
	Qt__TransparentMode = Qt__BGMode(0)
	Qt__OpaqueMode      = Qt__BGMode(1)
)

//Qt::BrushStyle
type Qt__BrushStyle int64

var (
	Qt__NoBrush                = Qt__BrushStyle(0)
	Qt__SolidPattern           = Qt__BrushStyle(1)
	Qt__Dense1Pattern          = Qt__BrushStyle(2)
	Qt__Dense2Pattern          = Qt__BrushStyle(3)
	Qt__Dense3Pattern          = Qt__BrushStyle(4)
	Qt__Dense4Pattern          = Qt__BrushStyle(5)
	Qt__Dense5Pattern          = Qt__BrushStyle(6)
	Qt__Dense6Pattern          = Qt__BrushStyle(7)
	Qt__Dense7Pattern          = Qt__BrushStyle(8)
	Qt__HorPattern             = Qt__BrushStyle(9)
	Qt__VerPattern             = Qt__BrushStyle(10)
	Qt__CrossPattern           = Qt__BrushStyle(11)
	Qt__BDiagPattern           = Qt__BrushStyle(12)
	Qt__FDiagPattern           = Qt__BrushStyle(13)
	Qt__DiagCrossPattern       = Qt__BrushStyle(14)
	Qt__LinearGradientPattern  = Qt__BrushStyle(15)
	Qt__RadialGradientPattern  = Qt__BrushStyle(16)
	Qt__ConicalGradientPattern = Qt__BrushStyle(17)
	Qt__TexturePattern         = Qt__BrushStyle(24)
)

//Qt::CaseSensitivity
type Qt__CaseSensitivity int64

const (
	Qt__CaseInsensitive = Qt__CaseSensitivity(0)
	Qt__CaseSensitive   = Qt__CaseSensitivity(1)
)

//Qt::CheckState
type Qt__CheckState int64

const (
	Qt__Unchecked        = Qt__CheckState(0)
	Qt__PartiallyChecked = Qt__CheckState(1)
	Qt__Checked          = Qt__CheckState(2)
)

//Qt::ClipOperation
type Qt__ClipOperation int64

const (
	Qt__NoClip        = Qt__ClipOperation(0)
	Qt__ReplaceClip   = Qt__ClipOperation(1)
	Qt__IntersectClip = Qt__ClipOperation(2)
)

//Qt::ConnectionType
type Qt__ConnectionType int64

const (
	Qt__AutoConnection           = Qt__ConnectionType(0)
	Qt__DirectConnection         = Qt__ConnectionType(1)
	Qt__QueuedConnection         = Qt__ConnectionType(2)
	Qt__BlockingQueuedConnection = Qt__ConnectionType(3)
	Qt__UniqueConnection         = Qt__ConnectionType(0x80)
)

//Qt::ContextMenuPolicy
type Qt__ContextMenuPolicy int64

const (
	Qt__NoContextMenu      = Qt__ContextMenuPolicy(0)
	Qt__DefaultContextMenu = Qt__ContextMenuPolicy(1)
	Qt__ActionsContextMenu = Qt__ContextMenuPolicy(2)
	Qt__CustomContextMenu  = Qt__ContextMenuPolicy(3)
	Qt__PreventContextMenu = Qt__ContextMenuPolicy(4)
)

//Qt::CoordinateSystem
type Qt__CoordinateSystem int64

const (
	Qt__DeviceCoordinates  = Qt__CoordinateSystem(0)
	Qt__LogicalCoordinates = Qt__CoordinateSystem(1)
)

//Qt::Corner
type Qt__Corner int64

const (
	Qt__TopLeftCorner     = Qt__Corner(0x00000)
	Qt__TopRightCorner    = Qt__Corner(0x00001)
	Qt__BottomLeftCorner  = Qt__Corner(0x00002)
	Qt__BottomRightCorner = Qt__Corner(0x00003)
)

//Qt::CursorMoveStyle
type Qt__CursorMoveStyle int64

var (
	Qt__LogicalMoveStyle = Qt__CursorMoveStyle(0)
	Qt__VisualMoveStyle  = Qt__CursorMoveStyle(1)
)

//Qt::CursorShape
type Qt__CursorShape int64

const (
	Qt__ArrowCursor        = Qt__CursorShape(0)
	Qt__UpArrowCursor      = Qt__CursorShape(1)
	Qt__CrossCursor        = Qt__CursorShape(2)
	Qt__WaitCursor         = Qt__CursorShape(3)
	Qt__IBeamCursor        = Qt__CursorShape(4)
	Qt__SizeVerCursor      = Qt__CursorShape(5)
	Qt__SizeHorCursor      = Qt__CursorShape(6)
	Qt__SizeBDiagCursor    = Qt__CursorShape(7)
	Qt__SizeFDiagCursor    = Qt__CursorShape(8)
	Qt__SizeAllCursor      = Qt__CursorShape(9)
	Qt__BlankCursor        = Qt__CursorShape(10)
	Qt__SplitVCursor       = Qt__CursorShape(11)
	Qt__SplitHCursor       = Qt__CursorShape(12)
	Qt__PointingHandCursor = Qt__CursorShape(13)
	Qt__ForbiddenCursor    = Qt__CursorShape(14)
	Qt__WhatsThisCursor    = Qt__CursorShape(15)
	Qt__BusyCursor         = Qt__CursorShape(16)
	Qt__OpenHandCursor     = Qt__CursorShape(17)
	Qt__ClosedHandCursor   = Qt__CursorShape(18)
	Qt__DragCopyCursor     = Qt__CursorShape(19)
	Qt__DragMoveCursor     = Qt__CursorShape(20)
	Qt__DragLinkCursor     = Qt__CursorShape(21)
	Qt__LastCursor         = Qt__CursorShape(Qt__DragLinkCursor)
	Qt__BitmapCursor       = Qt__CursorShape(24)
	Qt__CustomCursor       = Qt__CursorShape(25)
)

//Qt::DateFormat
type Qt__DateFormat int64

var (
	Qt__TextDate               = Qt__DateFormat(0)
	Qt__ISODate                = Qt__DateFormat(1)
	Qt__SystemLocaleDate       = Qt__DateFormat(2)
	Qt__LocalDate              = Qt__DateFormat(Qt__SystemLocaleDate)
	Qt__LocaleDate             = Qt__DateFormat(C.Qt_LocaleDate_Type())
	Qt__SystemLocaleShortDate  = Qt__DateFormat(C.Qt_SystemLocaleShortDate_Type())
	Qt__SystemLocaleLongDate   = Qt__DateFormat(C.Qt_SystemLocaleLongDate_Type())
	Qt__DefaultLocaleShortDate = Qt__DateFormat(C.Qt_DefaultLocaleShortDate_Type())
	Qt__DefaultLocaleLongDate  = Qt__DateFormat(C.Qt_DefaultLocaleLongDate_Type())
	Qt__RFC2822Date            = Qt__DateFormat(C.Qt_RFC2822Date_Type())
)

//Qt::DayOfWeek
type Qt__DayOfWeek int64

const (
	Qt__Monday    = Qt__DayOfWeek(1)
	Qt__Tuesday   = Qt__DayOfWeek(2)
	Qt__Wednesday = Qt__DayOfWeek(3)
	Qt__Thursday  = Qt__DayOfWeek(4)
	Qt__Friday    = Qt__DayOfWeek(5)
	Qt__Saturday  = Qt__DayOfWeek(6)
	Qt__Sunday    = Qt__DayOfWeek(7)
)

//Qt::DockWidgetArea
type Qt__DockWidgetArea int64

const (
	Qt__LeftDockWidgetArea   = Qt__DockWidgetArea(0x1)
	Qt__RightDockWidgetArea  = Qt__DockWidgetArea(0x2)
	Qt__TopDockWidgetArea    = Qt__DockWidgetArea(0x4)
	Qt__BottomDockWidgetArea = Qt__DockWidgetArea(0x8)
	Qt__DockWidgetArea_Mask  = Qt__DockWidgetArea(0xf)
	Qt__AllDockWidgetAreas   = Qt__DockWidgetArea(Qt__DockWidgetArea_Mask)
	Qt__NoDockWidgetArea     = Qt__DockWidgetArea(0)
)

//Qt::DropAction
type Qt__DropAction int64

const (
	Qt__CopyAction       = Qt__DropAction(0x1)
	Qt__MoveAction       = Qt__DropAction(0x2)
	Qt__LinkAction       = Qt__DropAction(0x4)
	Qt__ActionMask       = Qt__DropAction(0xff)
	Qt__TargetMoveAction = Qt__DropAction(0x8002)
	Qt__IgnoreAction     = Qt__DropAction(0x0)
)

//Qt::Edge
type Qt__Edge int64

const (
	Qt__TopEdge    = Qt__Edge(0x00001)
	Qt__LeftEdge   = Qt__Edge(0x00002)
	Qt__RightEdge  = Qt__Edge(0x00004)
	Qt__BottomEdge = Qt__Edge(0x00008)
)

//Qt::EventPriority
type Qt__EventPriority int64

const (
	Qt__HighEventPriority   = Qt__EventPriority(1)
	Qt__NormalEventPriority = Qt__EventPriority(0)
	Qt__LowEventPriority    = Qt__EventPriority(-1)
)

//Qt::FillRule
type Qt__FillRule int64

const (
	Qt__OddEvenFill = Qt__FillRule(0)
	Qt__WindingFill = Qt__FillRule(1)
)

//Qt::FindChildOption
type Qt__FindChildOption int64

const (
	Qt__FindDirectChildrenOnly  = Qt__FindChildOption(0x0)
	Qt__FindChildrenRecursively = Qt__FindChildOption(0x1)
)

//Qt::FocusPolicy
type Qt__FocusPolicy int64

const (
	Qt__NoFocus     = Qt__FocusPolicy(0)
	Qt__TabFocus    = Qt__FocusPolicy(0x1)
	Qt__ClickFocus  = Qt__FocusPolicy(0x2)
	Qt__StrongFocus = Qt__FocusPolicy(Qt__TabFocus | Qt__ClickFocus | 0x8)
	Qt__WheelFocus  = Qt__FocusPolicy(Qt__StrongFocus | 0x4)
)

//Qt::FocusReason
type Qt__FocusReason int64

const (
	Qt__MouseFocusReason        = Qt__FocusReason(0)
	Qt__TabFocusReason          = Qt__FocusReason(1)
	Qt__BacktabFocusReason      = Qt__FocusReason(2)
	Qt__ActiveWindowFocusReason = Qt__FocusReason(3)
	Qt__PopupFocusReason        = Qt__FocusReason(4)
	Qt__ShortcutFocusReason     = Qt__FocusReason(5)
	Qt__MenuBarFocusReason      = Qt__FocusReason(6)
	Qt__OtherFocusReason        = Qt__FocusReason(7)
	Qt__NoFocusReason           = Qt__FocusReason(8)
)

//Qt::GestureFlag
type Qt__GestureFlag int64

const (
	Qt__DontStartGestureOnChildren       = Qt__GestureFlag(0x01)
	Qt__ReceivePartialGestures           = Qt__GestureFlag(0x02)
	Qt__IgnoredGesturesPropagateToParent = Qt__GestureFlag(0x04)
)

//Qt::GestureState
type Qt__GestureState int64

const (
	Qt__NoGesture       = Qt__GestureState(0)
	Qt__GestureStarted  = Qt__GestureState(1)
	Qt__GestureUpdated  = Qt__GestureState(2)
	Qt__GestureFinished = Qt__GestureState(3)
	Qt__GestureCanceled = Qt__GestureState(4)
)

//Qt::GestureType
type Qt__GestureType int64

var (
	Qt__TapGesture        = Qt__GestureType(1)
	Qt__TapAndHoldGesture = Qt__GestureType(2)
	Qt__PanGesture        = Qt__GestureType(3)
	Qt__PinchGesture      = Qt__GestureType(4)
	Qt__SwipeGesture      = Qt__GestureType(5)
	Qt__CustomGesture     = Qt__GestureType(0x0100)
	Qt__LastGestureType   = Qt__GestureType(C.Qt_LastGestureType_Type())
)

//Qt::GlobalColor
type Qt__GlobalColor int64

const (
	Qt__color0      = Qt__GlobalColor(0)
	Qt__color1      = Qt__GlobalColor(1)
	Qt__black       = Qt__GlobalColor(2)
	Qt__white       = Qt__GlobalColor(3)
	Qt__darkGray    = Qt__GlobalColor(4)
	Qt__gray        = Qt__GlobalColor(5)
	Qt__lightGray   = Qt__GlobalColor(6)
	Qt__red         = Qt__GlobalColor(7)
	Qt__green       = Qt__GlobalColor(8)
	Qt__blue        = Qt__GlobalColor(9)
	Qt__cyan        = Qt__GlobalColor(10)
	Qt__magenta     = Qt__GlobalColor(11)
	Qt__yellow      = Qt__GlobalColor(12)
	Qt__darkRed     = Qt__GlobalColor(13)
	Qt__darkGreen   = Qt__GlobalColor(14)
	Qt__darkBlue    = Qt__GlobalColor(15)
	Qt__darkCyan    = Qt__GlobalColor(16)
	Qt__darkMagenta = Qt__GlobalColor(17)
	Qt__darkYellow  = Qt__GlobalColor(18)
	Qt__transparent = Qt__GlobalColor(19)
)

//Qt::HitTestAccuracy
type Qt__HitTestAccuracy int64

const (
	Qt__ExactHit = Qt__HitTestAccuracy(0)
	Qt__FuzzyHit = Qt__HitTestAccuracy(1)
)

//Qt::ImageConversionFlag
type Qt__ImageConversionFlag int64

const (
	Qt__ColorMode_Mask       = Qt__ImageConversionFlag(0x00000003)
	Qt__AutoColor            = Qt__ImageConversionFlag(0x00000000)
	Qt__ColorOnly            = Qt__ImageConversionFlag(0x00000003)
	Qt__MonoOnly             = Qt__ImageConversionFlag(0x00000002)
	Qt__AlphaDither_Mask     = Qt__ImageConversionFlag(0x0000000c)
	Qt__ThresholdAlphaDither = Qt__ImageConversionFlag(0x00000000)
	Qt__OrderedAlphaDither   = Qt__ImageConversionFlag(0x00000004)
	Qt__DiffuseAlphaDither   = Qt__ImageConversionFlag(0x00000008)
	Qt__NoAlpha              = Qt__ImageConversionFlag(0x0000000c)
	Qt__Dither_Mask          = Qt__ImageConversionFlag(0x00000030)
	Qt__DiffuseDither        = Qt__ImageConversionFlag(0x00000000)
	Qt__OrderedDither        = Qt__ImageConversionFlag(0x00000010)
	Qt__ThresholdDither      = Qt__ImageConversionFlag(0x00000020)
	Qt__DitherMode_Mask      = Qt__ImageConversionFlag(0x000000c0)
	Qt__AutoDither           = Qt__ImageConversionFlag(0x00000000)
	Qt__PreferDither         = Qt__ImageConversionFlag(0x00000040)
	Qt__AvoidDither          = Qt__ImageConversionFlag(0x00000080)
	Qt__NoOpaqueDetection    = Qt__ImageConversionFlag(0x00000100)
	Qt__NoFormatConversion   = Qt__ImageConversionFlag(0x00000200)
)

//Qt::InputMethodHint
type Qt__InputMethodHint int64

const (
	Qt__ImhNone                   = Qt__InputMethodHint(0x0)
	Qt__ImhHiddenText             = Qt__InputMethodHint(0x1)
	Qt__ImhSensitiveData          = Qt__InputMethodHint(0x2)
	Qt__ImhNoAutoUppercase        = Qt__InputMethodHint(0x4)
	Qt__ImhPreferNumbers          = Qt__InputMethodHint(0x8)
	Qt__ImhPreferUppercase        = Qt__InputMethodHint(0x10)
	Qt__ImhPreferLowercase        = Qt__InputMethodHint(0x20)
	Qt__ImhNoPredictiveText       = Qt__InputMethodHint(0x40)
	Qt__ImhDate                   = Qt__InputMethodHint(0x80)
	Qt__ImhTime                   = Qt__InputMethodHint(0x100)
	Qt__ImhPreferLatin            = Qt__InputMethodHint(0x200)
	Qt__ImhMultiLine              = Qt__InputMethodHint(0x400)
	Qt__ImhDigitsOnly             = Qt__InputMethodHint(0x10000)
	Qt__ImhFormattedNumbersOnly   = Qt__InputMethodHint(0x20000)
	Qt__ImhUppercaseOnly          = Qt__InputMethodHint(0x40000)
	Qt__ImhLowercaseOnly          = Qt__InputMethodHint(0x80000)
	Qt__ImhDialableCharactersOnly = Qt__InputMethodHint(0x100000)
	Qt__ImhEmailCharactersOnly    = Qt__InputMethodHint(0x200000)
	Qt__ImhUrlCharactersOnly      = Qt__InputMethodHint(0x400000)
	Qt__ImhLatinOnly              = Qt__InputMethodHint(0x800000)
	Qt__ImhExclusiveInputMask     = Qt__InputMethodHint(0xffff0000)
)

//Qt::InputMethodQuery
type Qt__InputMethodQuery int64

const (
	Qt__ImEnabled           = Qt__InputMethodQuery(0x1)
	Qt__ImCursorRectangle   = Qt__InputMethodQuery(0x2)
	Qt__ImMicroFocus        = Qt__InputMethodQuery(0x2)
	Qt__ImFont              = Qt__InputMethodQuery(0x4)
	Qt__ImCursorPosition    = Qt__InputMethodQuery(0x8)
	Qt__ImSurroundingText   = Qt__InputMethodQuery(0x10)
	Qt__ImCurrentSelection  = Qt__InputMethodQuery(0x20)
	Qt__ImMaximumTextLength = Qt__InputMethodQuery(0x40)
	Qt__ImAnchorPosition    = Qt__InputMethodQuery(0x80)
	Qt__ImHints             = Qt__InputMethodQuery(0x100)
	Qt__ImPreferredLanguage = Qt__InputMethodQuery(0x200)
	Qt__ImAbsolutePosition  = Qt__InputMethodQuery(0x400)
	Qt__ImTextBeforeCursor  = Qt__InputMethodQuery(0x800)
	Qt__ImTextAfterCursor   = Qt__InputMethodQuery(0x1000)
	Qt__ImPlatformData      = Qt__InputMethodQuery(0x80000000)
	Qt__ImQueryInput        = Qt__InputMethodQuery(Qt__ImCursorRectangle | Qt__ImCursorPosition | Qt__ImSurroundingText | Qt__ImCurrentSelection | Qt__ImAnchorPosition)
	Qt__ImQueryAll          = Qt__InputMethodQuery(0xffffffff)
)

//Qt::ItemDataRole
type Qt__ItemDataRole int64

const (
	Qt__DisplayRole               = Qt__ItemDataRole(0)
	Qt__DecorationRole            = Qt__ItemDataRole(1)
	Qt__EditRole                  = Qt__ItemDataRole(2)
	Qt__ToolTipRole               = Qt__ItemDataRole(3)
	Qt__StatusTipRole             = Qt__ItemDataRole(4)
	Qt__WhatsThisRole             = Qt__ItemDataRole(5)
	Qt__FontRole                  = Qt__ItemDataRole(6)
	Qt__TextAlignmentRole         = Qt__ItemDataRole(7)
	Qt__BackgroundColorRole       = Qt__ItemDataRole(8)
	Qt__BackgroundRole            = Qt__ItemDataRole(8)
	Qt__TextColorRole             = Qt__ItemDataRole(9)
	Qt__ForegroundRole            = Qt__ItemDataRole(9)
	Qt__CheckStateRole            = Qt__ItemDataRole(10)
	Qt__AccessibleTextRole        = Qt__ItemDataRole(11)
	Qt__AccessibleDescriptionRole = Qt__ItemDataRole(12)
	Qt__SizeHintRole              = Qt__ItemDataRole(13)
	Qt__InitialSortOrderRole      = Qt__ItemDataRole(14)
	Qt__DisplayPropertyRole       = Qt__ItemDataRole(27)
	Qt__DecorationPropertyRole    = Qt__ItemDataRole(28)
	Qt__ToolTipPropertyRole       = Qt__ItemDataRole(29)
	Qt__StatusTipPropertyRole     = Qt__ItemDataRole(30)
	Qt__WhatsThisPropertyRole     = Qt__ItemDataRole(31)
	Qt__UserRole                  = Qt__ItemDataRole(0x0100)
)

//Qt::ItemFlag
type Qt__ItemFlag int64

const (
	Qt__NoItemFlags          = Qt__ItemFlag(0)
	Qt__ItemIsSelectable     = Qt__ItemFlag(1)
	Qt__ItemIsEditable       = Qt__ItemFlag(2)
	Qt__ItemIsDragEnabled    = Qt__ItemFlag(4)
	Qt__ItemIsDropEnabled    = Qt__ItemFlag(8)
	Qt__ItemIsUserCheckable  = Qt__ItemFlag(16)
	Qt__ItemIsEnabled        = Qt__ItemFlag(32)
	Qt__ItemIsTristate       = Qt__ItemFlag(64)
	Qt__ItemNeverHasChildren = Qt__ItemFlag(128)
	Qt__ItemIsUserTristate   = Qt__ItemFlag(256)
)

//Qt::ItemSelectionMode
type Qt__ItemSelectionMode int64

const (
	Qt__ContainsItemShape          = Qt__ItemSelectionMode(0x0)
	Qt__IntersectsItemShape        = Qt__ItemSelectionMode(0x1)
	Qt__ContainsItemBoundingRect   = Qt__ItemSelectionMode(0x2)
	Qt__IntersectsItemBoundingRect = Qt__ItemSelectionMode(0x3)
)

//Qt::ItemSelectionOperation
type Qt__ItemSelectionOperation int64

const (
	Qt__ReplaceSelection = Qt__ItemSelectionOperation(0)
	Qt__AddToSelection   = Qt__ItemSelectionOperation(1)
)

//Qt::Key
type Qt__Key int64

const (
	Qt__Key_Escape                 = Qt__Key(0x01000000)
	Qt__Key_Tab                    = Qt__Key(0x01000001)
	Qt__Key_Backtab                = Qt__Key(0x01000002)
	Qt__Key_Backspace              = Qt__Key(0x01000003)
	Qt__Key_Return                 = Qt__Key(0x01000004)
	Qt__Key_Enter                  = Qt__Key(0x01000005)
	Qt__Key_Insert                 = Qt__Key(0x01000006)
	Qt__Key_Delete                 = Qt__Key(0x01000007)
	Qt__Key_Pause                  = Qt__Key(0x01000008)
	Qt__Key_Print                  = Qt__Key(0x01000009)
	Qt__Key_SysReq                 = Qt__Key(0x0100000a)
	Qt__Key_Clear                  = Qt__Key(0x0100000b)
	Qt__Key_Home                   = Qt__Key(0x01000010)
	Qt__Key_End                    = Qt__Key(0x01000011)
	Qt__Key_Left                   = Qt__Key(0x01000012)
	Qt__Key_Up                     = Qt__Key(0x01000013)
	Qt__Key_Right                  = Qt__Key(0x01000014)
	Qt__Key_Down                   = Qt__Key(0x01000015)
	Qt__Key_PageUp                 = Qt__Key(0x01000016)
	Qt__Key_PageDown               = Qt__Key(0x01000017)
	Qt__Key_Shift                  = Qt__Key(0x01000020)
	Qt__Key_Control                = Qt__Key(0x01000021)
	Qt__Key_Meta                   = Qt__Key(0x01000022)
	Qt__Key_Alt                    = Qt__Key(0x01000023)
	Qt__Key_CapsLock               = Qt__Key(0x01000024)
	Qt__Key_NumLock                = Qt__Key(0x01000025)
	Qt__Key_ScrollLock             = Qt__Key(0x01000026)
	Qt__Key_F1                     = Qt__Key(0x01000030)
	Qt__Key_F2                     = Qt__Key(0x01000031)
	Qt__Key_F3                     = Qt__Key(0x01000032)
	Qt__Key_F4                     = Qt__Key(0x01000033)
	Qt__Key_F5                     = Qt__Key(0x01000034)
	Qt__Key_F6                     = Qt__Key(0x01000035)
	Qt__Key_F7                     = Qt__Key(0x01000036)
	Qt__Key_F8                     = Qt__Key(0x01000037)
	Qt__Key_F9                     = Qt__Key(0x01000038)
	Qt__Key_F10                    = Qt__Key(0x01000039)
	Qt__Key_F11                    = Qt__Key(0x0100003a)
	Qt__Key_F12                    = Qt__Key(0x0100003b)
	Qt__Key_F13                    = Qt__Key(0x0100003c)
	Qt__Key_F14                    = Qt__Key(0x0100003d)
	Qt__Key_F15                    = Qt__Key(0x0100003e)
	Qt__Key_F16                    = Qt__Key(0x0100003f)
	Qt__Key_F17                    = Qt__Key(0x01000040)
	Qt__Key_F18                    = Qt__Key(0x01000041)
	Qt__Key_F19                    = Qt__Key(0x01000042)
	Qt__Key_F20                    = Qt__Key(0x01000043)
	Qt__Key_F21                    = Qt__Key(0x01000044)
	Qt__Key_F22                    = Qt__Key(0x01000045)
	Qt__Key_F23                    = Qt__Key(0x01000046)
	Qt__Key_F24                    = Qt__Key(0x01000047)
	Qt__Key_F25                    = Qt__Key(0x01000048)
	Qt__Key_F26                    = Qt__Key(0x01000049)
	Qt__Key_F27                    = Qt__Key(0x0100004a)
	Qt__Key_F28                    = Qt__Key(0x0100004b)
	Qt__Key_F29                    = Qt__Key(0x0100004c)
	Qt__Key_F30                    = Qt__Key(0x0100004d)
	Qt__Key_F31                    = Qt__Key(0x0100004e)
	Qt__Key_F32                    = Qt__Key(0x0100004f)
	Qt__Key_F33                    = Qt__Key(0x01000050)
	Qt__Key_F34                    = Qt__Key(0x01000051)
	Qt__Key_F35                    = Qt__Key(0x01000052)
	Qt__Key_Super_L                = Qt__Key(0x01000053)
	Qt__Key_Super_R                = Qt__Key(0x01000054)
	Qt__Key_Menu                   = Qt__Key(0x01000055)
	Qt__Key_Hyper_L                = Qt__Key(0x01000056)
	Qt__Key_Hyper_R                = Qt__Key(0x01000057)
	Qt__Key_Help                   = Qt__Key(0x01000058)
	Qt__Key_Direction_L            = Qt__Key(0x01000059)
	Qt__Key_Direction_R            = Qt__Key(0x01000060)
	Qt__Key_Space                  = Qt__Key(0x20)
	Qt__Key_Any                    = Qt__Key(Qt__Key_Space)
	Qt__Key_Exclam                 = Qt__Key(0x21)
	Qt__Key_QuoteDbl               = Qt__Key(0x22)
	Qt__Key_NumberSign             = Qt__Key(0x23)
	Qt__Key_Dollar                 = Qt__Key(0x24)
	Qt__Key_Percent                = Qt__Key(0x25)
	Qt__Key_Ampersand              = Qt__Key(0x26)
	Qt__Key_Apostrophe             = Qt__Key(0x27)
	Qt__Key_ParenLeft              = Qt__Key(0x28)
	Qt__Key_ParenRight             = Qt__Key(0x29)
	Qt__Key_Asterisk               = Qt__Key(0x2a)
	Qt__Key_Plus                   = Qt__Key(0x2b)
	Qt__Key_Comma                  = Qt__Key(0x2c)
	Qt__Key_Minus                  = Qt__Key(0x2d)
	Qt__Key_Period                 = Qt__Key(0x2e)
	Qt__Key_Slash                  = Qt__Key(0x2f)
	Qt__Key_0                      = Qt__Key(0x30)
	Qt__Key_1                      = Qt__Key(0x31)
	Qt__Key_2                      = Qt__Key(0x32)
	Qt__Key_3                      = Qt__Key(0x33)
	Qt__Key_4                      = Qt__Key(0x34)
	Qt__Key_5                      = Qt__Key(0x35)
	Qt__Key_6                      = Qt__Key(0x36)
	Qt__Key_7                      = Qt__Key(0x37)
	Qt__Key_8                      = Qt__Key(0x38)
	Qt__Key_9                      = Qt__Key(0x39)
	Qt__Key_Colon                  = Qt__Key(0x3a)
	Qt__Key_Semicolon              = Qt__Key(0x3b)
	Qt__Key_Less                   = Qt__Key(0x3c)
	Qt__Key_Equal                  = Qt__Key(0x3d)
	Qt__Key_Greater                = Qt__Key(0x3e)
	Qt__Key_Question               = Qt__Key(0x3f)
	Qt__Key_At                     = Qt__Key(0x40)
	Qt__Key_A                      = Qt__Key(0x41)
	Qt__Key_B                      = Qt__Key(0x42)
	Qt__Key_C                      = Qt__Key(0x43)
	Qt__Key_D                      = Qt__Key(0x44)
	Qt__Key_E                      = Qt__Key(0x45)
	Qt__Key_F                      = Qt__Key(0x46)
	Qt__Key_G                      = Qt__Key(0x47)
	Qt__Key_H                      = Qt__Key(0x48)
	Qt__Key_I                      = Qt__Key(0x49)
	Qt__Key_J                      = Qt__Key(0x4a)
	Qt__Key_K                      = Qt__Key(0x4b)
	Qt__Key_L                      = Qt__Key(0x4c)
	Qt__Key_M                      = Qt__Key(0x4d)
	Qt__Key_N                      = Qt__Key(0x4e)
	Qt__Key_O                      = Qt__Key(0x4f)
	Qt__Key_P                      = Qt__Key(0x50)
	Qt__Key_Q                      = Qt__Key(0x51)
	Qt__Key_R                      = Qt__Key(0x52)
	Qt__Key_S                      = Qt__Key(0x53)
	Qt__Key_T                      = Qt__Key(0x54)
	Qt__Key_U                      = Qt__Key(0x55)
	Qt__Key_V                      = Qt__Key(0x56)
	Qt__Key_W                      = Qt__Key(0x57)
	Qt__Key_X                      = Qt__Key(0x58)
	Qt__Key_Y                      = Qt__Key(0x59)
	Qt__Key_Z                      = Qt__Key(0x5a)
	Qt__Key_BracketLeft            = Qt__Key(0x5b)
	Qt__Key_Backslash              = Qt__Key(0x5c)
	Qt__Key_BracketRight           = Qt__Key(0x5d)
	Qt__Key_AsciiCircum            = Qt__Key(0x5e)
	Qt__Key_Underscore             = Qt__Key(0x5f)
	Qt__Key_QuoteLeft              = Qt__Key(0x60)
	Qt__Key_BraceLeft              = Qt__Key(0x7b)
	Qt__Key_Bar                    = Qt__Key(0x7c)
	Qt__Key_BraceRight             = Qt__Key(0x7d)
	Qt__Key_AsciiTilde             = Qt__Key(0x7e)
	Qt__Key_nobreakspace           = Qt__Key(0x0a0)
	Qt__Key_exclamdown             = Qt__Key(0x0a1)
	Qt__Key_cent                   = Qt__Key(0x0a2)
	Qt__Key_sterling               = Qt__Key(0x0a3)
	Qt__Key_currency               = Qt__Key(0x0a4)
	Qt__Key_yen                    = Qt__Key(0x0a5)
	Qt__Key_brokenbar              = Qt__Key(0x0a6)
	Qt__Key_section                = Qt__Key(0x0a7)
	Qt__Key_diaeresis              = Qt__Key(0x0a8)
	Qt__Key_copyright              = Qt__Key(0x0a9)
	Qt__Key_ordfeminine            = Qt__Key(0x0aa)
	Qt__Key_guillemotleft          = Qt__Key(0x0ab)
	Qt__Key_notsign                = Qt__Key(0x0ac)
	Qt__Key_hyphen                 = Qt__Key(0x0ad)
	Qt__Key_registered             = Qt__Key(0x0ae)
	Qt__Key_macron                 = Qt__Key(0x0af)
	Qt__Key_degree                 = Qt__Key(0x0b0)
	Qt__Key_plusminus              = Qt__Key(0x0b1)
	Qt__Key_twosuperior            = Qt__Key(0x0b2)
	Qt__Key_threesuperior          = Qt__Key(0x0b3)
	Qt__Key_acute                  = Qt__Key(0x0b4)
	Qt__Key_mu                     = Qt__Key(0x0b5)
	Qt__Key_paragraph              = Qt__Key(0x0b6)
	Qt__Key_periodcentered         = Qt__Key(0x0b7)
	Qt__Key_cedilla                = Qt__Key(0x0b8)
	Qt__Key_onesuperior            = Qt__Key(0x0b9)
	Qt__Key_masculine              = Qt__Key(0x0ba)
	Qt__Key_guillemotright         = Qt__Key(0x0bb)
	Qt__Key_onequarter             = Qt__Key(0x0bc)
	Qt__Key_onehalf                = Qt__Key(0x0bd)
	Qt__Key_threequarters          = Qt__Key(0x0be)
	Qt__Key_questiondown           = Qt__Key(0x0bf)
	Qt__Key_Agrave                 = Qt__Key(0x0c0)
	Qt__Key_Aacute                 = Qt__Key(0x0c1)
	Qt__Key_Acircumflex            = Qt__Key(0x0c2)
	Qt__Key_Atilde                 = Qt__Key(0x0c3)
	Qt__Key_Adiaeresis             = Qt__Key(0x0c4)
	Qt__Key_Aring                  = Qt__Key(0x0c5)
	Qt__Key_AE                     = Qt__Key(0x0c6)
	Qt__Key_Ccedilla               = Qt__Key(0x0c7)
	Qt__Key_Egrave                 = Qt__Key(0x0c8)
	Qt__Key_Eacute                 = Qt__Key(0x0c9)
	Qt__Key_Ecircumflex            = Qt__Key(0x0ca)
	Qt__Key_Ediaeresis             = Qt__Key(0x0cb)
	Qt__Key_Igrave                 = Qt__Key(0x0cc)
	Qt__Key_Iacute                 = Qt__Key(0x0cd)
	Qt__Key_Icircumflex            = Qt__Key(0x0ce)
	Qt__Key_Idiaeresis             = Qt__Key(0x0cf)
	Qt__Key_ETH                    = Qt__Key(0x0d0)
	Qt__Key_Ntilde                 = Qt__Key(0x0d1)
	Qt__Key_Ograve                 = Qt__Key(0x0d2)
	Qt__Key_Oacute                 = Qt__Key(0x0d3)
	Qt__Key_Ocircumflex            = Qt__Key(0x0d4)
	Qt__Key_Otilde                 = Qt__Key(0x0d5)
	Qt__Key_Odiaeresis             = Qt__Key(0x0d6)
	Qt__Key_multiply               = Qt__Key(0x0d7)
	Qt__Key_Ooblique               = Qt__Key(0x0d8)
	Qt__Key_Ugrave                 = Qt__Key(0x0d9)
	Qt__Key_Uacute                 = Qt__Key(0x0da)
	Qt__Key_Ucircumflex            = Qt__Key(0x0db)
	Qt__Key_Udiaeresis             = Qt__Key(0x0dc)
	Qt__Key_Yacute                 = Qt__Key(0x0dd)
	Qt__Key_THORN                  = Qt__Key(0x0de)
	Qt__Key_ssharp                 = Qt__Key(0x0df)
	Qt__Key_division               = Qt__Key(0x0f7)
	Qt__Key_ydiaeresis             = Qt__Key(0x0ff)
	Qt__Key_AltGr                  = Qt__Key(0x01001103)
	Qt__Key_Multi_key              = Qt__Key(0x01001120)
	Qt__Key_Codeinput              = Qt__Key(0x01001137)
	Qt__Key_SingleCandidate        = Qt__Key(0x0100113c)
	Qt__Key_MultipleCandidate      = Qt__Key(0x0100113d)
	Qt__Key_PreviousCandidate      = Qt__Key(0x0100113e)
	Qt__Key_Mode_switch            = Qt__Key(0x0100117e)
	Qt__Key_Kanji                  = Qt__Key(0x01001121)
	Qt__Key_Muhenkan               = Qt__Key(0x01001122)
	Qt__Key_Henkan                 = Qt__Key(0x01001123)
	Qt__Key_Romaji                 = Qt__Key(0x01001124)
	Qt__Key_Hiragana               = Qt__Key(0x01001125)
	Qt__Key_Katakana               = Qt__Key(0x01001126)
	Qt__Key_Hiragana_Katakana      = Qt__Key(0x01001127)
	Qt__Key_Zenkaku                = Qt__Key(0x01001128)
	Qt__Key_Hankaku                = Qt__Key(0x01001129)
	Qt__Key_Zenkaku_Hankaku        = Qt__Key(0x0100112a)
	Qt__Key_Touroku                = Qt__Key(0x0100112b)
	Qt__Key_Massyo                 = Qt__Key(0x0100112c)
	Qt__Key_Kana_Lock              = Qt__Key(0x0100112d)
	Qt__Key_Kana_Shift             = Qt__Key(0x0100112e)
	Qt__Key_Eisu_Shift             = Qt__Key(0x0100112f)
	Qt__Key_Eisu_toggle            = Qt__Key(0x01001130)
	Qt__Key_Hangul                 = Qt__Key(0x01001131)
	Qt__Key_Hangul_Start           = Qt__Key(0x01001132)
	Qt__Key_Hangul_End             = Qt__Key(0x01001133)
	Qt__Key_Hangul_Hanja           = Qt__Key(0x01001134)
	Qt__Key_Hangul_Jamo            = Qt__Key(0x01001135)
	Qt__Key_Hangul_Romaja          = Qt__Key(0x01001136)
	Qt__Key_Hangul_Jeonja          = Qt__Key(0x01001138)
	Qt__Key_Hangul_Banja           = Qt__Key(0x01001139)
	Qt__Key_Hangul_PreHanja        = Qt__Key(0x0100113a)
	Qt__Key_Hangul_PostHanja       = Qt__Key(0x0100113b)
	Qt__Key_Hangul_Special         = Qt__Key(0x0100113f)
	Qt__Key_Dead_Grave             = Qt__Key(0x01001250)
	Qt__Key_Dead_Acute             = Qt__Key(0x01001251)
	Qt__Key_Dead_Circumflex        = Qt__Key(0x01001252)
	Qt__Key_Dead_Tilde             = Qt__Key(0x01001253)
	Qt__Key_Dead_Macron            = Qt__Key(0x01001254)
	Qt__Key_Dead_Breve             = Qt__Key(0x01001255)
	Qt__Key_Dead_Abovedot          = Qt__Key(0x01001256)
	Qt__Key_Dead_Diaeresis         = Qt__Key(0x01001257)
	Qt__Key_Dead_Abovering         = Qt__Key(0x01001258)
	Qt__Key_Dead_Doubleacute       = Qt__Key(0x01001259)
	Qt__Key_Dead_Caron             = Qt__Key(0x0100125a)
	Qt__Key_Dead_Cedilla           = Qt__Key(0x0100125b)
	Qt__Key_Dead_Ogonek            = Qt__Key(0x0100125c)
	Qt__Key_Dead_Iota              = Qt__Key(0x0100125d)
	Qt__Key_Dead_Voiced_Sound      = Qt__Key(0x0100125e)
	Qt__Key_Dead_Semivoiced_Sound  = Qt__Key(0x0100125f)
	Qt__Key_Dead_Belowdot          = Qt__Key(0x01001260)
	Qt__Key_Dead_Hook              = Qt__Key(0x01001261)
	Qt__Key_Dead_Horn              = Qt__Key(0x01001262)
	Qt__Key_Back                   = Qt__Key(0x01000061)
	Qt__Key_Forward                = Qt__Key(0x01000062)
	Qt__Key_Stop                   = Qt__Key(0x01000063)
	Qt__Key_Refresh                = Qt__Key(0x01000064)
	Qt__Key_VolumeDown             = Qt__Key(0x01000070)
	Qt__Key_VolumeMute             = Qt__Key(0x01000071)
	Qt__Key_VolumeUp               = Qt__Key(0x01000072)
	Qt__Key_BassBoost              = Qt__Key(0x01000073)
	Qt__Key_BassUp                 = Qt__Key(0x01000074)
	Qt__Key_BassDown               = Qt__Key(0x01000075)
	Qt__Key_TrebleUp               = Qt__Key(0x01000076)
	Qt__Key_TrebleDown             = Qt__Key(0x01000077)
	Qt__Key_MediaPlay              = Qt__Key(0x01000080)
	Qt__Key_MediaStop              = Qt__Key(0x01000081)
	Qt__Key_MediaPrevious          = Qt__Key(0x01000082)
	Qt__Key_MediaNext              = Qt__Key(0x01000083)
	Qt__Key_MediaRecord            = Qt__Key(0x01000084)
	Qt__Key_MediaPause             = Qt__Key(0x1000085)
	Qt__Key_MediaTogglePlayPause   = Qt__Key(0x1000086)
	Qt__Key_HomePage               = Qt__Key(0x01000090)
	Qt__Key_Favorites              = Qt__Key(0x01000091)
	Qt__Key_Search                 = Qt__Key(0x01000092)
	Qt__Key_Standby                = Qt__Key(0x01000093)
	Qt__Key_OpenUrl                = Qt__Key(0x01000094)
	Qt__Key_LaunchMail             = Qt__Key(0x010000a0)
	Qt__Key_LaunchMedia            = Qt__Key(0x010000a1)
	Qt__Key_Launch0                = Qt__Key(0x010000a2)
	Qt__Key_Launch1                = Qt__Key(0x010000a3)
	Qt__Key_Launch2                = Qt__Key(0x010000a4)
	Qt__Key_Launch3                = Qt__Key(0x010000a5)
	Qt__Key_Launch4                = Qt__Key(0x010000a6)
	Qt__Key_Launch5                = Qt__Key(0x010000a7)
	Qt__Key_Launch6                = Qt__Key(0x010000a8)
	Qt__Key_Launch7                = Qt__Key(0x010000a9)
	Qt__Key_Launch8                = Qt__Key(0x010000aa)
	Qt__Key_Launch9                = Qt__Key(0x010000ab)
	Qt__Key_LaunchA                = Qt__Key(0x010000ac)
	Qt__Key_LaunchB                = Qt__Key(0x010000ad)
	Qt__Key_LaunchC                = Qt__Key(0x010000ae)
	Qt__Key_LaunchD                = Qt__Key(0x010000af)
	Qt__Key_LaunchE                = Qt__Key(0x010000b0)
	Qt__Key_LaunchF                = Qt__Key(0x010000b1)
	Qt__Key_MonBrightnessUp        = Qt__Key(0x010000b2)
	Qt__Key_MonBrightnessDown      = Qt__Key(0x010000b3)
	Qt__Key_KeyboardLightOnOff     = Qt__Key(0x010000b4)
	Qt__Key_KeyboardBrightnessUp   = Qt__Key(0x010000b5)
	Qt__Key_KeyboardBrightnessDown = Qt__Key(0x010000b6)
	Qt__Key_PowerOff               = Qt__Key(0x010000b7)
	Qt__Key_WakeUp                 = Qt__Key(0x010000b8)
	Qt__Key_Eject                  = Qt__Key(0x010000b9)
	Qt__Key_ScreenSaver            = Qt__Key(0x010000ba)
	Qt__Key_WWW                    = Qt__Key(0x010000bb)
	Qt__Key_Memo                   = Qt__Key(0x010000bc)
	Qt__Key_LightBulb              = Qt__Key(0x010000bd)
	Qt__Key_Shop                   = Qt__Key(0x010000be)
	Qt__Key_History                = Qt__Key(0x010000bf)
	Qt__Key_AddFavorite            = Qt__Key(0x010000c0)
	Qt__Key_HotLinks               = Qt__Key(0x010000c1)
	Qt__Key_BrightnessAdjust       = Qt__Key(0x010000c2)
	Qt__Key_Finance                = Qt__Key(0x010000c3)
	Qt__Key_Community              = Qt__Key(0x010000c4)
	Qt__Key_AudioRewind            = Qt__Key(0x010000c5)
	Qt__Key_BackForward            = Qt__Key(0x010000c6)
	Qt__Key_ApplicationLeft        = Qt__Key(0x010000c7)
	Qt__Key_ApplicationRight       = Qt__Key(0x010000c8)
	Qt__Key_Book                   = Qt__Key(0x010000c9)
	Qt__Key_CD                     = Qt__Key(0x010000ca)
	Qt__Key_Calculator             = Qt__Key(0x010000cb)
	Qt__Key_ToDoList               = Qt__Key(0x010000cc)
	Qt__Key_ClearGrab              = Qt__Key(0x010000cd)
	Qt__Key_Close                  = Qt__Key(0x010000ce)
	Qt__Key_Copy                   = Qt__Key(0x010000cf)
	Qt__Key_Cut                    = Qt__Key(0x010000d0)
	Qt__Key_Display                = Qt__Key(0x010000d1)
	Qt__Key_DOS                    = Qt__Key(0x010000d2)
	Qt__Key_Documents              = Qt__Key(0x010000d3)
	Qt__Key_Excel                  = Qt__Key(0x010000d4)
	Qt__Key_Explorer               = Qt__Key(0x010000d5)
	Qt__Key_Game                   = Qt__Key(0x010000d6)
	Qt__Key_Go                     = Qt__Key(0x010000d7)
	Qt__Key_iTouch                 = Qt__Key(0x010000d8)
	Qt__Key_LogOff                 = Qt__Key(0x010000d9)
	Qt__Key_Market                 = Qt__Key(0x010000da)
	Qt__Key_Meeting                = Qt__Key(0x010000db)
	Qt__Key_MenuKB                 = Qt__Key(0x010000dc)
	Qt__Key_MenuPB                 = Qt__Key(0x010000dd)
	Qt__Key_MySites                = Qt__Key(0x010000de)
	Qt__Key_News                   = Qt__Key(0x010000df)
	Qt__Key_OfficeHome             = Qt__Key(0x010000e0)
	Qt__Key_Option                 = Qt__Key(0x010000e1)
	Qt__Key_Paste                  = Qt__Key(0x010000e2)
	Qt__Key_Phone                  = Qt__Key(0x010000e3)
	Qt__Key_Calendar               = Qt__Key(0x010000e4)
	Qt__Key_Reply                  = Qt__Key(0x010000e5)
	Qt__Key_Reload                 = Qt__Key(0x010000e6)
	Qt__Key_RotateWindows          = Qt__Key(0x010000e7)
	Qt__Key_RotationPB             = Qt__Key(0x010000e8)
	Qt__Key_RotationKB             = Qt__Key(0x010000e9)
	Qt__Key_Save                   = Qt__Key(0x010000ea)
	Qt__Key_Send                   = Qt__Key(0x010000eb)
	Qt__Key_Spell                  = Qt__Key(0x010000ec)
	Qt__Key_SplitScreen            = Qt__Key(0x010000ed)
	Qt__Key_Support                = Qt__Key(0x010000ee)
	Qt__Key_TaskPane               = Qt__Key(0x010000ef)
	Qt__Key_Terminal               = Qt__Key(0x010000f0)
	Qt__Key_Tools                  = Qt__Key(0x010000f1)
	Qt__Key_Travel                 = Qt__Key(0x010000f2)
	Qt__Key_Video                  = Qt__Key(0x010000f3)
	Qt__Key_Word                   = Qt__Key(0x010000f4)
	Qt__Key_Xfer                   = Qt__Key(0x010000f5)
	Qt__Key_ZoomIn                 = Qt__Key(0x010000f6)
	Qt__Key_ZoomOut                = Qt__Key(0x010000f7)
	Qt__Key_Away                   = Qt__Key(0x010000f8)
	Qt__Key_Messenger              = Qt__Key(0x010000f9)
	Qt__Key_WebCam                 = Qt__Key(0x010000fa)
	Qt__Key_MailForward            = Qt__Key(0x010000fb)
	Qt__Key_Pictures               = Qt__Key(0x010000fc)
	Qt__Key_Music                  = Qt__Key(0x010000fd)
	Qt__Key_Battery                = Qt__Key(0x010000fe)
	Qt__Key_Bluetooth              = Qt__Key(0x010000ff)
	Qt__Key_WLAN                   = Qt__Key(0x01000100)
	Qt__Key_UWB                    = Qt__Key(0x01000101)
	Qt__Key_AudioForward           = Qt__Key(0x01000102)
	Qt__Key_AudioRepeat            = Qt__Key(0x01000103)
	Qt__Key_AudioRandomPlay        = Qt__Key(0x01000104)
	Qt__Key_Subtitle               = Qt__Key(0x01000105)
	Qt__Key_AudioCycleTrack        = Qt__Key(0x01000106)
	Qt__Key_Time                   = Qt__Key(0x01000107)
	Qt__Key_Hibernate              = Qt__Key(0x01000108)
	Qt__Key_View                   = Qt__Key(0x01000109)
	Qt__Key_TopMenu                = Qt__Key(0x0100010a)
	Qt__Key_PowerDown              = Qt__Key(0x0100010b)
	Qt__Key_Suspend                = Qt__Key(0x0100010c)
	Qt__Key_ContrastAdjust         = Qt__Key(0x0100010d)
	Qt__Key_LaunchG                = Qt__Key(0x0100010e)
	Qt__Key_LaunchH                = Qt__Key(0x0100010f)
	Qt__Key_TouchpadToggle         = Qt__Key(0x01000110)
	Qt__Key_TouchpadOn             = Qt__Key(0x01000111)
	Qt__Key_TouchpadOff            = Qt__Key(0x01000112)
	Qt__Key_MicMute                = Qt__Key(0x01000113)
	Qt__Key_Red                    = Qt__Key(0x01000114)
	Qt__Key_Green                  = Qt__Key(0x01000115)
	Qt__Key_Yellow                 = Qt__Key(0x01000116)
	Qt__Key_Blue                   = Qt__Key(0x01000117)
	Qt__Key_ChannelUp              = Qt__Key(0x01000118)
	Qt__Key_ChannelDown            = Qt__Key(0x01000119)
	Qt__Key_Guide                  = Qt__Key(0x0100011a)
	Qt__Key_Info                   = Qt__Key(0x0100011b)
	Qt__Key_Settings               = Qt__Key(0x0100011c)
	Qt__Key_MicVolumeUp            = Qt__Key(0x0100011d)
	Qt__Key_MicVolumeDown          = Qt__Key(0x0100011e)
	Qt__Key_New                    = Qt__Key(0x01000120)
	Qt__Key_Open                   = Qt__Key(0x01000121)
	Qt__Key_Find                   = Qt__Key(0x01000122)
	Qt__Key_Undo                   = Qt__Key(0x01000123)
	Qt__Key_Redo                   = Qt__Key(0x01000124)
	Qt__Key_MediaLast              = Qt__Key(0x0100ffff)
	Qt__Key_Select                 = Qt__Key(0x01010000)
	Qt__Key_Yes                    = Qt__Key(0x01010001)
	Qt__Key_No                     = Qt__Key(0x01010002)
	Qt__Key_Cancel                 = Qt__Key(0x01020001)
	Qt__Key_Printer                = Qt__Key(0x01020002)
	Qt__Key_Execute                = Qt__Key(0x01020003)
	Qt__Key_Sleep                  = Qt__Key(0x01020004)
	Qt__Key_Play                   = Qt__Key(0x01020005)
	Qt__Key_Zoom                   = Qt__Key(0x01020006)
	Qt__Key_Exit                   = Qt__Key(0x0102000a)
	Qt__Key_Context1               = Qt__Key(0x01100000)
	Qt__Key_Context2               = Qt__Key(0x01100001)
	Qt__Key_Context3               = Qt__Key(0x01100002)
	Qt__Key_Context4               = Qt__Key(0x01100003)
	Qt__Key_Call                   = Qt__Key(0x01100004)
	Qt__Key_Hangup                 = Qt__Key(0x01100005)
	Qt__Key_Flip                   = Qt__Key(0x01100006)
	Qt__Key_ToggleCallHangup       = Qt__Key(0x01100007)
	Qt__Key_VoiceDial              = Qt__Key(0x01100008)
	Qt__Key_LastNumberRedial       = Qt__Key(0x01100009)
	Qt__Key_Camera                 = Qt__Key(0x01100020)
	Qt__Key_CameraFocus            = Qt__Key(0x01100021)
	Qt__Key_unknown                = Qt__Key(0x01ffffff)
)

//Qt::KeyboardModifier
type Qt__KeyboardModifier int64

const (
	Qt__NoModifier           = Qt__KeyboardModifier(0x00000000)
	Qt__ShiftModifier        = Qt__KeyboardModifier(0x02000000)
	Qt__ControlModifier      = Qt__KeyboardModifier(0x04000000)
	Qt__AltModifier          = Qt__KeyboardModifier(0x08000000)
	Qt__MetaModifier         = Qt__KeyboardModifier(0x10000000)
	Qt__KeypadModifier       = Qt__KeyboardModifier(0x20000000)
	Qt__GroupSwitchModifier  = Qt__KeyboardModifier(0x40000000)
	Qt__KeyboardModifierMask = Qt__KeyboardModifier(0xfe000000)
)

//Qt::LayoutDirection
type Qt__LayoutDirection int64

const (
	Qt__LeftToRight         = Qt__LayoutDirection(0)
	Qt__RightToLeft         = Qt__LayoutDirection(1)
	Qt__LayoutDirectionAuto = Qt__LayoutDirection(2)
)

//Qt::MaskMode
type Qt__MaskMode int64

const (
	Qt__MaskInColor  = Qt__MaskMode(0)
	Qt__MaskOutColor = Qt__MaskMode(1)
)

//Qt::MatchFlag
type Qt__MatchFlag int64

const (
	Qt__MatchExactly       = Qt__MatchFlag(0)
	Qt__MatchContains      = Qt__MatchFlag(1)
	Qt__MatchStartsWith    = Qt__MatchFlag(2)
	Qt__MatchEndsWith      = Qt__MatchFlag(3)
	Qt__MatchRegExp        = Qt__MatchFlag(4)
	Qt__MatchWildcard      = Qt__MatchFlag(5)
	Qt__MatchFixedString   = Qt__MatchFlag(8)
	Qt__MatchCaseSensitive = Qt__MatchFlag(16)
	Qt__MatchWrap          = Qt__MatchFlag(32)
	Qt__MatchRecursive     = Qt__MatchFlag(64)
)

//Qt::Modifier
type Qt__Modifier int64

const (
	Qt__META          = Qt__Modifier(Qt__MetaModifier)
	Qt__SHIFT         = Qt__Modifier(Qt__ShiftModifier)
	Qt__CTRL          = Qt__Modifier(Qt__ControlModifier)
	Qt__ALT           = Qt__Modifier(Qt__AltModifier)
	Qt__MODIFIER_MASK = Qt__Modifier(Qt__KeyboardModifierMask)
	Qt__UNICODE_ACCEL = Qt__Modifier(0x00000000)
)

//Qt::MouseButton
type Qt__MouseButton int64

const (
	Qt__NoButton        = Qt__MouseButton(0x00000000)
	Qt__LeftButton      = Qt__MouseButton(0x00000001)
	Qt__RightButton     = Qt__MouseButton(0x00000002)
	Qt__MidButton       = Qt__MouseButton(0x00000004)
	Qt__MiddleButton    = Qt__MouseButton(Qt__MidButton)
	Qt__BackButton      = Qt__MouseButton(0x00000008)
	Qt__XButton1        = Qt__MouseButton(Qt__BackButton)
	Qt__ExtraButton1    = Qt__MouseButton(Qt__XButton1)
	Qt__ForwardButton   = Qt__MouseButton(0x00000010)
	Qt__XButton2        = Qt__MouseButton(Qt__ForwardButton)
	Qt__ExtraButton2    = Qt__MouseButton(Qt__ForwardButton)
	Qt__TaskButton      = Qt__MouseButton(0x00000020)
	Qt__ExtraButton3    = Qt__MouseButton(Qt__TaskButton)
	Qt__ExtraButton4    = Qt__MouseButton(0x00000040)
	Qt__ExtraButton5    = Qt__MouseButton(0x00000080)
	Qt__ExtraButton6    = Qt__MouseButton(0x00000100)
	Qt__ExtraButton7    = Qt__MouseButton(0x00000200)
	Qt__ExtraButton8    = Qt__MouseButton(0x00000400)
	Qt__ExtraButton9    = Qt__MouseButton(0x00000800)
	Qt__ExtraButton10   = Qt__MouseButton(0x00001000)
	Qt__ExtraButton11   = Qt__MouseButton(0x00002000)
	Qt__ExtraButton12   = Qt__MouseButton(0x00004000)
	Qt__ExtraButton13   = Qt__MouseButton(0x00008000)
	Qt__ExtraButton14   = Qt__MouseButton(0x00010000)
	Qt__ExtraButton15   = Qt__MouseButton(0x00020000)
	Qt__ExtraButton16   = Qt__MouseButton(0x00040000)
	Qt__ExtraButton17   = Qt__MouseButton(0x00080000)
	Qt__ExtraButton18   = Qt__MouseButton(0x00100000)
	Qt__ExtraButton19   = Qt__MouseButton(0x00200000)
	Qt__ExtraButton20   = Qt__MouseButton(0x00400000)
	Qt__ExtraButton21   = Qt__MouseButton(0x00800000)
	Qt__ExtraButton22   = Qt__MouseButton(0x01000000)
	Qt__ExtraButton23   = Qt__MouseButton(0x02000000)
	Qt__ExtraButton24   = Qt__MouseButton(0x04000000)
	Qt__AllButtons      = Qt__MouseButton(0x07ffffff)
	Qt__MaxMouseButton  = Qt__MouseButton(Qt__ExtraButton24)
	Qt__MouseButtonMask = Qt__MouseButton(0xffffffff)
)

//Qt::MouseEventFlag
type Qt__MouseEventFlag int64

const (
	Qt__MouseEventCreatedDoubleClick = Qt__MouseEventFlag(0x01)
	Qt__MouseEventFlagMask           = Qt__MouseEventFlag(0xFF)
)

//Qt::MouseEventSource
type Qt__MouseEventSource int64

const (
	Qt__MouseEventNotSynthesized      = Qt__MouseEventSource(0)
	Qt__MouseEventSynthesizedBySystem = Qt__MouseEventSource(1)
	Qt__MouseEventSynthesizedByQt     = Qt__MouseEventSource(2)
)

//Qt::NativeGestureType
type Qt__NativeGestureType int64

const (
	Qt__BeginNativeGesture     = Qt__NativeGestureType(0)
	Qt__EndNativeGesture       = Qt__NativeGestureType(1)
	Qt__PanNativeGesture       = Qt__NativeGestureType(2)
	Qt__ZoomNativeGesture      = Qt__NativeGestureType(3)
	Qt__SmartZoomNativeGesture = Qt__NativeGestureType(4)
	Qt__RotateNativeGesture    = Qt__NativeGestureType(5)
	Qt__SwipeNativeGesture     = Qt__NativeGestureType(6)
)

//Qt::NavigationMode
type Qt__NavigationMode int64

const (
	Qt__NavigationModeNone               = Qt__NavigationMode(0)
	Qt__NavigationModeKeypadTabOrder     = Qt__NavigationMode(1)
	Qt__NavigationModeKeypadDirectional  = Qt__NavigationMode(2)
	Qt__NavigationModeCursorAuto         = Qt__NavigationMode(3)
	Qt__NavigationModeCursorForceVisible = Qt__NavigationMode(4)
)

//Qt::Orientation
type Qt__Orientation int64

const (
	Qt__Horizontal = Qt__Orientation(0x1)
	Qt__Vertical   = Qt__Orientation(0x2)
)

//Qt::PenCapStyle
type Qt__PenCapStyle int64

var (
	Qt__FlatCap      = Qt__PenCapStyle(0x00)
	Qt__SquareCap    = Qt__PenCapStyle(0x10)
	Qt__RoundCap     = Qt__PenCapStyle(0x20)
	Qt__MPenCapStyle = Qt__PenCapStyle(0x30)
)

//Qt::PenJoinStyle
type Qt__PenJoinStyle int64

var (
	Qt__MiterJoin     = Qt__PenJoinStyle(0x00)
	Qt__BevelJoin     = Qt__PenJoinStyle(0x40)
	Qt__RoundJoin     = Qt__PenJoinStyle(0x80)
	Qt__SvgMiterJoin  = Qt__PenJoinStyle(0x100)
	Qt__MPenJoinStyle = Qt__PenJoinStyle(0x1c0)
)

//Qt::PenStyle
type Qt__PenStyle int64

var (
	Qt__NoPen          = Qt__PenStyle(0)
	Qt__SolidLine      = Qt__PenStyle(1)
	Qt__DashLine       = Qt__PenStyle(2)
	Qt__DotLine        = Qt__PenStyle(3)
	Qt__DashDotLine    = Qt__PenStyle(4)
	Qt__DashDotDotLine = Qt__PenStyle(5)
	Qt__CustomDashLine = Qt__PenStyle(6)
	Qt__MPenStyle      = Qt__PenStyle(0x0f)
)

//Qt::ScreenOrientation
type Qt__ScreenOrientation int64

const (
	Qt__PrimaryOrientation           = Qt__ScreenOrientation(0x00000000)
	Qt__PortraitOrientation          = Qt__ScreenOrientation(0x00000001)
	Qt__LandscapeOrientation         = Qt__ScreenOrientation(0x00000002)
	Qt__InvertedPortraitOrientation  = Qt__ScreenOrientation(0x00000004)
	Qt__InvertedLandscapeOrientation = Qt__ScreenOrientation(0x00000008)
)

//Qt::ScrollBarPolicy
type Qt__ScrollBarPolicy int64

const (
	Qt__ScrollBarAsNeeded  = Qt__ScrollBarPolicy(0)
	Qt__ScrollBarAlwaysOff = Qt__ScrollBarPolicy(1)
	Qt__ScrollBarAlwaysOn  = Qt__ScrollBarPolicy(2)
)

//Qt::ScrollPhase
type Qt__ScrollPhase int64

const (
	Qt__ScrollBegin  = Qt__ScrollPhase(1)
	Qt__ScrollUpdate = Qt__ScrollPhase(2)
	Qt__ScrollEnd    = Qt__ScrollPhase(3)
)

//Qt::ShortcutContext
type Qt__ShortcutContext int64

const (
	Qt__WidgetShortcut             = Qt__ShortcutContext(0)
	Qt__WindowShortcut             = Qt__ShortcutContext(1)
	Qt__ApplicationShortcut        = Qt__ShortcutContext(2)
	Qt__WidgetWithChildrenShortcut = Qt__ShortcutContext(3)
)

//Qt::SizeHint
type Qt__SizeHint int64

const (
	Qt__MinimumSize    = Qt__SizeHint(0)
	Qt__PreferredSize  = Qt__SizeHint(1)
	Qt__MaximumSize    = Qt__SizeHint(2)
	Qt__MinimumDescent = Qt__SizeHint(3)
	Qt__NSizeHints     = Qt__SizeHint(4)
)

//Qt::SizeMode
type Qt__SizeMode int64

const (
	Qt__AbsoluteSize = Qt__SizeMode(0)
	Qt__RelativeSize = Qt__SizeMode(1)
)

//Qt::SortOrder
type Qt__SortOrder int64

const (
	Qt__AscendingOrder  = Qt__SortOrder(0)
	Qt__DescendingOrder = Qt__SortOrder(1)
)

//Qt::TabFocusBehavior
type Qt__TabFocusBehavior int64

const (
	Qt__NoTabFocus           = Qt__TabFocusBehavior(0x00)
	Qt__TabFocusTextControls = Qt__TabFocusBehavior(0x01)
	Qt__TabFocusListControls = Qt__TabFocusBehavior(0x02)
	Qt__TabFocusAllControls  = Qt__TabFocusBehavior(0xff)
)

//Qt::TextElideMode
type Qt__TextElideMode int64

const (
	Qt__ElideLeft   = Qt__TextElideMode(0)
	Qt__ElideRight  = Qt__TextElideMode(1)
	Qt__ElideMiddle = Qt__TextElideMode(2)
	Qt__ElideNone   = Qt__TextElideMode(3)
)

//Qt::TextFlag
type Qt__TextFlag int64

const (
	Qt__TextSingleLine            = Qt__TextFlag(0x0100)
	Qt__TextDontClip              = Qt__TextFlag(0x0200)
	Qt__TextExpandTabs            = Qt__TextFlag(0x0400)
	Qt__TextShowMnemonic          = Qt__TextFlag(0x0800)
	Qt__TextWordWrap              = Qt__TextFlag(0x1000)
	Qt__TextWrapAnywhere          = Qt__TextFlag(0x2000)
	Qt__TextDontPrint             = Qt__TextFlag(0x4000)
	Qt__TextIncludeTrailingSpaces = Qt__TextFlag(0x08000000)
	Qt__TextHideMnemonic          = Qt__TextFlag(0x8000)
	Qt__TextJustificationForced   = Qt__TextFlag(0x10000)
	Qt__TextForceLeftToRight      = Qt__TextFlag(0x20000)
	Qt__TextForceRightToLeft      = Qt__TextFlag(0x40000)
	Qt__TextLongestVariant        = Qt__TextFlag(0x80000)
	Qt__TextBypassShaping         = Qt__TextFlag(0x100000)
)

//Qt::TextFormat
type Qt__TextFormat int64

const (
	Qt__PlainText = Qt__TextFormat(0)
	Qt__RichText  = Qt__TextFormat(1)
	Qt__AutoText  = Qt__TextFormat(2)
)

//Qt::TextInteractionFlag
type Qt__TextInteractionFlag int64

const (
	Qt__NoTextInteraction         = Qt__TextInteractionFlag(0)
	Qt__TextSelectableByMouse     = Qt__TextInteractionFlag(1)
	Qt__TextSelectableByKeyboard  = Qt__TextInteractionFlag(2)
	Qt__LinksAccessibleByMouse    = Qt__TextInteractionFlag(4)
	Qt__LinksAccessibleByKeyboard = Qt__TextInteractionFlag(8)
	Qt__TextEditable              = Qt__TextInteractionFlag(16)
	Qt__TextEditorInteraction     = Qt__TextInteractionFlag(Qt__TextSelectableByMouse | Qt__TextSelectableByKeyboard | Qt__TextEditable)
	Qt__TextBrowserInteraction    = Qt__TextInteractionFlag(Qt__TextSelectableByMouse | Qt__LinksAccessibleByMouse | Qt__LinksAccessibleByKeyboard)
)

//Qt::TileRule
type Qt__TileRule int64

const (
	Qt__StretchTile = Qt__TileRule(0)
	Qt__RepeatTile  = Qt__TileRule(1)
	Qt__RoundTile   = Qt__TileRule(2)
)

//Qt::TimeSpec
type Qt__TimeSpec int64

const (
	Qt__LocalTime     = Qt__TimeSpec(0)
	Qt__UTC           = Qt__TimeSpec(1)
	Qt__OffsetFromUTC = Qt__TimeSpec(2)
	Qt__TimeZone      = Qt__TimeSpec(3)
)

//Qt::TimerType
type Qt__TimerType int64

const (
	Qt__PreciseTimer    = Qt__TimerType(0)
	Qt__CoarseTimer     = Qt__TimerType(1)
	Qt__VeryCoarseTimer = Qt__TimerType(2)
)

//Qt::ToolBarArea
type Qt__ToolBarArea int64

const (
	Qt__LeftToolBarArea   = Qt__ToolBarArea(0x1)
	Qt__RightToolBarArea  = Qt__ToolBarArea(0x2)
	Qt__TopToolBarArea    = Qt__ToolBarArea(0x4)
	Qt__BottomToolBarArea = Qt__ToolBarArea(0x8)
	Qt__ToolBarArea_Mask  = Qt__ToolBarArea(0xf)
	Qt__AllToolBarAreas   = Qt__ToolBarArea(Qt__ToolBarArea_Mask)
	Qt__NoToolBarArea     = Qt__ToolBarArea(0)
)

//Qt::ToolButtonStyle
type Qt__ToolButtonStyle int64

var (
	Qt__ToolButtonIconOnly       = Qt__ToolButtonStyle(0)
	Qt__ToolButtonTextOnly       = Qt__ToolButtonStyle(1)
	Qt__ToolButtonTextBesideIcon = Qt__ToolButtonStyle(2)
	Qt__ToolButtonTextUnderIcon  = Qt__ToolButtonStyle(3)
	Qt__ToolButtonFollowStyle    = Qt__ToolButtonStyle(4)
)

//Qt::TouchPointState
type Qt__TouchPointState int64

const (
	Qt__TouchPointPressed    = Qt__TouchPointState(0x01)
	Qt__TouchPointMoved      = Qt__TouchPointState(0x02)
	Qt__TouchPointStationary = Qt__TouchPointState(0x04)
	Qt__TouchPointReleased   = Qt__TouchPointState(0x08)
)

//Qt::TransformationMode
type Qt__TransformationMode int64

const (
	Qt__FastTransformation   = Qt__TransformationMode(0)
	Qt__SmoothTransformation = Qt__TransformationMode(1)
)

//Qt::UIEffect
type Qt__UIEffect int64

const (
	Qt__UI_General        = Qt__UIEffect(0)
	Qt__UI_AnimateMenu    = Qt__UIEffect(1)
	Qt__UI_FadeMenu       = Qt__UIEffect(2)
	Qt__UI_AnimateCombo   = Qt__UIEffect(3)
	Qt__UI_AnimateTooltip = Qt__UIEffect(4)
	Qt__UI_FadeTooltip    = Qt__UIEffect(5)
	Qt__UI_AnimateToolBox = Qt__UIEffect(6)
)

//Qt::WhiteSpaceMode
type Qt__WhiteSpaceMode int64

const (
	Qt__WhiteSpaceNormal        = Qt__WhiteSpaceMode(0)
	Qt__WhiteSpacePre           = Qt__WhiteSpaceMode(1)
	Qt__WhiteSpaceNoWrap        = Qt__WhiteSpaceMode(2)
	Qt__WhiteSpaceModeUndefined = Qt__WhiteSpaceMode(-1)
)

//Qt::WidgetAttribute
type Qt__WidgetAttribute int64

const (
	Qt__WA_Disabled                        = Qt__WidgetAttribute(0)
	Qt__WA_UnderMouse                      = Qt__WidgetAttribute(1)
	Qt__WA_MouseTracking                   = Qt__WidgetAttribute(2)
	Qt__WA_ContentsPropagated              = Qt__WidgetAttribute(3)
	Qt__WA_OpaquePaintEvent                = Qt__WidgetAttribute(4)
	Qt__WA_NoBackground                    = Qt__WidgetAttribute(Qt__WA_OpaquePaintEvent)
	Qt__WA_StaticContents                  = Qt__WidgetAttribute(5)
	Qt__WA_LaidOut                         = Qt__WidgetAttribute(7)
	Qt__WA_PaintOnScreen                   = Qt__WidgetAttribute(8)
	Qt__WA_NoSystemBackground              = Qt__WidgetAttribute(9)
	Qt__WA_UpdatesDisabled                 = Qt__WidgetAttribute(10)
	Qt__WA_Mapped                          = Qt__WidgetAttribute(11)
	Qt__WA_MacNoClickThrough               = Qt__WidgetAttribute(12)
	Qt__WA_InputMethodEnabled              = Qt__WidgetAttribute(14)
	Qt__WA_WState_Visible                  = Qt__WidgetAttribute(15)
	Qt__WA_WState_Hidden                   = Qt__WidgetAttribute(16)
	Qt__WA_ForceDisabled                   = Qt__WidgetAttribute(32)
	Qt__WA_KeyCompression                  = Qt__WidgetAttribute(33)
	Qt__WA_PendingMoveEvent                = Qt__WidgetAttribute(34)
	Qt__WA_PendingResizeEvent              = Qt__WidgetAttribute(35)
	Qt__WA_SetPalette                      = Qt__WidgetAttribute(36)
	Qt__WA_SetFont                         = Qt__WidgetAttribute(37)
	Qt__WA_SetCursor                       = Qt__WidgetAttribute(38)
	Qt__WA_NoChildEventsFromChildren       = Qt__WidgetAttribute(39)
	Qt__WA_WindowModified                  = Qt__WidgetAttribute(41)
	Qt__WA_Resized                         = Qt__WidgetAttribute(42)
	Qt__WA_Moved                           = Qt__WidgetAttribute(43)
	Qt__WA_PendingUpdate                   = Qt__WidgetAttribute(44)
	Qt__WA_InvalidSize                     = Qt__WidgetAttribute(45)
	Qt__WA_MacBrushedMetal                 = Qt__WidgetAttribute(46)
	Qt__WA_MacMetalStyle                   = Qt__WidgetAttribute(Qt__WA_MacBrushedMetal)
	Qt__WA_CustomWhatsThis                 = Qt__WidgetAttribute(47)
	Qt__WA_LayoutOnEntireRect              = Qt__WidgetAttribute(48)
	Qt__WA_OutsideWSRange                  = Qt__WidgetAttribute(49)
	Qt__WA_GrabbedShortcut                 = Qt__WidgetAttribute(50)
	Qt__WA_TransparentForMouseEvents       = Qt__WidgetAttribute(51)
	Qt__WA_PaintUnclipped                  = Qt__WidgetAttribute(52)
	Qt__WA_SetWindowIcon                   = Qt__WidgetAttribute(53)
	Qt__WA_NoMouseReplay                   = Qt__WidgetAttribute(54)
	Qt__WA_DeleteOnClose                   = Qt__WidgetAttribute(55)
	Qt__WA_RightToLeft                     = Qt__WidgetAttribute(56)
	Qt__WA_SetLayoutDirection              = Qt__WidgetAttribute(57)
	Qt__WA_NoChildEventsForParent          = Qt__WidgetAttribute(58)
	Qt__WA_ForceUpdatesDisabled            = Qt__WidgetAttribute(59)
	Qt__WA_WState_Created                  = Qt__WidgetAttribute(60)
	Qt__WA_WState_CompressKeys             = Qt__WidgetAttribute(61)
	Qt__WA_WState_InPaintEvent             = Qt__WidgetAttribute(62)
	Qt__WA_WState_Reparented               = Qt__WidgetAttribute(63)
	Qt__WA_WState_ConfigPending            = Qt__WidgetAttribute(64)
	Qt__WA_WState_Polished                 = Qt__WidgetAttribute(66)
	Qt__WA_WState_DND                      = Qt__WidgetAttribute(67)
	Qt__WA_WState_OwnSizePolicy            = Qt__WidgetAttribute(68)
	Qt__WA_WState_ExplicitShowHide         = Qt__WidgetAttribute(69)
	Qt__WA_ShowModal                       = Qt__WidgetAttribute(70)
	Qt__WA_MouseNoMask                     = Qt__WidgetAttribute(71)
	Qt__WA_GroupLeader                     = Qt__WidgetAttribute(72)
	Qt__WA_NoMousePropagation              = Qt__WidgetAttribute(73)
	Qt__WA_Hover                           = Qt__WidgetAttribute(74)
	Qt__WA_InputMethodTransparent          = Qt__WidgetAttribute(75)
	Qt__WA_QuitOnClose                     = Qt__WidgetAttribute(76)
	Qt__WA_KeyboardFocusChange             = Qt__WidgetAttribute(77)
	Qt__WA_AcceptDrops                     = Qt__WidgetAttribute(78)
	Qt__WA_DropSiteRegistered              = Qt__WidgetAttribute(79)
	Qt__WA_ForceAcceptDrops                = Qt__WidgetAttribute(Qt__WA_DropSiteRegistered)
	Qt__WA_WindowPropagation               = Qt__WidgetAttribute(80)
	Qt__WA_NoX11EventCompression           = Qt__WidgetAttribute(81)
	Qt__WA_TintedBackground                = Qt__WidgetAttribute(82)
	Qt__WA_X11OpenGLOverlay                = Qt__WidgetAttribute(83)
	Qt__WA_AlwaysShowToolTips              = Qt__WidgetAttribute(84)
	Qt__WA_MacOpaqueSizeGrip               = Qt__WidgetAttribute(85)
	Qt__WA_SetStyle                        = Qt__WidgetAttribute(86)
	Qt__WA_SetLocale                       = Qt__WidgetAttribute(87)
	Qt__WA_MacShowFocusRect                = Qt__WidgetAttribute(88)
	Qt__WA_MacNormalSize                   = Qt__WidgetAttribute(89)
	Qt__WA_MacSmallSize                    = Qt__WidgetAttribute(90)
	Qt__WA_MacMiniSize                     = Qt__WidgetAttribute(91)
	Qt__WA_LayoutUsesWidgetRect            = Qt__WidgetAttribute(92)
	Qt__WA_StyledBackground                = Qt__WidgetAttribute(93)
	Qt__WA_MSWindowsUseDirect3D            = Qt__WidgetAttribute(94)
	Qt__WA_CanHostQMdiSubWindowTitleBar    = Qt__WidgetAttribute(95)
	Qt__WA_MacAlwaysShowToolWindow         = Qt__WidgetAttribute(96)
	Qt__WA_StyleSheet                      = Qt__WidgetAttribute(97)
	Qt__WA_ShowWithoutActivating           = Qt__WidgetAttribute(98)
	Qt__WA_X11BypassTransientForHint       = Qt__WidgetAttribute(99)
	Qt__WA_NativeWindow                    = Qt__WidgetAttribute(100)
	Qt__WA_DontCreateNativeAncestors       = Qt__WidgetAttribute(101)
	Qt__WA_MacVariableSize                 = Qt__WidgetAttribute(102)
	Qt__WA_DontShowOnScreen                = Qt__WidgetAttribute(103)
	Qt__WA_X11NetWmWindowTypeDesktop       = Qt__WidgetAttribute(104)
	Qt__WA_X11NetWmWindowTypeDock          = Qt__WidgetAttribute(105)
	Qt__WA_X11NetWmWindowTypeToolBar       = Qt__WidgetAttribute(106)
	Qt__WA_X11NetWmWindowTypeMenu          = Qt__WidgetAttribute(107)
	Qt__WA_X11NetWmWindowTypeUtility       = Qt__WidgetAttribute(108)
	Qt__WA_X11NetWmWindowTypeSplash        = Qt__WidgetAttribute(109)
	Qt__WA_X11NetWmWindowTypeDialog        = Qt__WidgetAttribute(110)
	Qt__WA_X11NetWmWindowTypeDropDownMenu  = Qt__WidgetAttribute(111)
	Qt__WA_X11NetWmWindowTypePopupMenu     = Qt__WidgetAttribute(112)
	Qt__WA_X11NetWmWindowTypeToolTip       = Qt__WidgetAttribute(113)
	Qt__WA_X11NetWmWindowTypeNotification  = Qt__WidgetAttribute(114)
	Qt__WA_X11NetWmWindowTypeCombo         = Qt__WidgetAttribute(115)
	Qt__WA_X11NetWmWindowTypeDND           = Qt__WidgetAttribute(116)
	Qt__WA_MacFrameworkScaled              = Qt__WidgetAttribute(117)
	Qt__WA_SetWindowModality               = Qt__WidgetAttribute(118)
	Qt__WA_WState_WindowOpacitySet         = Qt__WidgetAttribute(119)
	Qt__WA_TranslucentBackground           = Qt__WidgetAttribute(120)
	Qt__WA_AcceptTouchEvents               = Qt__WidgetAttribute(121)
	Qt__WA_WState_AcceptedTouchBeginEvent  = Qt__WidgetAttribute(122)
	Qt__WA_TouchPadAcceptSingleTouchEvents = Qt__WidgetAttribute(123)
	Qt__WA_X11DoNotAcceptFocus             = Qt__WidgetAttribute(126)
	Qt__WA_MacNoShadow                     = Qt__WidgetAttribute(127)
	Qt__WA_AlwaysStackOnTop                = Qt__WidgetAttribute(128)
	Qt__WA_AttributeCount                  = Qt__WidgetAttribute(129)
)

//Qt::WindowFrameSection
type Qt__WindowFrameSection int64

const (
	Qt__NoSection          = Qt__WindowFrameSection(0)
	Qt__LeftSection        = Qt__WindowFrameSection(1)
	Qt__TopLeftSection     = Qt__WindowFrameSection(2)
	Qt__TopSection         = Qt__WindowFrameSection(3)
	Qt__TopRightSection    = Qt__WindowFrameSection(4)
	Qt__RightSection       = Qt__WindowFrameSection(5)
	Qt__BottomRightSection = Qt__WindowFrameSection(6)
	Qt__BottomSection      = Qt__WindowFrameSection(7)
	Qt__BottomLeftSection  = Qt__WindowFrameSection(8)
	Qt__TitleBarArea       = Qt__WindowFrameSection(9)
)

//Qt::WindowModality
type Qt__WindowModality int64

const (
	Qt__NonModal         = Qt__WindowModality(0)
	Qt__WindowModal      = Qt__WindowModality(1)
	Qt__ApplicationModal = Qt__WindowModality(2)
)

//Qt::WindowState
type Qt__WindowState int64

const (
	Qt__WindowNoState    = Qt__WindowState(0x00000000)
	Qt__WindowMinimized  = Qt__WindowState(0x00000001)
	Qt__WindowMaximized  = Qt__WindowState(0x00000002)
	Qt__WindowFullScreen = Qt__WindowState(0x00000004)
	Qt__WindowActive     = Qt__WindowState(0x00000008)
)

//Qt::WindowType
type Qt__WindowType int64

const (
	Qt__Widget                              = Qt__WindowType(0x00000000)
	Qt__Window                              = Qt__WindowType(0x00000001)
	Qt__Dialog                              = Qt__WindowType(0x00000002 | Qt__Window)
	Qt__Sheet                               = Qt__WindowType(0x00000004 | Qt__Window)
	Qt__Drawer                              = Qt__WindowType(Qt__Sheet | Qt__Dialog)
	Qt__Popup                               = Qt__WindowType(0x00000008 | Qt__Window)
	Qt__Tool                                = Qt__WindowType(Qt__Popup | Qt__Dialog)
	Qt__ToolTip                             = Qt__WindowType(Qt__Popup | Qt__Sheet)
	Qt__SplashScreen                        = Qt__WindowType(Qt__ToolTip | Qt__Dialog)
	Qt__Desktop                             = Qt__WindowType(0x00000010 | Qt__Window)
	Qt__SubWindow                           = Qt__WindowType(0x00000012)
	Qt__ForeignWindow                       = Qt__WindowType(0x00000020 | Qt__Window)
	Qt__CoverWindow                         = Qt__WindowType(0x00000040 | Qt__Window)
	Qt__WindowType_Mask                     = Qt__WindowType(0x000000ff)
	Qt__MSWindowsFixedSizeDialogHint        = Qt__WindowType(0x00000100)
	Qt__MSWindowsOwnDC                      = Qt__WindowType(0x00000200)
	Qt__BypassWindowManagerHint             = Qt__WindowType(0x00000400)
	Qt__X11BypassWindowManagerHint          = Qt__WindowType(Qt__BypassWindowManagerHint)
	Qt__FramelessWindowHint                 = Qt__WindowType(0x00000800)
	Qt__WindowTitleHint                     = Qt__WindowType(0x00001000)
	Qt__WindowSystemMenuHint                = Qt__WindowType(0x00002000)
	Qt__WindowMinimizeButtonHint            = Qt__WindowType(0x00004000)
	Qt__WindowMaximizeButtonHint            = Qt__WindowType(0x00008000)
	Qt__WindowMinMaxButtonsHint             = Qt__WindowType(Qt__WindowMinimizeButtonHint | Qt__WindowMaximizeButtonHint)
	Qt__WindowContextHelpButtonHint         = Qt__WindowType(0x00010000)
	Qt__WindowShadeButtonHint               = Qt__WindowType(0x00020000)
	Qt__WindowStaysOnTopHint                = Qt__WindowType(0x00040000)
	Qt__WindowTransparentForInput           = Qt__WindowType(0x00080000)
	Qt__WindowOverridesSystemGestures       = Qt__WindowType(0x00100000)
	Qt__WindowDoesNotAcceptFocus            = Qt__WindowType(0x00200000)
	Qt__MaximizeUsingFullscreenGeometryHint = Qt__WindowType(0x00400000)
	Qt__CustomizeWindowHint                 = Qt__WindowType(0x02000000)
	Qt__WindowStaysOnBottomHint             = Qt__WindowType(0x04000000)
	Qt__WindowCloseButtonHint               = Qt__WindowType(0x08000000)
	Qt__MacWindowToolBarButtonHint          = Qt__WindowType(0x10000000)
	Qt__BypassGraphicsProxyWidget           = Qt__WindowType(0x20000000)
	Qt__NoDropShadowWindowHint              = Qt__WindowType(0x40000000)
	Qt__WindowFullscreenButtonHint          = Qt__WindowType(0x80000000)
	Qt__WindowOkButtonHint                  = Qt__WindowType(0x00080000)
	Qt__WindowCancelButtonHint              = Qt__WindowType(0x00100000)
)

type QtGlobalStatic struct {
	ptr unsafe.Pointer
}

type QtGlobalStatic_ITF interface {
	QtGlobalStatic_PTR() *QtGlobalStatic
}

func (p *QtGlobalStatic) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QtGlobalStatic) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQtGlobalStatic(ptr QtGlobalStatic_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QtGlobalStatic_PTR().Pointer()
	}
	return nil
}

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

func newQtGlobalStaticFromPointer(ptr unsafe.Pointer) *QtGlobalStatic {
	var n = NewQtGlobalStaticFromPointer(ptr)
	return n
}

func (ptr *QtGlobalStatic) QtGlobalStatic_PTR() *QtGlobalStatic {
	return ptr
}

//QtGlobalStatic::GuardValues
type QtGlobalStatic__GuardValues int64

const (
	QtGlobalStatic__Destroyed     = QtGlobalStatic__GuardValues(-2)
	QtGlobalStatic__Initialized   = QtGlobalStatic__GuardValues(-1)
	QtGlobalStatic__Uninitialized = QtGlobalStatic__GuardValues(0)
	QtGlobalStatic__Initializing  = QtGlobalStatic__GuardValues(1)
)

type QtMetaTypePrivate struct {
	ptr unsafe.Pointer
}

type QtMetaTypePrivate_ITF interface {
	QtMetaTypePrivate_PTR() *QtMetaTypePrivate
}

func (p *QtMetaTypePrivate) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QtMetaTypePrivate) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQtMetaTypePrivate(ptr QtMetaTypePrivate_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QtMetaTypePrivate_PTR().Pointer()
	}
	return nil
}

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

func newQtMetaTypePrivateFromPointer(ptr unsafe.Pointer) *QtMetaTypePrivate {
	var n = NewQtMetaTypePrivateFromPointer(ptr)
	return n
}

func (ptr *QtMetaTypePrivate) QtMetaTypePrivate_PTR() *QtMetaTypePrivate {
	return ptr
}

//QtMetaTypePrivate::IteratorCapability
type QtMetaTypePrivate__IteratorCapability int64

const (
	QtMetaTypePrivate__ForwardCapability       = QtMetaTypePrivate__IteratorCapability(1)
	QtMetaTypePrivate__BiDirectionalCapability = QtMetaTypePrivate__IteratorCapability(2)
	QtMetaTypePrivate__RandomAccessCapability  = QtMetaTypePrivate__IteratorCapability(4)
)