// +build !minimal

package widgets

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

func cGoUnpackString(s C.struct_QtWidgets_PackedString) string {
	if int(s.len) == -1 {
		return C.GoString(s.data)
	}
	return C.GoStringN(s.data, C.int(s.len))
}
func cGoUnpackBytes(s C.struct_QtWidgets_PackedString) []byte {
	if int(s.len) == -1 {
		gs := C.GoString(s.data)
		return *(*[]byte)(unsafe.Pointer(&gs))
	}
	return C.GoBytes(unsafe.Pointer(s.data), C.int(s.len))
}

type QAbstractButton struct {
	QWidget
}

type QAbstractButton_ITF interface {
	QWidget_ITF
	QAbstractButton_PTR() *QAbstractButton
}

func (ptr *QAbstractButton) QAbstractButton_PTR() *QAbstractButton {
	return ptr
}

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

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

func PointerFromQAbstractButton(ptr QAbstractButton_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractButton_PTR().Pointer()
	}
	return nil
}

func NewQAbstractButtonFromPointer(ptr unsafe.Pointer) (n *QAbstractButton) {
	n = new(QAbstractButton)
	n.SetPointer(ptr)
	return
}
func NewQAbstractButton(parent QWidget_ITF) *QAbstractButton {
	tmpValue := NewQAbstractButtonFromPointer(C.QAbstractButton_NewQAbstractButton(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQAbstractButton_AnimateClick
func callbackQAbstractButton_AnimateClick(ptr unsafe.Pointer, msec C.int) {
	if signal := qt.GetSignal(ptr, "animateClick"); signal != nil {
		(*(*func(int))(signal))(int(int32(msec)))
	} else {
		NewQAbstractButtonFromPointer(ptr).AnimateClickDefault(int(int32(msec)))
	}
}

func (ptr *QAbstractButton) ConnectAnimateClick(f func(msec int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectAnimateClick() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) AnimateClick(msec int) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_AnimateClick(ptr.Pointer(), C.int(int32(msec)))
	}
}

func (ptr *QAbstractButton) AnimateClickDefault(msec int) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_AnimateClickDefault(ptr.Pointer(), C.int(int32(msec)))
	}
}

//export callbackQAbstractButton_CheckStateSet
func callbackQAbstractButton_CheckStateSet(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "checkStateSet"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractButtonFromPointer(ptr).CheckStateSetDefault()
	}
}

func (ptr *QAbstractButton) ConnectCheckStateSet(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectCheckStateSet() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) CheckStateSet() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_CheckStateSet(ptr.Pointer())
	}
}

func (ptr *QAbstractButton) CheckStateSetDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_CheckStateSetDefault(ptr.Pointer())
	}
}

//export callbackQAbstractButton_Click
func callbackQAbstractButton_Click(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "click"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractButtonFromPointer(ptr).ClickDefault()
	}
}

func (ptr *QAbstractButton) ConnectClick(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectClick() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) Click() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_Click(ptr.Pointer())
	}
}

func (ptr *QAbstractButton) ClickDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_ClickDefault(ptr.Pointer())
	}
}

//export callbackQAbstractButton_Clicked
func callbackQAbstractButton_Clicked(ptr unsafe.Pointer, checked C.char) {
	if signal := qt.GetSignal(ptr, "clicked"); signal != nil {
		(*(*func(bool))(signal))(int8(checked) != 0)
	}

}

func (ptr *QAbstractButton) ConnectClicked(f func(checked bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "clicked") {
			C.QAbstractButton_ConnectClicked(ptr.Pointer())
		}

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

func (ptr *QAbstractButton) DisconnectClicked() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_DisconnectClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "clicked")
	}
}

func (ptr *QAbstractButton) Clicked(checked bool) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_Clicked(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(checked))))
	}
}

//export callbackQAbstractButton_NextCheckState
func callbackQAbstractButton_NextCheckState(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "nextCheckState"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractButtonFromPointer(ptr).NextCheckStateDefault()
	}
}

func (ptr *QAbstractButton) ConnectNextCheckState(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectNextCheckState() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) NextCheckState() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_NextCheckState(ptr.Pointer())
	}
}

func (ptr *QAbstractButton) NextCheckStateDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_NextCheckStateDefault(ptr.Pointer())
	}
}

//export callbackQAbstractButton_PaintEvent
func callbackQAbstractButton_PaintEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paintEvent"); signal != nil {
		(*(*func(*gui.QPaintEvent))(signal))(gui.NewQPaintEventFromPointer(e))
	}

}

func (ptr *QAbstractButton) ConnectPaintEvent(f func(e *gui.QPaintEvent)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectPaintEvent() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) PaintEvent(e gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_PaintEvent(ptr.Pointer(), gui.PointerFromQPaintEvent(e))
	}
}

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

}

func (ptr *QAbstractButton) ConnectPressed(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "pressed") {
			C.QAbstractButton_ConnectPressed(ptr.Pointer())
		}

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

func (ptr *QAbstractButton) DisconnectPressed() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_DisconnectPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "pressed")
	}
}

func (ptr *QAbstractButton) Pressed() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_Pressed(ptr.Pointer())
	}
}

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

}

func (ptr *QAbstractButton) ConnectReleased(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "released") {
			C.QAbstractButton_ConnectReleased(ptr.Pointer())
		}

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

func (ptr *QAbstractButton) DisconnectReleased() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_DisconnectReleased(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "released")
	}
}

func (ptr *QAbstractButton) Released() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_Released(ptr.Pointer())
	}
}

func (ptr *QAbstractButton) SetAutoExclusive(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetAutoExclusive(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAbstractButton) SetAutoRepeat(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetAutoRepeat(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAbstractButton) SetAutoRepeatDelay(vin int) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetAutoRepeatDelay(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QAbstractButton) SetAutoRepeatInterval(vin int) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetAutoRepeatInterval(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QAbstractButton) SetCheckable(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetCheckable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQAbstractButton_SetChecked
func callbackQAbstractButton_SetChecked(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setChecked"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQAbstractButtonFromPointer(ptr).SetCheckedDefault(int8(vbo) != 0)
	}
}

func (ptr *QAbstractButton) ConnectSetChecked(f func(vbo bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectSetChecked() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) SetChecked(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetChecked(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAbstractButton) SetCheckedDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetCheckedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAbstractButton) SetDown(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetDown(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAbstractButton) SetIcon(icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(icon))
	}
}

//export callbackQAbstractButton_SetIconSize
func callbackQAbstractButton_SetIconSize(ptr unsafe.Pointer, size unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setIconSize"); signal != nil {
		(*(*func(*core.QSize))(signal))(core.NewQSizeFromPointer(size))
	} else {
		NewQAbstractButtonFromPointer(ptr).SetIconSizeDefault(core.NewQSizeFromPointer(size))
	}
}

func (ptr *QAbstractButton) ConnectSetIconSize(f func(size *core.QSize)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectSetIconSize() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) SetIconSize(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetIconSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QAbstractButton) SetIconSizeDefault(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetIconSizeDefault(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QAbstractButton) SetShortcut(key gui.QKeySequence_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_SetShortcut(ptr.Pointer(), gui.PointerFromQKeySequence(key))
	}
}

func (ptr *QAbstractButton) SetText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QAbstractButton_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQAbstractButton_Toggle
func callbackQAbstractButton_Toggle(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "toggle"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractButtonFromPointer(ptr).ToggleDefault()
	}
}

func (ptr *QAbstractButton) ConnectToggle(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectToggle() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) Toggle() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_Toggle(ptr.Pointer())
	}
}

func (ptr *QAbstractButton) ToggleDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_ToggleDefault(ptr.Pointer())
	}
}

//export callbackQAbstractButton_Toggled
func callbackQAbstractButton_Toggled(ptr unsafe.Pointer, checked C.char) {
	if signal := qt.GetSignal(ptr, "toggled"); signal != nil {
		(*(*func(bool))(signal))(int8(checked) != 0)
	}

}

func (ptr *QAbstractButton) ConnectToggled(f func(checked bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "toggled") {
			C.QAbstractButton_ConnectToggled(ptr.Pointer())
		}

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

func (ptr *QAbstractButton) DisconnectToggled() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_DisconnectToggled(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "toggled")
	}
}

func (ptr *QAbstractButton) Toggled(checked bool) {
	if ptr.Pointer() != nil {
		C.QAbstractButton_Toggled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(checked))))
	}
}

//export callbackQAbstractButton_DestroyQAbstractButton
func callbackQAbstractButton_DestroyQAbstractButton(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractButton"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractButtonFromPointer(ptr).DestroyQAbstractButtonDefault()
	}
}

func (ptr *QAbstractButton) ConnectDestroyQAbstractButton(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectDestroyQAbstractButton() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DestroyQAbstractButton() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_DestroyQAbstractButton(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractButton) DestroyQAbstractButtonDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractButton_DestroyQAbstractButtonDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractButton) Group() *QButtonGroup {
	if ptr.Pointer() != nil {
		tmpValue := NewQButtonGroupFromPointer(C.QAbstractButton_Group(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractButton) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QAbstractButton_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractButton) Shortcut() *gui.QKeySequence {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQKeySequenceFromPointer(C.QAbstractButton_Shortcut(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QKeySequence).DestroyQKeySequence)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractButton) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QAbstractButton_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractButton) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAbstractButton_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QAbstractButton) AutoExclusive() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractButton_AutoExclusive(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractButton) AutoRepeat() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractButton_AutoRepeat(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQAbstractButton_HitButton
func callbackQAbstractButton_HitButton(ptr unsafe.Pointer, pos unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "hitButton"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QPoint) bool)(signal))(core.NewQPointFromPointer(pos)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractButtonFromPointer(ptr).HitButtonDefault(core.NewQPointFromPointer(pos)))))
}

func (ptr *QAbstractButton) ConnectHitButton(f func(pos *core.QPoint) bool) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) DisconnectHitButton() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractButton) HitButton(pos core.QPoint_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractButton_HitButton(ptr.Pointer(), core.PointerFromQPoint(pos))) != 0
	}
	return false
}

func (ptr *QAbstractButton) HitButtonDefault(pos core.QPoint_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractButton_HitButtonDefault(ptr.Pointer(), core.PointerFromQPoint(pos))) != 0
	}
	return false
}

func (ptr *QAbstractButton) IsCheckable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractButton_IsCheckable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractButton) IsChecked() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractButton_IsChecked(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractButton) IsDown() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractButton_IsDown(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractButton) AutoRepeatDelay() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractButton_AutoRepeatDelay(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAbstractButton) AutoRepeatInterval() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractButton_AutoRepeatInterval(ptr.Pointer())))
	}
	return 0
}

type QAbstractGraphicsShapeItem struct {
	QGraphicsItem
}

type QAbstractGraphicsShapeItem_ITF interface {
	QGraphicsItem_ITF
	QAbstractGraphicsShapeItem_PTR() *QAbstractGraphicsShapeItem
}

func (ptr *QAbstractGraphicsShapeItem) QAbstractGraphicsShapeItem_PTR() *QAbstractGraphicsShapeItem {
	return ptr
}

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

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

func PointerFromQAbstractGraphicsShapeItem(ptr QAbstractGraphicsShapeItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractGraphicsShapeItem_PTR().Pointer()
	}
	return nil
}

func NewQAbstractGraphicsShapeItemFromPointer(ptr unsafe.Pointer) (n *QAbstractGraphicsShapeItem) {
	n = new(QAbstractGraphicsShapeItem)
	n.SetPointer(ptr)
	return
}
func NewQAbstractGraphicsShapeItem(parent QGraphicsItem_ITF) *QAbstractGraphicsShapeItem {
	return NewQAbstractGraphicsShapeItemFromPointer(C.QAbstractGraphicsShapeItem_NewQAbstractGraphicsShapeItem(PointerFromQGraphicsItem(parent)))
}

func (ptr *QAbstractGraphicsShapeItem) SetBrush(brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractGraphicsShapeItem_SetBrush(ptr.Pointer(), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QAbstractGraphicsShapeItem) SetPen(pen gui.QPen_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractGraphicsShapeItem_SetPen(ptr.Pointer(), gui.PointerFromQPen(pen))
	}
}

//export callbackQAbstractGraphicsShapeItem_DestroyQAbstractGraphicsShapeItem
func callbackQAbstractGraphicsShapeItem_DestroyQAbstractGraphicsShapeItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractGraphicsShapeItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractGraphicsShapeItemFromPointer(ptr).DestroyQAbstractGraphicsShapeItemDefault()
	}
}

func (ptr *QAbstractGraphicsShapeItem) ConnectDestroyQAbstractGraphicsShapeItem(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractGraphicsShapeItem) DisconnectDestroyQAbstractGraphicsShapeItem() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractGraphicsShapeItem) DestroyQAbstractGraphicsShapeItem() {
	if ptr.Pointer() != nil {
		C.QAbstractGraphicsShapeItem_DestroyQAbstractGraphicsShapeItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractGraphicsShapeItem) DestroyQAbstractGraphicsShapeItemDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractGraphicsShapeItem_DestroyQAbstractGraphicsShapeItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractGraphicsShapeItem) Brush() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QAbstractGraphicsShapeItem_Brush(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractGraphicsShapeItem) Pen() *gui.QPen {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPenFromPointer(C.QAbstractGraphicsShapeItem_Pen(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPen).DestroyQPen)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractGraphicsShapeItem_Paint
func callbackQAbstractGraphicsShapeItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQAbstractGraphicsShapeItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QAbstractGraphicsShapeItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractGraphicsShapeItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QAbstractGraphicsShapeItem) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractGraphicsShapeItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

//export callbackQAbstractGraphicsShapeItem_BoundingRect
func callbackQAbstractGraphicsShapeItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQAbstractGraphicsShapeItemFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QAbstractGraphicsShapeItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QAbstractGraphicsShapeItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractGraphicsShapeItem) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QAbstractGraphicsShapeItem_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

type QAbstractItemDelegate struct {
	core.QObject
}

type QAbstractItemDelegate_ITF interface {
	core.QObject_ITF
	QAbstractItemDelegate_PTR() *QAbstractItemDelegate
}

func (ptr *QAbstractItemDelegate) QAbstractItemDelegate_PTR() *QAbstractItemDelegate {
	return ptr
}

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

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

func PointerFromQAbstractItemDelegate(ptr QAbstractItemDelegate_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemDelegate_PTR().Pointer()
	}
	return nil
}

func NewQAbstractItemDelegateFromPointer(ptr unsafe.Pointer) (n *QAbstractItemDelegate) {
	n = new(QAbstractItemDelegate)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QAbstractItemDelegate__EndEditHint
//QAbstractItemDelegate::EndEditHint
type QAbstractItemDelegate__EndEditHint int64

const (
	QAbstractItemDelegate__NoHint           QAbstractItemDelegate__EndEditHint = QAbstractItemDelegate__EndEditHint(0)
	QAbstractItemDelegate__EditNextItem     QAbstractItemDelegate__EndEditHint = QAbstractItemDelegate__EndEditHint(1)
	QAbstractItemDelegate__EditPreviousItem QAbstractItemDelegate__EndEditHint = QAbstractItemDelegate__EndEditHint(2)
	QAbstractItemDelegate__SubmitModelCache QAbstractItemDelegate__EndEditHint = QAbstractItemDelegate__EndEditHint(3)
	QAbstractItemDelegate__RevertModelCache QAbstractItemDelegate__EndEditHint = QAbstractItemDelegate__EndEditHint(4)
)

func NewQAbstractItemDelegate(parent core.QObject_ITF) *QAbstractItemDelegate {
	tmpValue := NewQAbstractItemDelegateFromPointer(C.QAbstractItemDelegate_NewQAbstractItemDelegate(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QAbstractItemDelegate_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QAbstractItemDelegate_QAbstractItemDelegate_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QAbstractItemDelegate) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QAbstractItemDelegate_QAbstractItemDelegate_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQAbstractItemDelegate_EditorEvent
func callbackQAbstractItemDelegate_EditorEvent(ptr unsafe.Pointer, event unsafe.Pointer, model unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "editorEvent"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent, *core.QAbstractItemModel, *QStyleOptionViewItem, *core.QModelIndex) bool)(signal))(core.NewQEventFromPointer(event), core.NewQAbstractItemModelFromPointer(model), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemDelegateFromPointer(ptr).EditorEventDefault(core.NewQEventFromPointer(event), core.NewQAbstractItemModelFromPointer(model), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))))
}

func (ptr *QAbstractItemDelegate) ConnectEditorEvent(f func(event *core.QEvent, model *core.QAbstractItemModel, option *QStyleOptionViewItem, index *core.QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "editorEvent"); signal != nil {
			f := func(event *core.QEvent, model *core.QAbstractItemModel, option *QStyleOptionViewItem, index *core.QModelIndex) bool {
				(*(*func(*core.QEvent, *core.QAbstractItemModel, *QStyleOptionViewItem, *core.QModelIndex) bool)(signal))(event, model, option, index)
				return f(event, model, option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "editorEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "editorEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemDelegate) DisconnectEditorEvent() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) EditorEvent(event core.QEvent_ITF, model core.QAbstractItemModel_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemDelegate_EditorEvent(ptr.Pointer(), core.PointerFromQEvent(event), core.PointerFromQAbstractItemModel(model), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QAbstractItemDelegate) EditorEventDefault(event core.QEvent_ITF, model core.QAbstractItemModel_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemDelegate_EditorEventDefault(ptr.Pointer(), core.PointerFromQEvent(event), core.PointerFromQAbstractItemModel(model), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

//export callbackQAbstractItemDelegate_HelpEvent
func callbackQAbstractItemDelegate_HelpEvent(ptr unsafe.Pointer, event unsafe.Pointer, view unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "helpEvent"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*gui.QHelpEvent, *QAbstractItemView, *QStyleOptionViewItem, *core.QModelIndex) bool)(signal))(gui.NewQHelpEventFromPointer(event), NewQAbstractItemViewFromPointer(view), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemDelegateFromPointer(ptr).HelpEventDefault(gui.NewQHelpEventFromPointer(event), NewQAbstractItemViewFromPointer(view), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))))
}

func (ptr *QAbstractItemDelegate) ConnectHelpEvent(f func(event *gui.QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *core.QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "helpEvent"); signal != nil {
			f := func(event *gui.QHelpEvent, view *QAbstractItemView, option *QStyleOptionViewItem, index *core.QModelIndex) bool {
				(*(*func(*gui.QHelpEvent, *QAbstractItemView, *QStyleOptionViewItem, *core.QModelIndex) bool)(signal))(event, view, option, index)
				return f(event, view, option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "helpEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "helpEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemDelegate) DisconnectHelpEvent() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) HelpEvent(event gui.QHelpEvent_ITF, view QAbstractItemView_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemDelegate_HelpEvent(ptr.Pointer(), gui.PointerFromQHelpEvent(event), PointerFromQAbstractItemView(view), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QAbstractItemDelegate) HelpEventDefault(event gui.QHelpEvent_ITF, view QAbstractItemView_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemDelegate_HelpEventDefault(ptr.Pointer(), gui.PointerFromQHelpEvent(event), PointerFromQAbstractItemView(view), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

//export callbackQAbstractItemDelegate_CloseEditor
func callbackQAbstractItemDelegate_CloseEditor(ptr unsafe.Pointer, editor unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "closeEditor"); signal != nil {
		(*(*func(*QWidget, QAbstractItemDelegate__EndEditHint))(signal))(NewQWidgetFromPointer(editor), QAbstractItemDelegate__EndEditHint(hint))
	}

}

func (ptr *QAbstractItemDelegate) ConnectCloseEditor(f func(editor *QWidget, hint QAbstractItemDelegate__EndEditHint)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "closeEditor") {
			C.QAbstractItemDelegate_ConnectCloseEditor(ptr.Pointer())
		}

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

func (ptr *QAbstractItemDelegate) DisconnectCloseEditor() {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_DisconnectCloseEditor(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "closeEditor")
	}
}

func (ptr *QAbstractItemDelegate) CloseEditor(editor QWidget_ITF, hint QAbstractItemDelegate__EndEditHint) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_CloseEditor(ptr.Pointer(), PointerFromQWidget(editor), C.longlong(hint))
	}
}

//export callbackQAbstractItemDelegate_CommitData
func callbackQAbstractItemDelegate_CommitData(ptr unsafe.Pointer, editor unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "commitData"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(editor))
	}

}

func (ptr *QAbstractItemDelegate) ConnectCommitData(f func(editor *QWidget)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "commitData") {
			C.QAbstractItemDelegate_ConnectCommitData(ptr.Pointer())
		}

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

func (ptr *QAbstractItemDelegate) DisconnectCommitData() {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_DisconnectCommitData(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "commitData")
	}
}

func (ptr *QAbstractItemDelegate) CommitData(editor QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_CommitData(ptr.Pointer(), PointerFromQWidget(editor))
	}
}

//export callbackQAbstractItemDelegate_SizeHintChanged
func callbackQAbstractItemDelegate_SizeHintChanged(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "sizeHintChanged"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QAbstractItemDelegate) ConnectSizeHintChanged(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sizeHintChanged") {
			C.QAbstractItemDelegate_ConnectSizeHintChanged(ptr.Pointer())
		}

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

func (ptr *QAbstractItemDelegate) DisconnectSizeHintChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_DisconnectSizeHintChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sizeHintChanged")
	}
}

func (ptr *QAbstractItemDelegate) SizeHintChanged(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_SizeHintChanged(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemDelegate_DestroyQAbstractItemDelegate
func callbackQAbstractItemDelegate_DestroyQAbstractItemDelegate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractItemDelegate"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemDelegateFromPointer(ptr).DestroyQAbstractItemDelegateDefault()
	}
}

func (ptr *QAbstractItemDelegate) ConnectDestroyQAbstractItemDelegate(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) DisconnectDestroyQAbstractItemDelegate() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) DestroyQAbstractItemDelegate() {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_DestroyQAbstractItemDelegate(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractItemDelegate) DestroyQAbstractItemDelegateDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_DestroyQAbstractItemDelegateDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQAbstractItemDelegate_SizeHint
func callbackQAbstractItemDelegate_SizeHint(ptr unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func(*QStyleOptionViewItem, *core.QModelIndex) *core.QSize)(signal))(NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQSize(core.NewQSize())
}

func (ptr *QAbstractItemDelegate) ConnectSizeHint(f func(option *QStyleOptionViewItem, index *core.QModelIndex) *core.QSize) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) SizeHint(option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QAbstractItemDelegate_SizeHint(ptr.Pointer(), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemDelegate_CreateEditor
func callbackQAbstractItemDelegate_CreateEditor(ptr unsafe.Pointer, parent unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "createEditor"); signal != nil {
		return PointerFromQWidget((*(*func(*QWidget, *QStyleOptionViewItem, *core.QModelIndex) *QWidget)(signal))(NewQWidgetFromPointer(parent), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))
	}

	return PointerFromQWidget(NewQAbstractItemDelegateFromPointer(ptr).CreateEditorDefault(NewQWidgetFromPointer(parent), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))
}

func (ptr *QAbstractItemDelegate) ConnectCreateEditor(f func(parent *QWidget, option *QStyleOptionViewItem, index *core.QModelIndex) *QWidget) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) DisconnectCreateEditor() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) CreateEditor(parent QWidget_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QAbstractItemDelegate_CreateEditor(ptr.Pointer(), PointerFromQWidget(parent), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemDelegate) CreateEditorDefault(parent QWidget_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QAbstractItemDelegate_CreateEditorDefault(ptr.Pointer(), PointerFromQWidget(parent), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

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

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

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

//export callbackQAbstractItemDelegate_DestroyEditor
func callbackQAbstractItemDelegate_DestroyEditor(ptr unsafe.Pointer, editor unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyEditor"); signal != nil {
		(*(*func(*QWidget, *core.QModelIndex))(signal))(NewQWidgetFromPointer(editor), core.NewQModelIndexFromPointer(index))
	} else {
		NewQAbstractItemDelegateFromPointer(ptr).DestroyEditorDefault(NewQWidgetFromPointer(editor), core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QAbstractItemDelegate) ConnectDestroyEditor(f func(editor *QWidget, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) DisconnectDestroyEditor() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) DestroyEditor(editor QWidget_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_DestroyEditor(ptr.Pointer(), PointerFromQWidget(editor), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemDelegate) DestroyEditorDefault(editor QWidget_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_DestroyEditorDefault(ptr.Pointer(), PointerFromQWidget(editor), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemDelegate_Paint
func callbackQAbstractItemDelegate_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QModelIndex))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QAbstractItemDelegate) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionViewItem, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionViewItem, index *core.QModelIndex) {
				(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QModelIndex))(signal))(painter, option, index)
				f(painter, option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

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

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

func (ptr *QAbstractItemDelegate) Paint(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemDelegate_SetEditorData
func callbackQAbstractItemDelegate_SetEditorData(ptr unsafe.Pointer, editor unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setEditorData"); signal != nil {
		(*(*func(*QWidget, *core.QModelIndex))(signal))(NewQWidgetFromPointer(editor), core.NewQModelIndexFromPointer(index))
	} else {
		NewQAbstractItemDelegateFromPointer(ptr).SetEditorDataDefault(NewQWidgetFromPointer(editor), core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QAbstractItemDelegate) ConnectSetEditorData(f func(editor *QWidget, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) DisconnectSetEditorData() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) SetEditorData(editor QWidget_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_SetEditorData(ptr.Pointer(), PointerFromQWidget(editor), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemDelegate) SetEditorDataDefault(editor QWidget_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_SetEditorDataDefault(ptr.Pointer(), PointerFromQWidget(editor), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemDelegate_SetModelData
func callbackQAbstractItemDelegate_SetModelData(ptr unsafe.Pointer, editor unsafe.Pointer, model unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setModelData"); signal != nil {
		(*(*func(*QWidget, *core.QAbstractItemModel, *core.QModelIndex))(signal))(NewQWidgetFromPointer(editor), core.NewQAbstractItemModelFromPointer(model), core.NewQModelIndexFromPointer(index))
	} else {
		NewQAbstractItemDelegateFromPointer(ptr).SetModelDataDefault(NewQWidgetFromPointer(editor), core.NewQAbstractItemModelFromPointer(model), core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QAbstractItemDelegate) ConnectSetModelData(f func(editor *QWidget, model *core.QAbstractItemModel, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setModelData"); signal != nil {
			f := func(editor *QWidget, model *core.QAbstractItemModel, index *core.QModelIndex) {
				(*(*func(*QWidget, *core.QAbstractItemModel, *core.QModelIndex))(signal))(editor, model, index)
				f(editor, model, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "setModelData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setModelData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemDelegate) DisconnectSetModelData() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) SetModelData(editor QWidget_ITF, model core.QAbstractItemModel_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_SetModelData(ptr.Pointer(), PointerFromQWidget(editor), core.PointerFromQAbstractItemModel(model), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemDelegate) SetModelDataDefault(editor QWidget_ITF, model core.QAbstractItemModel_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_SetModelDataDefault(ptr.Pointer(), PointerFromQWidget(editor), core.PointerFromQAbstractItemModel(model), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemDelegate_UpdateEditorGeometry
func callbackQAbstractItemDelegate_UpdateEditorGeometry(ptr unsafe.Pointer, editor unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateEditorGeometry"); signal != nil {
		(*(*func(*QWidget, *QStyleOptionViewItem, *core.QModelIndex))(signal))(NewQWidgetFromPointer(editor), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	} else {
		NewQAbstractItemDelegateFromPointer(ptr).UpdateEditorGeometryDefault(NewQWidgetFromPointer(editor), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QAbstractItemDelegate) ConnectUpdateEditorGeometry(f func(editor *QWidget, option *QStyleOptionViewItem, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateEditorGeometry"); signal != nil {
			f := func(editor *QWidget, option *QStyleOptionViewItem, index *core.QModelIndex) {
				(*(*func(*QWidget, *QStyleOptionViewItem, *core.QModelIndex))(signal))(editor, option, index)
				f(editor, option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateEditorGeometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateEditorGeometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemDelegate) DisconnectUpdateEditorGeometry() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemDelegate) UpdateEditorGeometry(editor QWidget_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_UpdateEditorGeometry(ptr.Pointer(), PointerFromQWidget(editor), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemDelegate) UpdateEditorGeometryDefault(editor QWidget_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_UpdateEditorGeometryDefault(ptr.Pointer(), PointerFromQWidget(editor), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemDelegate) __paintingRoles_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemDelegate___paintingRoles_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QAbstractItemDelegate) __paintingRoles_setList(i int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate___paintingRoles_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QAbstractItemDelegate) __paintingRoles_newList() unsafe.Pointer {
	return C.QAbstractItemDelegate___paintingRoles_newList(ptr.Pointer())
}

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

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

func (ptr *QAbstractItemDelegate) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QAbstractItemDelegate___dynamicPropertyNames_newList(ptr.Pointer())
}

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

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

func (ptr *QAbstractItemDelegate) __findChildren_newList2() unsafe.Pointer {
	return C.QAbstractItemDelegate___findChildren_newList2(ptr.Pointer())
}

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

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

func (ptr *QAbstractItemDelegate) __findChildren_newList3() unsafe.Pointer {
	return C.QAbstractItemDelegate___findChildren_newList3(ptr.Pointer())
}

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

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

func (ptr *QAbstractItemDelegate) __findChildren_newList() unsafe.Pointer {
	return C.QAbstractItemDelegate___findChildren_newList(ptr.Pointer())
}

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

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

func (ptr *QAbstractItemDelegate) __children_newList() unsafe.Pointer {
	return C.QAbstractItemDelegate___children_newList(ptr.Pointer())
}

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

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

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

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

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

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

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

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

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

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

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

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

//export callbackQAbstractItemDelegate_DeleteLater
func callbackQAbstractItemDelegate_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemDelegateFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QAbstractItemDelegate) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemDelegate_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

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

}

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

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

//export callbackQAbstractItemDelegate_ObjectNameChanged
func callbackQAbstractItemDelegate_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

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

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

type QAbstractItemView struct {
	QAbstractScrollArea
}

type QAbstractItemView_ITF interface {
	QAbstractScrollArea_ITF
	QAbstractItemView_PTR() *QAbstractItemView
}

func (ptr *QAbstractItemView) QAbstractItemView_PTR() *QAbstractItemView {
	return ptr
}

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

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

func PointerFromQAbstractItemView(ptr QAbstractItemView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemView_PTR().Pointer()
	}
	return nil
}

func NewQAbstractItemViewFromPointer(ptr unsafe.Pointer) (n *QAbstractItemView) {
	n = new(QAbstractItemView)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QAbstractItemView__CursorAction
//QAbstractItemView::CursorAction
type QAbstractItemView__CursorAction int64

const (
	QAbstractItemView__MoveUp       QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(0)
	QAbstractItemView__MoveDown     QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(1)
	QAbstractItemView__MoveLeft     QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(2)
	QAbstractItemView__MoveRight    QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(3)
	QAbstractItemView__MoveHome     QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(4)
	QAbstractItemView__MoveEnd      QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(5)
	QAbstractItemView__MovePageUp   QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(6)
	QAbstractItemView__MovePageDown QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(7)
	QAbstractItemView__MoveNext     QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(8)
	QAbstractItemView__MovePrevious QAbstractItemView__CursorAction = QAbstractItemView__CursorAction(9)
)

//go:generate stringer -type=QAbstractItemView__DragDropMode
//QAbstractItemView::DragDropMode
type QAbstractItemView__DragDropMode int64

const (
	QAbstractItemView__NoDragDrop   QAbstractItemView__DragDropMode = QAbstractItemView__DragDropMode(0)
	QAbstractItemView__DragOnly     QAbstractItemView__DragDropMode = QAbstractItemView__DragDropMode(1)
	QAbstractItemView__DropOnly     QAbstractItemView__DragDropMode = QAbstractItemView__DragDropMode(2)
	QAbstractItemView__DragDrop     QAbstractItemView__DragDropMode = QAbstractItemView__DragDropMode(3)
	QAbstractItemView__InternalMove QAbstractItemView__DragDropMode = QAbstractItemView__DragDropMode(4)
)

//go:generate stringer -type=QAbstractItemView__DropIndicatorPosition
//QAbstractItemView::DropIndicatorPosition
type QAbstractItemView__DropIndicatorPosition int64

const (
	QAbstractItemView__OnItem     QAbstractItemView__DropIndicatorPosition = QAbstractItemView__DropIndicatorPosition(0)
	QAbstractItemView__AboveItem  QAbstractItemView__DropIndicatorPosition = QAbstractItemView__DropIndicatorPosition(1)
	QAbstractItemView__BelowItem  QAbstractItemView__DropIndicatorPosition = QAbstractItemView__DropIndicatorPosition(2)
	QAbstractItemView__OnViewport QAbstractItemView__DropIndicatorPosition = QAbstractItemView__DropIndicatorPosition(3)
)

//go:generate stringer -type=QAbstractItemView__EditTrigger
//QAbstractItemView::EditTrigger
type QAbstractItemView__EditTrigger int64

const (
	QAbstractItemView__NoEditTriggers  QAbstractItemView__EditTrigger = QAbstractItemView__EditTrigger(0)
	QAbstractItemView__CurrentChanged  QAbstractItemView__EditTrigger = QAbstractItemView__EditTrigger(1)
	QAbstractItemView__DoubleClicked   QAbstractItemView__EditTrigger = QAbstractItemView__EditTrigger(2)
	QAbstractItemView__SelectedClicked QAbstractItemView__EditTrigger = QAbstractItemView__EditTrigger(4)
	QAbstractItemView__EditKeyPressed  QAbstractItemView__EditTrigger = QAbstractItemView__EditTrigger(8)
	QAbstractItemView__AnyKeyPressed   QAbstractItemView__EditTrigger = QAbstractItemView__EditTrigger(16)
	QAbstractItemView__AllEditTriggers QAbstractItemView__EditTrigger = QAbstractItemView__EditTrigger(31)
)

//go:generate stringer -type=QAbstractItemView__ScrollHint
//QAbstractItemView::ScrollHint
type QAbstractItemView__ScrollHint int64

const (
	QAbstractItemView__EnsureVisible    QAbstractItemView__ScrollHint = QAbstractItemView__ScrollHint(0)
	QAbstractItemView__PositionAtTop    QAbstractItemView__ScrollHint = QAbstractItemView__ScrollHint(1)
	QAbstractItemView__PositionAtBottom QAbstractItemView__ScrollHint = QAbstractItemView__ScrollHint(2)
	QAbstractItemView__PositionAtCenter QAbstractItemView__ScrollHint = QAbstractItemView__ScrollHint(3)
)

//go:generate stringer -type=QAbstractItemView__ScrollMode
//QAbstractItemView::ScrollMode
type QAbstractItemView__ScrollMode int64

const (
	QAbstractItemView__ScrollPerItem  QAbstractItemView__ScrollMode = QAbstractItemView__ScrollMode(0)
	QAbstractItemView__ScrollPerPixel QAbstractItemView__ScrollMode = QAbstractItemView__ScrollMode(1)
)

//go:generate stringer -type=QAbstractItemView__SelectionBehavior
//QAbstractItemView::SelectionBehavior
type QAbstractItemView__SelectionBehavior int64

const (
	QAbstractItemView__SelectItems   QAbstractItemView__SelectionBehavior = QAbstractItemView__SelectionBehavior(0)
	QAbstractItemView__SelectRows    QAbstractItemView__SelectionBehavior = QAbstractItemView__SelectionBehavior(1)
	QAbstractItemView__SelectColumns QAbstractItemView__SelectionBehavior = QAbstractItemView__SelectionBehavior(2)
)

//go:generate stringer -type=QAbstractItemView__SelectionMode
//QAbstractItemView::SelectionMode
type QAbstractItemView__SelectionMode int64

const (
	QAbstractItemView__NoSelection         QAbstractItemView__SelectionMode = QAbstractItemView__SelectionMode(0)
	QAbstractItemView__SingleSelection     QAbstractItemView__SelectionMode = QAbstractItemView__SelectionMode(1)
	QAbstractItemView__MultiSelection      QAbstractItemView__SelectionMode = QAbstractItemView__SelectionMode(2)
	QAbstractItemView__ExtendedSelection   QAbstractItemView__SelectionMode = QAbstractItemView__SelectionMode(3)
	QAbstractItemView__ContiguousSelection QAbstractItemView__SelectionMode = QAbstractItemView__SelectionMode(4)
)

//go:generate stringer -type=QAbstractItemView__State
//QAbstractItemView::State
type QAbstractItemView__State int64

const (
	QAbstractItemView__NoState            QAbstractItemView__State = QAbstractItemView__State(0)
	QAbstractItemView__DraggingState      QAbstractItemView__State = QAbstractItemView__State(1)
	QAbstractItemView__DragSelectingState QAbstractItemView__State = QAbstractItemView__State(2)
	QAbstractItemView__EditingState       QAbstractItemView__State = QAbstractItemView__State(3)
	QAbstractItemView__ExpandingState     QAbstractItemView__State = QAbstractItemView__State(4)
	QAbstractItemView__CollapsingState    QAbstractItemView__State = QAbstractItemView__State(5)
	QAbstractItemView__AnimatingState     QAbstractItemView__State = QAbstractItemView__State(6)
)

func NewQAbstractItemView(parent QWidget_ITF) *QAbstractItemView {
	tmpValue := NewQAbstractItemViewFromPointer(C.QAbstractItemView_NewQAbstractItemView(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQAbstractItemView_MoveCursor
func callbackQAbstractItemView_MoveCursor(ptr unsafe.Pointer, cursorAction C.longlong, modifiers C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "moveCursor"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
	}

	return core.PointerFromQModelIndex(core.NewQModelIndex())
}

func (ptr *QAbstractItemView) ConnectMoveCursor(f func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "moveCursor"); signal != nil {
			f := func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
				(*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(cursorAction, modifiers)
				return f(cursorAction, modifiers)
			}
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemView) DisconnectMoveCursor() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) MoveCursor(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QAbstractItemView_MoveCursor(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemView_Edit2
func callbackQAbstractItemView_Edit2(ptr unsafe.Pointer, index unsafe.Pointer, trigger C.longlong, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "edit2"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex, QAbstractItemView__EditTrigger, *core.QEvent) bool)(signal))(core.NewQModelIndexFromPointer(index), QAbstractItemView__EditTrigger(trigger), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQAbstractItemViewFromPointer(ptr).Edit2Default(core.NewQModelIndexFromPointer(index), QAbstractItemView__EditTrigger(trigger), core.NewQEventFromPointer(event)))))
}

func (ptr *QAbstractItemView) ConnectEdit2(f func(index *core.QModelIndex, trigger QAbstractItemView__EditTrigger, event *core.QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "edit2"); signal != nil {
			f := func(index *core.QModelIndex, trigger QAbstractItemView__EditTrigger, event *core.QEvent) bool {
				(*(*func(*core.QModelIndex, QAbstractItemView__EditTrigger, *core.QEvent) bool)(signal))(index, trigger, event)
				return f(index, trigger, event)
			}
			qt.ConnectSignal(ptr.Pointer(), "edit2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "edit2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemView) DisconnectEdit2() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) Edit2(index core.QModelIndex_ITF, trigger QAbstractItemView__EditTrigger, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_Edit2(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(trigger), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QAbstractItemView) Edit2Default(index core.QModelIndex_ITF, trigger QAbstractItemView__EditTrigger, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_Edit2Default(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(trigger), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQAbstractItemView_Activated
func callbackQAbstractItemView_Activated(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "activated"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QAbstractItemView) ConnectActivated(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activated") {
			C.QAbstractItemView_ConnectActivated(ptr.Pointer())
		}

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

func (ptr *QAbstractItemView) DisconnectActivated() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DisconnectActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activated")
	}
}

func (ptr *QAbstractItemView) Activated(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_Activated(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemView_ClearSelection
func callbackQAbstractItemView_ClearSelection(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clearSelection"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemViewFromPointer(ptr).ClearSelectionDefault()
	}
}

func (ptr *QAbstractItemView) ConnectClearSelection(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectClearSelection() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) ClearSelection() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ClearSelection(ptr.Pointer())
	}
}

func (ptr *QAbstractItemView) ClearSelectionDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ClearSelectionDefault(ptr.Pointer())
	}
}

//export callbackQAbstractItemView_Clicked
func callbackQAbstractItemView_Clicked(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clicked"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QAbstractItemView) ConnectClicked(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "clicked") {
			C.QAbstractItemView_ConnectClicked(ptr.Pointer())
		}

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

func (ptr *QAbstractItemView) DisconnectClicked() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DisconnectClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "clicked")
	}
}

func (ptr *QAbstractItemView) Clicked(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_Clicked(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemView_CloseEditor
func callbackQAbstractItemView_CloseEditor(ptr unsafe.Pointer, editor unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "closeEditor"); signal != nil {
		(*(*func(*QWidget, QAbstractItemDelegate__EndEditHint))(signal))(NewQWidgetFromPointer(editor), QAbstractItemDelegate__EndEditHint(hint))
	} else {
		NewQAbstractItemViewFromPointer(ptr).CloseEditorDefault(NewQWidgetFromPointer(editor), QAbstractItemDelegate__EndEditHint(hint))
	}
}

func (ptr *QAbstractItemView) ConnectCloseEditor(f func(editor *QWidget, hint QAbstractItemDelegate__EndEditHint)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectCloseEditor() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) CloseEditor(editor QWidget_ITF, hint QAbstractItemDelegate__EndEditHint) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_CloseEditor(ptr.Pointer(), PointerFromQWidget(editor), C.longlong(hint))
	}
}

func (ptr *QAbstractItemView) CloseEditorDefault(editor QWidget_ITF, hint QAbstractItemDelegate__EndEditHint) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_CloseEditorDefault(ptr.Pointer(), PointerFromQWidget(editor), C.longlong(hint))
	}
}

func (ptr *QAbstractItemView) ClosePersistentEditor(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ClosePersistentEditor(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemView_CommitData
func callbackQAbstractItemView_CommitData(ptr unsafe.Pointer, editor unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "commitData"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(editor))
	} else {
		NewQAbstractItemViewFromPointer(ptr).CommitDataDefault(NewQWidgetFromPointer(editor))
	}
}

func (ptr *QAbstractItemView) ConnectCommitData(f func(editor *QWidget)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectCommitData() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) CommitData(editor QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_CommitData(ptr.Pointer(), PointerFromQWidget(editor))
	}
}

func (ptr *QAbstractItemView) CommitDataDefault(editor QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_CommitDataDefault(ptr.Pointer(), PointerFromQWidget(editor))
	}
}

//export callbackQAbstractItemView_CurrentChanged
func callbackQAbstractItemView_CurrentChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	} else {
		NewQAbstractItemViewFromPointer(ptr).CurrentChangedDefault(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	}
}

func (ptr *QAbstractItemView) ConnectCurrentChanged(f func(current *core.QModelIndex, previous *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) CurrentChanged(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_CurrentChanged(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

func (ptr *QAbstractItemView) CurrentChangedDefault(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_CurrentChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

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

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

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

func (ptr *QAbstractItemView) DisconnectDataChanged() {
	if ptr.Pointer() != nil {

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

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

func (ptr *QAbstractItemView) DataChangedDefault(topLeft core.QModelIndex_ITF, bottomRight core.QModelIndex_ITF, roles []int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DataChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(topLeft), core.PointerFromQModelIndex(bottomRight), func() unsafe.Pointer {
			tmpList := NewQAbstractItemViewFromPointer(NewQAbstractItemViewFromPointer(nil).__dataChanged_roles_newList())
			for _, v := range roles {
				tmpList.__dataChanged_roles_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQAbstractItemView_DoubleClicked
func callbackQAbstractItemView_DoubleClicked(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "doubleClicked"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QAbstractItemView) ConnectDoubleClicked(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "doubleClicked") {
			C.QAbstractItemView_ConnectDoubleClicked(ptr.Pointer())
		}

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

func (ptr *QAbstractItemView) DisconnectDoubleClicked() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DisconnectDoubleClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "doubleClicked")
	}
}

func (ptr *QAbstractItemView) DoubleClicked(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DoubleClicked(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemView_Edit
func callbackQAbstractItemView_Edit(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "edit"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQAbstractItemViewFromPointer(ptr).EditDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QAbstractItemView) ConnectEdit(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectEdit() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) Edit(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_Edit(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemView) EditDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_EditDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemView_EditorDestroyed
func callbackQAbstractItemView_EditorDestroyed(ptr unsafe.Pointer, editor unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "editorDestroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(editor))
	} else {
		NewQAbstractItemViewFromPointer(ptr).EditorDestroyedDefault(core.NewQObjectFromPointer(editor))
	}
}

func (ptr *QAbstractItemView) ConnectEditorDestroyed(f func(editor *core.QObject)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectEditorDestroyed() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) EditorDestroyed(editor core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_EditorDestroyed(ptr.Pointer(), core.PointerFromQObject(editor))
	}
}

func (ptr *QAbstractItemView) EditorDestroyedDefault(editor core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_EditorDestroyedDefault(ptr.Pointer(), core.PointerFromQObject(editor))
	}
}

//export callbackQAbstractItemView_Entered
func callbackQAbstractItemView_Entered(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "entered"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QAbstractItemView) ConnectEntered(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "entered") {
			C.QAbstractItemView_ConnectEntered(ptr.Pointer())
		}

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

func (ptr *QAbstractItemView) DisconnectEntered() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DisconnectEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "entered")
	}
}

func (ptr *QAbstractItemView) Entered(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_Entered(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemView) ExecuteDelayedItemsLayout() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ExecuteDelayedItemsLayout(ptr.Pointer())
	}
}

//export callbackQAbstractItemView_IconSizeChanged
func callbackQAbstractItemView_IconSizeChanged(ptr unsafe.Pointer, size unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "iconSizeChanged"); signal != nil {
		(*(*func(*core.QSize))(signal))(core.NewQSizeFromPointer(size))
	}

}

func (ptr *QAbstractItemView) ConnectIconSizeChanged(f func(size *core.QSize)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "iconSizeChanged") {
			C.QAbstractItemView_ConnectIconSizeChanged(ptr.Pointer())
		}

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

func (ptr *QAbstractItemView) DisconnectIconSizeChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DisconnectIconSizeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "iconSizeChanged")
	}
}

func (ptr *QAbstractItemView) IconSizeChanged(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_IconSizeChanged(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

//export callbackQAbstractItemView_KeyboardSearch
func callbackQAbstractItemView_KeyboardSearch(ptr unsafe.Pointer, search C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "keyboardSearch"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(search))
	} else {
		NewQAbstractItemViewFromPointer(ptr).KeyboardSearchDefault(cGoUnpackString(search))
	}
}

func (ptr *QAbstractItemView) ConnectKeyboardSearch(f func(search string)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectKeyboardSearch() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) KeyboardSearch(search string) {
	if ptr.Pointer() != nil {
		var searchC *C.char
		if search != "" {
			searchC = C.CString(search)
			defer C.free(unsafe.Pointer(searchC))
		}
		C.QAbstractItemView_KeyboardSearch(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: searchC, len: C.longlong(len(search))})
	}
}

func (ptr *QAbstractItemView) KeyboardSearchDefault(search string) {
	if ptr.Pointer() != nil {
		var searchC *C.char
		if search != "" {
			searchC = C.CString(search)
			defer C.free(unsafe.Pointer(searchC))
		}
		C.QAbstractItemView_KeyboardSearchDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: searchC, len: C.longlong(len(search))})
	}
}

func (ptr *QAbstractItemView) OpenPersistentEditor(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_OpenPersistentEditor(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemView_Pressed
func callbackQAbstractItemView_Pressed(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "pressed"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QAbstractItemView) ConnectPressed(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "pressed") {
			C.QAbstractItemView_ConnectPressed(ptr.Pointer())
		}

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

func (ptr *QAbstractItemView) DisconnectPressed() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DisconnectPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "pressed")
	}
}

func (ptr *QAbstractItemView) Pressed(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_Pressed(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemView_Reset
func callbackQAbstractItemView_Reset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "reset"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemViewFromPointer(ptr).ResetDefault()
	}
}

func (ptr *QAbstractItemView) ConnectReset(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectReset() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) Reset() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_Reset(ptr.Pointer())
	}
}

func (ptr *QAbstractItemView) ResetDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ResetDefault(ptr.Pointer())
	}
}

func (ptr *QAbstractItemView) ResetHorizontalScrollMode() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ResetHorizontalScrollMode(ptr.Pointer())
	}
}

func (ptr *QAbstractItemView) ResetVerticalScrollMode() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ResetVerticalScrollMode(ptr.Pointer())
	}
}

//export callbackQAbstractItemView_RowsAboutToBeRemoved
func callbackQAbstractItemView_RowsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	} else {
		NewQAbstractItemViewFromPointer(ptr).RowsAboutToBeRemovedDefault(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}
}

func (ptr *QAbstractItemView) ConnectRowsAboutToBeRemoved(f func(parent *core.QModelIndex, start int, end int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectRowsAboutToBeRemoved() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) RowsAboutToBeRemoved(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_RowsAboutToBeRemoved(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

func (ptr *QAbstractItemView) RowsAboutToBeRemovedDefault(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_RowsAboutToBeRemovedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

//export callbackQAbstractItemView_RowsInserted
func callbackQAbstractItemView_RowsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	} else {
		NewQAbstractItemViewFromPointer(ptr).RowsInsertedDefault(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}
}

func (ptr *QAbstractItemView) ConnectRowsInserted(f func(parent *core.QModelIndex, start int, end int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectRowsInserted() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) RowsInserted(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_RowsInserted(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

func (ptr *QAbstractItemView) RowsInsertedDefault(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_RowsInsertedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

func (ptr *QAbstractItemView) ScheduleDelayedItemsLayout() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ScheduleDelayedItemsLayout(ptr.Pointer())
	}
}

func (ptr *QAbstractItemView) ScrollDirtyRegion(dx int, dy int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ScrollDirtyRegion(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy)))
	}
}

//export callbackQAbstractItemView_ScrollTo
func callbackQAbstractItemView_ScrollTo(ptr unsafe.Pointer, index unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "scrollTo"); signal != nil {
		(*(*func(*core.QModelIndex, QAbstractItemView__ScrollHint))(signal))(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	}

}

func (ptr *QAbstractItemView) ConnectScrollTo(f func(index *core.QModelIndex, hint QAbstractItemView__ScrollHint)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectScrollTo() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) ScrollTo(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ScrollTo(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

//export callbackQAbstractItemView_ScrollToBottom
func callbackQAbstractItemView_ScrollToBottom(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "scrollToBottom"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemViewFromPointer(ptr).ScrollToBottomDefault()
	}
}

func (ptr *QAbstractItemView) ConnectScrollToBottom(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectScrollToBottom() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) ScrollToBottom() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ScrollToBottom(ptr.Pointer())
	}
}

func (ptr *QAbstractItemView) ScrollToBottomDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ScrollToBottomDefault(ptr.Pointer())
	}
}

//export callbackQAbstractItemView_ScrollToTop
func callbackQAbstractItemView_ScrollToTop(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "scrollToTop"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemViewFromPointer(ptr).ScrollToTopDefault()
	}
}

func (ptr *QAbstractItemView) ConnectScrollToTop(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectScrollToTop() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) ScrollToTop() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ScrollToTop(ptr.Pointer())
	}
}

func (ptr *QAbstractItemView) ScrollToTopDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ScrollToTopDefault(ptr.Pointer())
	}
}

//export callbackQAbstractItemView_SelectAll
func callbackQAbstractItemView_SelectAll(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectAll"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemViewFromPointer(ptr).SelectAllDefault()
	}
}

func (ptr *QAbstractItemView) ConnectSelectAll(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSelectAll() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SelectAll() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SelectAll(ptr.Pointer())
	}
}

func (ptr *QAbstractItemView) SelectAllDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SelectAllDefault(ptr.Pointer())
	}
}

//export callbackQAbstractItemView_SelectionChanged
func callbackQAbstractItemView_SelectionChanged(ptr unsafe.Pointer, selected unsafe.Pointer, deselected unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
		(*(*func(*core.QItemSelection, *core.QItemSelection))(signal))(core.NewQItemSelectionFromPointer(selected), core.NewQItemSelectionFromPointer(deselected))
	} else {
		NewQAbstractItemViewFromPointer(ptr).SelectionChangedDefault(core.NewQItemSelectionFromPointer(selected), core.NewQItemSelectionFromPointer(deselected))
	}
}

func (ptr *QAbstractItemView) ConnectSelectionChanged(f func(selected *core.QItemSelection, deselected *core.QItemSelection)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SelectionChanged(selected core.QItemSelection_ITF, deselected core.QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SelectionChanged(ptr.Pointer(), core.PointerFromQItemSelection(selected), core.PointerFromQItemSelection(deselected))
	}
}

func (ptr *QAbstractItemView) SelectionChangedDefault(selected core.QItemSelection_ITF, deselected core.QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SelectionChangedDefault(ptr.Pointer(), core.PointerFromQItemSelection(selected), core.PointerFromQItemSelection(deselected))
	}
}

func (ptr *QAbstractItemView) SetAlternatingRowColors(enable bool) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetAlternatingRowColors(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QAbstractItemView) SetAutoScroll(enable bool) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetAutoScroll(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QAbstractItemView) SetAutoScrollMargin(margin int) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetAutoScrollMargin(ptr.Pointer(), C.int(int32(margin)))
	}
}

//export callbackQAbstractItemView_SetCurrentIndex
func callbackQAbstractItemView_SetCurrentIndex(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQAbstractItemViewFromPointer(ptr).SetCurrentIndexDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QAbstractItemView) ConnectSetCurrentIndex(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSetCurrentIndex() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SetCurrentIndex(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetCurrentIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemView) SetCurrentIndexDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetCurrentIndexDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemView) SetDefaultDropAction(dropAction core.Qt__DropAction) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetDefaultDropAction(ptr.Pointer(), C.longlong(dropAction))
	}
}

func (ptr *QAbstractItemView) SetDirtyRegion(region gui.QRegion_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetDirtyRegion(ptr.Pointer(), gui.PointerFromQRegion(region))
	}
}

func (ptr *QAbstractItemView) SetDragDropMode(behavior QAbstractItemView__DragDropMode) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetDragDropMode(ptr.Pointer(), C.longlong(behavior))
	}
}

func (ptr *QAbstractItemView) SetDragDropOverwriteMode(overwrite bool) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetDragDropOverwriteMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(overwrite))))
	}
}

func (ptr *QAbstractItemView) SetDragEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetDragEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QAbstractItemView) SetDropIndicatorShown(enable bool) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetDropIndicatorShown(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QAbstractItemView) SetEditTriggers(triggers QAbstractItemView__EditTrigger) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetEditTriggers(ptr.Pointer(), C.longlong(triggers))
	}
}

func (ptr *QAbstractItemView) SetHorizontalScrollMode(mode QAbstractItemView__ScrollMode) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetHorizontalScrollMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QAbstractItemView) SetIconSize(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetIconSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QAbstractItemView) SetIndexWidget(index core.QModelIndex_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetIndexWidget(ptr.Pointer(), core.PointerFromQModelIndex(index), PointerFromQWidget(widget))
	}
}

func (ptr *QAbstractItemView) SetItemDelegate(delegate QAbstractItemDelegate_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetItemDelegate(ptr.Pointer(), PointerFromQAbstractItemDelegate(delegate))
	}
}

func (ptr *QAbstractItemView) SetItemDelegateForColumn(column int, delegate QAbstractItemDelegate_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetItemDelegateForColumn(ptr.Pointer(), C.int(int32(column)), PointerFromQAbstractItemDelegate(delegate))
	}
}

func (ptr *QAbstractItemView) SetItemDelegateForRow(row int, delegate QAbstractItemDelegate_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetItemDelegateForRow(ptr.Pointer(), C.int(int32(row)), PointerFromQAbstractItemDelegate(delegate))
	}
}

//export callbackQAbstractItemView_SetModel
func callbackQAbstractItemView_SetModel(ptr unsafe.Pointer, model unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setModel"); signal != nil {
		(*(*func(*core.QAbstractItemModel))(signal))(core.NewQAbstractItemModelFromPointer(model))
	} else {
		NewQAbstractItemViewFromPointer(ptr).SetModelDefault(core.NewQAbstractItemModelFromPointer(model))
	}
}

func (ptr *QAbstractItemView) ConnectSetModel(f func(model *core.QAbstractItemModel)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSetModel() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SetModel(model core.QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetModel(ptr.Pointer(), core.PointerFromQAbstractItemModel(model))
	}
}

func (ptr *QAbstractItemView) SetModelDefault(model core.QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetModelDefault(ptr.Pointer(), core.PointerFromQAbstractItemModel(model))
	}
}

//export callbackQAbstractItemView_SetRootIndex
func callbackQAbstractItemView_SetRootIndex(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setRootIndex"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQAbstractItemViewFromPointer(ptr).SetRootIndexDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QAbstractItemView) ConnectSetRootIndex(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSetRootIndex() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SetRootIndex(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetRootIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemView) SetRootIndexDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetRootIndexDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemView_SetSelection
func callbackQAbstractItemView_SetSelection(ptr unsafe.Pointer, rect unsafe.Pointer, flags C.longlong) {
	if signal := qt.GetSignal(ptr, "setSelection"); signal != nil {
		(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(flags))
	}

}

func (ptr *QAbstractItemView) ConnectSetSelection(f func(rect *core.QRect, flags core.QItemSelectionModel__SelectionFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setSelection"); signal != nil {
			f := func(rect *core.QRect, flags core.QItemSelectionModel__SelectionFlag) {
				(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(rect, flags)
				f(rect, flags)
			}
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemView) DisconnectSetSelection() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SetSelection(rect core.QRect_ITF, flags core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetSelection(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(flags))
	}
}

func (ptr *QAbstractItemView) SetSelectionBehavior(behavior QAbstractItemView__SelectionBehavior) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetSelectionBehavior(ptr.Pointer(), C.longlong(behavior))
	}
}

func (ptr *QAbstractItemView) SetSelectionMode(mode QAbstractItemView__SelectionMode) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetSelectionMode(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQAbstractItemView_SetSelectionModel
func callbackQAbstractItemView_SetSelectionModel(ptr unsafe.Pointer, selectionModel unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setSelectionModel"); signal != nil {
		(*(*func(*core.QItemSelectionModel))(signal))(core.NewQItemSelectionModelFromPointer(selectionModel))
	} else {
		NewQAbstractItemViewFromPointer(ptr).SetSelectionModelDefault(core.NewQItemSelectionModelFromPointer(selectionModel))
	}
}

func (ptr *QAbstractItemView) ConnectSetSelectionModel(f func(selectionModel *core.QItemSelectionModel)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSetSelectionModel() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SetSelectionModel(selectionModel core.QItemSelectionModel_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetSelectionModel(ptr.Pointer(), core.PointerFromQItemSelectionModel(selectionModel))
	}
}

func (ptr *QAbstractItemView) SetSelectionModelDefault(selectionModel core.QItemSelectionModel_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetSelectionModelDefault(ptr.Pointer(), core.PointerFromQItemSelectionModel(selectionModel))
	}
}

func (ptr *QAbstractItemView) SetState(state QAbstractItemView__State) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetState(ptr.Pointer(), C.longlong(state))
	}
}

func (ptr *QAbstractItemView) SetTabKeyNavigation(enable bool) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetTabKeyNavigation(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QAbstractItemView) SetTextElideMode(mode core.Qt__TextElideMode) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetTextElideMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QAbstractItemView) SetVerticalScrollMode(mode QAbstractItemView__ScrollMode) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_SetVerticalScrollMode(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQAbstractItemView_StartDrag
func callbackQAbstractItemView_StartDrag(ptr unsafe.Pointer, supportedActions C.longlong) {
	if signal := qt.GetSignal(ptr, "startDrag"); signal != nil {
		(*(*func(core.Qt__DropAction))(signal))(core.Qt__DropAction(supportedActions))
	} else {
		NewQAbstractItemViewFromPointer(ptr).StartDragDefault(core.Qt__DropAction(supportedActions))
	}
}

func (ptr *QAbstractItemView) ConnectStartDrag(f func(supportedActions core.Qt__DropAction)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectStartDrag() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) StartDrag(supportedActions core.Qt__DropAction) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_StartDrag(ptr.Pointer(), C.longlong(supportedActions))
	}
}

func (ptr *QAbstractItemView) StartDragDefault(supportedActions core.Qt__DropAction) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_StartDragDefault(ptr.Pointer(), C.longlong(supportedActions))
	}
}

//export callbackQAbstractItemView_Update
func callbackQAbstractItemView_Update(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "update"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQAbstractItemViewFromPointer(ptr).UpdateDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QAbstractItemView) ConnectUpdate(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

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

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

func (ptr *QAbstractItemView) Update(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_Update(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QAbstractItemView) UpdateDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_UpdateDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQAbstractItemView_UpdateGeometries
func callbackQAbstractItemView_UpdateGeometries(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateGeometries"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemViewFromPointer(ptr).UpdateGeometriesDefault()
	}
}

func (ptr *QAbstractItemView) ConnectUpdateGeometries(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectUpdateGeometries() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) UpdateGeometries() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_UpdateGeometries(ptr.Pointer())
	}
}

func (ptr *QAbstractItemView) UpdateGeometriesDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_UpdateGeometriesDefault(ptr.Pointer())
	}
}

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

}

func (ptr *QAbstractItemView) ConnectViewportEntered(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "viewportEntered") {
			C.QAbstractItemView_ConnectViewportEntered(ptr.Pointer())
		}

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

func (ptr *QAbstractItemView) DisconnectViewportEntered() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DisconnectViewportEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "viewportEntered")
	}
}

func (ptr *QAbstractItemView) ViewportEntered() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_ViewportEntered(ptr.Pointer())
	}
}

//export callbackQAbstractItemView_DestroyQAbstractItemView
func callbackQAbstractItemView_DestroyQAbstractItemView(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractItemView"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractItemViewFromPointer(ptr).DestroyQAbstractItemViewDefault()
	}
}

func (ptr *QAbstractItemView) ConnectDestroyQAbstractItemView(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectDestroyQAbstractItemView() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DestroyQAbstractItemView() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DestroyQAbstractItemView(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractItemView) DestroyQAbstractItemViewDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractItemView_DestroyQAbstractItemViewDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractItemView) ItemDelegate() *QAbstractItemDelegate {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemDelegateFromPointer(C.QAbstractItemView_ItemDelegate(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) ItemDelegate2(index core.QModelIndex_ITF) *QAbstractItemDelegate {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemDelegateFromPointer(C.QAbstractItemView_ItemDelegate2(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) ItemDelegateForColumn(column int) *QAbstractItemDelegate {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemDelegateFromPointer(C.QAbstractItemView_ItemDelegateForColumn(ptr.Pointer(), C.int(int32(column))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) ItemDelegateForRow(row int) *QAbstractItemDelegate {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemDelegateFromPointer(C.QAbstractItemView_ItemDelegateForRow(ptr.Pointer(), C.int(int32(row))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) Model() *core.QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractItemModelFromPointer(C.QAbstractItemView_Model(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) DragDropMode() QAbstractItemView__DragDropMode {
	if ptr.Pointer() != nil {
		return QAbstractItemView__DragDropMode(C.QAbstractItemView_DragDropMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) DropIndicatorPosition() QAbstractItemView__DropIndicatorPosition {
	if ptr.Pointer() != nil {
		return QAbstractItemView__DropIndicatorPosition(C.QAbstractItemView_DropIndicatorPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) EditTriggers() QAbstractItemView__EditTrigger {
	if ptr.Pointer() != nil {
		return QAbstractItemView__EditTrigger(C.QAbstractItemView_EditTriggers(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) HorizontalScrollMode() QAbstractItemView__ScrollMode {
	if ptr.Pointer() != nil {
		return QAbstractItemView__ScrollMode(C.QAbstractItemView_HorizontalScrollMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) VerticalScrollMode() QAbstractItemView__ScrollMode {
	if ptr.Pointer() != nil {
		return QAbstractItemView__ScrollMode(C.QAbstractItemView_VerticalScrollMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) SelectionBehavior() QAbstractItemView__SelectionBehavior {
	if ptr.Pointer() != nil {
		return QAbstractItemView__SelectionBehavior(C.QAbstractItemView_SelectionBehavior(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) SelectionMode() QAbstractItemView__SelectionMode {
	if ptr.Pointer() != nil {
		return QAbstractItemView__SelectionMode(C.QAbstractItemView_SelectionMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) State() QAbstractItemView__State {
	if ptr.Pointer() != nil {
		return QAbstractItemView__State(C.QAbstractItemView_State(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) SelectionModel() *core.QItemSelectionModel {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQItemSelectionModelFromPointer(C.QAbstractItemView_SelectionModel(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemView_SelectionCommand
func callbackQAbstractItemView_SelectionCommand(ptr unsafe.Pointer, index unsafe.Pointer, event unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "selectionCommand"); signal != nil {
		return C.longlong((*(*func(*core.QModelIndex, *core.QEvent) core.QItemSelectionModel__SelectionFlag)(signal))(core.NewQModelIndexFromPointer(index), core.NewQEventFromPointer(event)))
	}

	return C.longlong(NewQAbstractItemViewFromPointer(ptr).SelectionCommandDefault(core.NewQModelIndexFromPointer(index), core.NewQEventFromPointer(event)))
}

func (ptr *QAbstractItemView) ConnectSelectionCommand(f func(index *core.QModelIndex, event *core.QEvent) core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSelectionCommand() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SelectionCommand(index core.QModelIndex_ITF, event core.QEvent_ITF) core.QItemSelectionModel__SelectionFlag {
	if ptr.Pointer() != nil {
		return core.QItemSelectionModel__SelectionFlag(C.QAbstractItemView_SelectionCommand(ptr.Pointer(), core.PointerFromQModelIndex(index), core.PointerFromQEvent(event)))
	}
	return 0
}

func (ptr *QAbstractItemView) SelectionCommandDefault(index core.QModelIndex_ITF, event core.QEvent_ITF) core.QItemSelectionModel__SelectionFlag {
	if ptr.Pointer() != nil {
		return core.QItemSelectionModel__SelectionFlag(C.QAbstractItemView_SelectionCommandDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), core.PointerFromQEvent(event)))
	}
	return 0
}

func (ptr *QAbstractItemView) CurrentIndex() *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QAbstractItemView_CurrentIndex(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemView_IndexAt
func callbackQAbstractItemView_IndexAt(ptr unsafe.Pointer, point unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "indexAt"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QPoint) *core.QModelIndex)(signal))(core.NewQPointFromPointer(point)))
	}

	return core.PointerFromQModelIndex(core.NewQModelIndex())
}

func (ptr *QAbstractItemView) ConnectIndexAt(f func(point *core.QPoint) *core.QModelIndex) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectIndexAt() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) IndexAt(point core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QAbstractItemView_IndexAt(ptr.Pointer(), core.PointerFromQPoint(point)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) RootIndex() *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QAbstractItemView_RootIndex(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemView_SelectedIndexes
func callbackQAbstractItemView_SelectedIndexes(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "selectedIndexes"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQAbstractItemViewFromPointer(NewQAbstractItemViewFromPointer(nil).__selectedIndexes_newList())
			for _, v := range (*(*func() []*core.QModelIndex)(signal))() {
				tmpList.__selectedIndexes_setList(v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQAbstractItemViewFromPointer(NewQAbstractItemViewFromPointer(nil).__selectedIndexes_newList())
		for _, v := range NewQAbstractItemViewFromPointer(ptr).SelectedIndexesDefault() {
			tmpList.__selectedIndexes_setList(v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QAbstractItemView) ConnectSelectedIndexes(f func() []*core.QModelIndex) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSelectedIndexes() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SelectedIndexes() []*core.QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
			out := make([]*core.QModelIndex, int(l.len))
			tmpList := NewQAbstractItemViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedIndexes_atList(i)
			}
			return out
		}(C.QAbstractItemView_SelectedIndexes(ptr.Pointer()))
	}
	return make([]*core.QModelIndex, 0)
}

func (ptr *QAbstractItemView) SelectedIndexesDefault() []*core.QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
			out := make([]*core.QModelIndex, int(l.len))
			tmpList := NewQAbstractItemViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedIndexes_atList(i)
			}
			return out
		}(C.QAbstractItemView_SelectedIndexesDefault(ptr.Pointer()))
	}
	return make([]*core.QModelIndex, 0)
}

func (ptr *QAbstractItemView) DirtyRegionOffset() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QAbstractItemView_DirtyRegionOffset(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemView_VisualRect
func callbackQAbstractItemView_VisualRect(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRect"); signal != nil {
		return core.PointerFromQRect((*(*func(*core.QModelIndex) *core.QRect)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQRect(core.NewQRect())
}

func (ptr *QAbstractItemView) ConnectVisualRect(f func(index *core.QModelIndex) *core.QRect) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectVisualRect() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) VisualRect(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QAbstractItemView_VisualRect(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemView_VisualRegionForSelection
func callbackQAbstractItemView_VisualRegionForSelection(ptr unsafe.Pointer, selection unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRegionForSelection"); signal != nil {
		return gui.PointerFromQRegion((*(*func(*core.QItemSelection) *gui.QRegion)(signal))(core.NewQItemSelectionFromPointer(selection)))
	}

	return gui.PointerFromQRegion(gui.NewQRegion())
}

func (ptr *QAbstractItemView) ConnectVisualRegionForSelection(f func(selection *core.QItemSelection) *gui.QRegion) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "visualRegionForSelection"); signal != nil {
			f := func(selection *core.QItemSelection) *gui.QRegion {
				(*(*func(*core.QItemSelection) *gui.QRegion)(signal))(selection)
				return f(selection)
			}
			qt.ConnectSignal(ptr.Pointer(), "visualRegionForSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "visualRegionForSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractItemView) DisconnectVisualRegionForSelection() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) VisualRegionForSelection(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QAbstractItemView_VisualRegionForSelection(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QAbstractItemView_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) SizeHintForIndex(index core.QModelIndex_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QAbstractItemView_SizeHintForIndex(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractItemView_ViewOptions
func callbackQAbstractItemView_ViewOptions(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "viewOptions"); signal != nil {
		return PointerFromQStyleOptionViewItem((*(*func() *QStyleOptionViewItem)(signal))())
	}

	return PointerFromQStyleOptionViewItem(NewQAbstractItemViewFromPointer(ptr).ViewOptionsDefault())
}

func (ptr *QAbstractItemView) ConnectViewOptions(f func() *QStyleOptionViewItem) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectViewOptions() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) ViewOptions() *QStyleOptionViewItem {
	if ptr.Pointer() != nil {
		tmpValue := NewQStyleOptionViewItemFromPointer(C.QAbstractItemView_ViewOptions(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStyleOptionViewItem).DestroyQStyleOptionViewItem)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) ViewOptionsDefault() *QStyleOptionViewItem {
	if ptr.Pointer() != nil {
		tmpValue := NewQStyleOptionViewItemFromPointer(C.QAbstractItemView_ViewOptionsDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QStyleOptionViewItem).DestroyQStyleOptionViewItem)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) IndexWidget(index core.QModelIndex_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QAbstractItemView_IndexWidget(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) DefaultDropAction() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QAbstractItemView_DefaultDropAction(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) TextElideMode() core.Qt__TextElideMode {
	if ptr.Pointer() != nil {
		return core.Qt__TextElideMode(C.QAbstractItemView_TextElideMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractItemView) AlternatingRowColors() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_AlternatingRowColors(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractItemView) DragDropOverwriteMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_DragDropOverwriteMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractItemView) DragEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_DragEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractItemView) HasAutoScroll() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_HasAutoScroll(ptr.Pointer())) != 0
	}
	return false
}

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

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

func (ptr *QAbstractItemView) ConnectIsIndexHidden(f func(index *core.QModelIndex) bool) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectIsIndexHidden() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) IsIndexHidden(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_IsIndexHidden(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QAbstractItemView) IsPersistentEditorOpen(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_IsPersistentEditorOpen(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QAbstractItemView) ShowDropIndicator() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_ShowDropIndicator(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractItemView) TabKeyNavigation() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractItemView_TabKeyNavigation(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractItemView) AutoScrollMargin() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemView_AutoScrollMargin(ptr.Pointer())))
	}
	return 0
}

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

	return C.int(int32(0))
}

func (ptr *QAbstractItemView) ConnectHorizontalOffset(f func() int) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectHorizontalOffset() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) HorizontalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemView_HorizontalOffset(ptr.Pointer())))
	}
	return 0
}

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

	return C.int(int32(NewQAbstractItemViewFromPointer(ptr).SizeHintForColumnDefault(int(int32(column)))))
}

func (ptr *QAbstractItemView) ConnectSizeHintForColumn(f func(column int) int) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSizeHintForColumn() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SizeHintForColumn(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemView_SizeHintForColumn(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

func (ptr *QAbstractItemView) SizeHintForColumnDefault(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemView_SizeHintForColumnDefault(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

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

	return C.int(int32(NewQAbstractItemViewFromPointer(ptr).SizeHintForRowDefault(int(int32(row)))))
}

func (ptr *QAbstractItemView) ConnectSizeHintForRow(f func(row int) int) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectSizeHintForRow() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) SizeHintForRow(row int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemView_SizeHintForRow(ptr.Pointer(), C.int(int32(row)))))
	}
	return 0
}

func (ptr *QAbstractItemView) SizeHintForRowDefault(row int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemView_SizeHintForRowDefault(ptr.Pointer(), C.int(int32(row)))))
	}
	return 0
}

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

	return C.int(int32(0))
}

func (ptr *QAbstractItemView) ConnectVerticalOffset(f func() int) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) DisconnectVerticalOffset() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractItemView) VerticalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractItemView_VerticalOffset(ptr.Pointer())))
	}
	return 0
}

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

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

func (ptr *QAbstractItemView) __dataChanged_roles_newList() unsafe.Pointer {
	return C.QAbstractItemView___dataChanged_roles_newList(ptr.Pointer())
}

func (ptr *QAbstractItemView) __selectedIndexes_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QAbstractItemView___selectedIndexes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractItemView) __selectedIndexes_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractItemView___selectedIndexes_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QAbstractItemView) __selectedIndexes_newList() unsafe.Pointer {
	return C.QAbstractItemView___selectedIndexes_newList(ptr.Pointer())
}

type QAbstractScrollArea struct {
	QFrame
}

type QAbstractScrollArea_ITF interface {
	QFrame_ITF
	QAbstractScrollArea_PTR() *QAbstractScrollArea
}

func (ptr *QAbstractScrollArea) QAbstractScrollArea_PTR() *QAbstractScrollArea {
	return ptr
}

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

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

func PointerFromQAbstractScrollArea(ptr QAbstractScrollArea_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractScrollArea_PTR().Pointer()
	}
	return nil
}

func NewQAbstractScrollAreaFromPointer(ptr unsafe.Pointer) (n *QAbstractScrollArea) {
	n = new(QAbstractScrollArea)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QAbstractScrollArea__SizeAdjustPolicy
//QAbstractScrollArea::SizeAdjustPolicy
type QAbstractScrollArea__SizeAdjustPolicy int64

const (
	QAbstractScrollArea__AdjustIgnored               QAbstractScrollArea__SizeAdjustPolicy = QAbstractScrollArea__SizeAdjustPolicy(0)
	QAbstractScrollArea__AdjustToContentsOnFirstShow QAbstractScrollArea__SizeAdjustPolicy = QAbstractScrollArea__SizeAdjustPolicy(1)
	QAbstractScrollArea__AdjustToContents            QAbstractScrollArea__SizeAdjustPolicy = QAbstractScrollArea__SizeAdjustPolicy(2)
)

func NewQAbstractScrollArea(parent QWidget_ITF) *QAbstractScrollArea {
	tmpValue := NewQAbstractScrollAreaFromPointer(C.QAbstractScrollArea_NewQAbstractScrollArea(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QAbstractScrollArea) ScrollBarWidgets(alignment core.Qt__AlignmentFlag) []*QWidget {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QWidget {
			out := make([]*QWidget, int(l.len))
			tmpList := NewQAbstractScrollAreaFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__scrollBarWidgets_atList(i)
			}
			return out
		}(C.QAbstractScrollArea_ScrollBarWidgets(ptr.Pointer(), C.longlong(alignment)))
	}
	return make([]*QWidget, 0)
}

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

	return C.char(int8(qt.GoBoolToInt(NewQAbstractScrollAreaFromPointer(ptr).ViewportEventDefault(core.NewQEventFromPointer(event)))))
}

func (ptr *QAbstractScrollArea) ConnectViewportEvent(f func(event *core.QEvent) bool) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) DisconnectViewportEvent() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) ViewportEvent(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractScrollArea_ViewportEvent(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QAbstractScrollArea) ViewportEventDefault(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractScrollArea_ViewportEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QAbstractScrollArea) AddScrollBarWidget(widget QWidget_ITF, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_AddScrollBarWidget(ptr.Pointer(), PointerFromQWidget(widget), C.longlong(alignment))
	}
}

//export callbackQAbstractScrollArea_ScrollContentsBy
func callbackQAbstractScrollArea_ScrollContentsBy(ptr unsafe.Pointer, dx C.int, dy C.int) {
	if signal := qt.GetSignal(ptr, "scrollContentsBy"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(dx)), int(int32(dy)))
	} else {
		NewQAbstractScrollAreaFromPointer(ptr).ScrollContentsByDefault(int(int32(dx)), int(int32(dy)))
	}
}

func (ptr *QAbstractScrollArea) ConnectScrollContentsBy(f func(dx int, dy int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) DisconnectScrollContentsBy() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) ScrollContentsBy(dx int, dy int) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_ScrollContentsBy(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy)))
	}
}

func (ptr *QAbstractScrollArea) ScrollContentsByDefault(dx int, dy int) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_ScrollContentsByDefault(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy)))
	}
}

func (ptr *QAbstractScrollArea) SetCornerWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetCornerWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QAbstractScrollArea) SetHorizontalScrollBar(scrollBar QScrollBar_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetHorizontalScrollBar(ptr.Pointer(), PointerFromQScrollBar(scrollBar))
	}
}

func (ptr *QAbstractScrollArea) SetHorizontalScrollBarPolicy(vqt core.Qt__ScrollBarPolicy) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetHorizontalScrollBarPolicy(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QAbstractScrollArea) SetSizeAdjustPolicy(policy QAbstractScrollArea__SizeAdjustPolicy) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetSizeAdjustPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QAbstractScrollArea) SetVerticalScrollBar(scrollBar QScrollBar_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetVerticalScrollBar(ptr.Pointer(), PointerFromQScrollBar(scrollBar))
	}
}

func (ptr *QAbstractScrollArea) SetVerticalScrollBarPolicy(vqt core.Qt__ScrollBarPolicy) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetVerticalScrollBarPolicy(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QAbstractScrollArea) SetViewport(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetViewport(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QAbstractScrollArea) SetViewportMargins2(margins core.QMargins_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetViewportMargins2(ptr.Pointer(), core.PointerFromQMargins(margins))
	}
}

func (ptr *QAbstractScrollArea) SetViewportMargins(left int, top int, right int, bottom int) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetViewportMargins(ptr.Pointer(), C.int(int32(left)), C.int(int32(top)), C.int(int32(right)), C.int(int32(bottom)))
	}
}

//export callbackQAbstractScrollArea_SetupViewport
func callbackQAbstractScrollArea_SetupViewport(ptr unsafe.Pointer, viewport unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setupViewport"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(viewport))
	} else {
		NewQAbstractScrollAreaFromPointer(ptr).SetupViewportDefault(NewQWidgetFromPointer(viewport))
	}
}

func (ptr *QAbstractScrollArea) ConnectSetupViewport(f func(viewport *QWidget)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) DisconnectSetupViewport() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) SetupViewport(viewport QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetupViewport(ptr.Pointer(), PointerFromQWidget(viewport))
	}
}

func (ptr *QAbstractScrollArea) SetupViewportDefault(viewport QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_SetupViewportDefault(ptr.Pointer(), PointerFromQWidget(viewport))
	}
}

//export callbackQAbstractScrollArea_DestroyQAbstractScrollArea
func callbackQAbstractScrollArea_DestroyQAbstractScrollArea(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractScrollArea"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractScrollAreaFromPointer(ptr).DestroyQAbstractScrollAreaDefault()
	}
}

func (ptr *QAbstractScrollArea) ConnectDestroyQAbstractScrollArea(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) DisconnectDestroyQAbstractScrollArea() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) DestroyQAbstractScrollArea() {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_DestroyQAbstractScrollArea(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractScrollArea) DestroyQAbstractScrollAreaDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea_DestroyQAbstractScrollAreaDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractScrollArea) SizeAdjustPolicy() QAbstractScrollArea__SizeAdjustPolicy {
	if ptr.Pointer() != nil {
		return QAbstractScrollArea__SizeAdjustPolicy(C.QAbstractScrollArea_SizeAdjustPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractScrollArea) ViewportMargins() *core.QMargins {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMarginsFromPointer(C.QAbstractScrollArea_ViewportMargins(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QMargins).DestroyQMargins)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractScrollArea) HorizontalScrollBar() *QScrollBar {
	if ptr.Pointer() != nil {
		tmpValue := NewQScrollBarFromPointer(C.QAbstractScrollArea_HorizontalScrollBar(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractScrollArea) VerticalScrollBar() *QScrollBar {
	if ptr.Pointer() != nil {
		tmpValue := NewQScrollBarFromPointer(C.QAbstractScrollArea_VerticalScrollBar(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractScrollArea) MaximumViewportSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QAbstractScrollArea_MaximumViewportSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQAbstractScrollArea_ViewportSizeHint
func callbackQAbstractScrollArea_ViewportSizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "viewportSizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQAbstractScrollAreaFromPointer(ptr).ViewportSizeHintDefault())
}

func (ptr *QAbstractScrollArea) ConnectViewportSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) DisconnectViewportSizeHint() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractScrollArea) ViewportSizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QAbstractScrollArea_ViewportSizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractScrollArea) ViewportSizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QAbstractScrollArea_ViewportSizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractScrollArea) CornerWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QAbstractScrollArea_CornerWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractScrollArea) Viewport() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QAbstractScrollArea_Viewport(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractScrollArea) HorizontalScrollBarPolicy() core.Qt__ScrollBarPolicy {
	if ptr.Pointer() != nil {
		return core.Qt__ScrollBarPolicy(C.QAbstractScrollArea_HorizontalScrollBarPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractScrollArea) VerticalScrollBarPolicy() core.Qt__ScrollBarPolicy {
	if ptr.Pointer() != nil {
		return core.Qt__ScrollBarPolicy(C.QAbstractScrollArea_VerticalScrollBarPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractScrollArea) __scrollBarWidgets_atList(i int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QAbstractScrollArea___scrollBarWidgets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractScrollArea) __scrollBarWidgets_setList(i QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractScrollArea___scrollBarWidgets_setList(ptr.Pointer(), PointerFromQWidget(i))
	}
}

func (ptr *QAbstractScrollArea) __scrollBarWidgets_newList() unsafe.Pointer {
	return C.QAbstractScrollArea___scrollBarWidgets_newList(ptr.Pointer())
}

type QAbstractSlider struct {
	QWidget
}

type QAbstractSlider_ITF interface {
	QWidget_ITF
	QAbstractSlider_PTR() *QAbstractSlider
}

func (ptr *QAbstractSlider) QAbstractSlider_PTR() *QAbstractSlider {
	return ptr
}

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

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

func PointerFromQAbstractSlider(ptr QAbstractSlider_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractSlider_PTR().Pointer()
	}
	return nil
}

func NewQAbstractSliderFromPointer(ptr unsafe.Pointer) (n *QAbstractSlider) {
	n = new(QAbstractSlider)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QAbstractSlider__SliderAction
//QAbstractSlider::SliderAction
type QAbstractSlider__SliderAction int64

const (
	QAbstractSlider__SliderNoAction      QAbstractSlider__SliderAction = QAbstractSlider__SliderAction(0)
	QAbstractSlider__SliderSingleStepAdd QAbstractSlider__SliderAction = QAbstractSlider__SliderAction(1)
	QAbstractSlider__SliderSingleStepSub QAbstractSlider__SliderAction = QAbstractSlider__SliderAction(2)
	QAbstractSlider__SliderPageStepAdd   QAbstractSlider__SliderAction = QAbstractSlider__SliderAction(3)
	QAbstractSlider__SliderPageStepSub   QAbstractSlider__SliderAction = QAbstractSlider__SliderAction(4)
	QAbstractSlider__SliderToMinimum     QAbstractSlider__SliderAction = QAbstractSlider__SliderAction(5)
	QAbstractSlider__SliderToMaximum     QAbstractSlider__SliderAction = QAbstractSlider__SliderAction(6)
	QAbstractSlider__SliderMove          QAbstractSlider__SliderAction = QAbstractSlider__SliderAction(7)
)

//go:generate stringer -type=QAbstractSlider__SliderChange
//QAbstractSlider::SliderChange
type QAbstractSlider__SliderChange int64

const (
	QAbstractSlider__SliderRangeChange       QAbstractSlider__SliderChange = QAbstractSlider__SliderChange(0)
	QAbstractSlider__SliderOrientationChange QAbstractSlider__SliderChange = QAbstractSlider__SliderChange(1)
	QAbstractSlider__SliderStepsChange       QAbstractSlider__SliderChange = QAbstractSlider__SliderChange(2)
	QAbstractSlider__SliderValueChange       QAbstractSlider__SliderChange = QAbstractSlider__SliderChange(3)
)

func NewQAbstractSlider(parent QWidget_ITF) *QAbstractSlider {
	tmpValue := NewQAbstractSliderFromPointer(C.QAbstractSlider_NewQAbstractSlider(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

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

}

func (ptr *QAbstractSlider) ConnectActionTriggered(f func(action int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "actionTriggered") {
			C.QAbstractSlider_ConnectActionTriggered(ptr.Pointer())
		}

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

func (ptr *QAbstractSlider) DisconnectActionTriggered() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_DisconnectActionTriggered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "actionTriggered")
	}
}

func (ptr *QAbstractSlider) ActionTriggered(action int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_ActionTriggered(ptr.Pointer(), C.int(int32(action)))
	}
}

//export callbackQAbstractSlider_RangeChanged
func callbackQAbstractSlider_RangeChanged(ptr unsafe.Pointer, min C.int, max C.int) {
	if signal := qt.GetSignal(ptr, "rangeChanged"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(min)), int(int32(max)))
	}

}

func (ptr *QAbstractSlider) ConnectRangeChanged(f func(min int, max int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rangeChanged") {
			C.QAbstractSlider_ConnectRangeChanged(ptr.Pointer())
		}

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

func (ptr *QAbstractSlider) DisconnectRangeChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_DisconnectRangeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rangeChanged")
	}
}

func (ptr *QAbstractSlider) RangeChanged(min int, max int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_RangeChanged(ptr.Pointer(), C.int(int32(min)), C.int(int32(max)))
	}
}

func (ptr *QAbstractSlider) SetInvertedAppearance(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetInvertedAppearance(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAbstractSlider) SetInvertedControls(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetInvertedControls(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAbstractSlider) SetMaximum(vin int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetMaximum(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QAbstractSlider) SetMinimum(vin int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetMinimum(ptr.Pointer(), C.int(int32(vin)))
	}
}

//export callbackQAbstractSlider_SetOrientation
func callbackQAbstractSlider_SetOrientation(ptr unsafe.Pointer, vqt C.longlong) {
	if signal := qt.GetSignal(ptr, "setOrientation"); signal != nil {
		(*(*func(core.Qt__Orientation))(signal))(core.Qt__Orientation(vqt))
	} else {
		NewQAbstractSliderFromPointer(ptr).SetOrientationDefault(core.Qt__Orientation(vqt))
	}
}

func (ptr *QAbstractSlider) ConnectSetOrientation(f func(vqt core.Qt__Orientation)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) DisconnectSetOrientation() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) SetOrientation(vqt core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetOrientation(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QAbstractSlider) SetOrientationDefault(vqt core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetOrientationDefault(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QAbstractSlider) SetPageStep(vin int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetPageStep(ptr.Pointer(), C.int(int32(vin)))
	}
}

//export callbackQAbstractSlider_SetRange
func callbackQAbstractSlider_SetRange(ptr unsafe.Pointer, min C.int, max C.int) {
	if signal := qt.GetSignal(ptr, "setRange"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(min)), int(int32(max)))
	} else {
		NewQAbstractSliderFromPointer(ptr).SetRangeDefault(int(int32(min)), int(int32(max)))
	}
}

func (ptr *QAbstractSlider) ConnectSetRange(f func(min int, max int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) DisconnectSetRange() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) SetRange(min int, max int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetRange(ptr.Pointer(), C.int(int32(min)), C.int(int32(max)))
	}
}

func (ptr *QAbstractSlider) SetRangeDefault(min int, max int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetRangeDefault(ptr.Pointer(), C.int(int32(min)), C.int(int32(max)))
	}
}

func (ptr *QAbstractSlider) SetRepeatAction(action QAbstractSlider__SliderAction, thresholdTime int, repeatTime int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetRepeatAction(ptr.Pointer(), C.longlong(action), C.int(int32(thresholdTime)), C.int(int32(repeatTime)))
	}
}

func (ptr *QAbstractSlider) SetSingleStep(vin int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetSingleStep(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QAbstractSlider) SetSliderDown(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetSliderDown(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAbstractSlider) SetSliderPosition(vin int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetSliderPosition(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QAbstractSlider) SetTracking(enable bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetTracking(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQAbstractSlider_SetValue
func callbackQAbstractSlider_SetValue(ptr unsafe.Pointer, vin C.int) {
	if signal := qt.GetSignal(ptr, "setValue"); signal != nil {
		(*(*func(int))(signal))(int(int32(vin)))
	} else {
		NewQAbstractSliderFromPointer(ptr).SetValueDefault(int(int32(vin)))
	}
}

func (ptr *QAbstractSlider) ConnectSetValue(f func(vin int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) DisconnectSetValue() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) SetValue(vin int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetValue(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QAbstractSlider) SetValueDefault(vin int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SetValueDefault(ptr.Pointer(), C.int(int32(vin)))
	}
}

//export callbackQAbstractSlider_SliderChange
func callbackQAbstractSlider_SliderChange(ptr unsafe.Pointer, change C.longlong) {
	if signal := qt.GetSignal(ptr, "sliderChange"); signal != nil {
		(*(*func(QAbstractSlider__SliderChange))(signal))(QAbstractSlider__SliderChange(change))
	} else {
		NewQAbstractSliderFromPointer(ptr).SliderChangeDefault(QAbstractSlider__SliderChange(change))
	}
}

func (ptr *QAbstractSlider) ConnectSliderChange(f func(change QAbstractSlider__SliderChange)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) DisconnectSliderChange() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) SliderChange(change QAbstractSlider__SliderChange) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SliderChange(ptr.Pointer(), C.longlong(change))
	}
}

func (ptr *QAbstractSlider) SliderChangeDefault(change QAbstractSlider__SliderChange) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SliderChangeDefault(ptr.Pointer(), C.longlong(change))
	}
}

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

}

func (ptr *QAbstractSlider) ConnectSliderMoved(f func(value int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sliderMoved") {
			C.QAbstractSlider_ConnectSliderMoved(ptr.Pointer())
		}

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

func (ptr *QAbstractSlider) DisconnectSliderMoved() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_DisconnectSliderMoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sliderMoved")
	}
}

func (ptr *QAbstractSlider) SliderMoved(value int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SliderMoved(ptr.Pointer(), C.int(int32(value)))
	}
}

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

}

func (ptr *QAbstractSlider) ConnectSliderPressed(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sliderPressed") {
			C.QAbstractSlider_ConnectSliderPressed(ptr.Pointer())
		}

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

func (ptr *QAbstractSlider) DisconnectSliderPressed() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_DisconnectSliderPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sliderPressed")
	}
}

func (ptr *QAbstractSlider) SliderPressed() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SliderPressed(ptr.Pointer())
	}
}

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

}

func (ptr *QAbstractSlider) ConnectSliderReleased(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sliderReleased") {
			C.QAbstractSlider_ConnectSliderReleased(ptr.Pointer())
		}

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

func (ptr *QAbstractSlider) DisconnectSliderReleased() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_DisconnectSliderReleased(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sliderReleased")
	}
}

func (ptr *QAbstractSlider) SliderReleased() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_SliderReleased(ptr.Pointer())
	}
}

func (ptr *QAbstractSlider) TriggerAction(action QAbstractSlider__SliderAction) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_TriggerAction(ptr.Pointer(), C.longlong(action))
	}
}

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

}

func (ptr *QAbstractSlider) ConnectValueChanged(f func(value int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "valueChanged") {
			C.QAbstractSlider_ConnectValueChanged(ptr.Pointer())
		}

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

func (ptr *QAbstractSlider) DisconnectValueChanged() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_DisconnectValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "valueChanged")
	}
}

func (ptr *QAbstractSlider) ValueChanged(value int) {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_ValueChanged(ptr.Pointer(), C.int(int32(value)))
	}
}

//export callbackQAbstractSlider_DestroyQAbstractSlider
func callbackQAbstractSlider_DestroyQAbstractSlider(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractSlider"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractSliderFromPointer(ptr).DestroyQAbstractSliderDefault()
	}
}

func (ptr *QAbstractSlider) ConnectDestroyQAbstractSlider(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) DisconnectDestroyQAbstractSlider() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSlider) DestroyQAbstractSlider() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_DestroyQAbstractSlider(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractSlider) DestroyQAbstractSliderDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractSlider_DestroyQAbstractSliderDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractSlider) RepeatAction() QAbstractSlider__SliderAction {
	if ptr.Pointer() != nil {
		return QAbstractSlider__SliderAction(C.QAbstractSlider_RepeatAction(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractSlider) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QAbstractSlider_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractSlider) HasTracking() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSlider_HasTracking(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSlider) InvertedAppearance() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSlider_InvertedAppearance(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSlider) InvertedControls() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSlider_InvertedControls(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSlider) IsSliderDown() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSlider_IsSliderDown(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSlider) Maximum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractSlider_Maximum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAbstractSlider) Minimum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractSlider_Minimum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAbstractSlider) PageStep() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractSlider_PageStep(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAbstractSlider) SingleStep() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractSlider_SingleStep(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAbstractSlider) SliderPosition() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractSlider_SliderPosition(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAbstractSlider) Value() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAbstractSlider_Value(ptr.Pointer())))
	}
	return 0
}

type QAbstractSpinBox struct {
	QWidget
}

type QAbstractSpinBox_ITF interface {
	QWidget_ITF
	QAbstractSpinBox_PTR() *QAbstractSpinBox
}

func (ptr *QAbstractSpinBox) QAbstractSpinBox_PTR() *QAbstractSpinBox {
	return ptr
}

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

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

func PointerFromQAbstractSpinBox(ptr QAbstractSpinBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractSpinBox_PTR().Pointer()
	}
	return nil
}

func NewQAbstractSpinBoxFromPointer(ptr unsafe.Pointer) (n *QAbstractSpinBox) {
	n = new(QAbstractSpinBox)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QAbstractSpinBox__ButtonSymbols
//QAbstractSpinBox::ButtonSymbols
type QAbstractSpinBox__ButtonSymbols int64

const (
	QAbstractSpinBox__UpDownArrows QAbstractSpinBox__ButtonSymbols = QAbstractSpinBox__ButtonSymbols(0)
	QAbstractSpinBox__PlusMinus    QAbstractSpinBox__ButtonSymbols = QAbstractSpinBox__ButtonSymbols(1)
	QAbstractSpinBox__NoButtons    QAbstractSpinBox__ButtonSymbols = QAbstractSpinBox__ButtonSymbols(2)
)

//go:generate stringer -type=QAbstractSpinBox__CorrectionMode
//QAbstractSpinBox::CorrectionMode
type QAbstractSpinBox__CorrectionMode int64

const (
	QAbstractSpinBox__CorrectToPreviousValue QAbstractSpinBox__CorrectionMode = QAbstractSpinBox__CorrectionMode(0)
	QAbstractSpinBox__CorrectToNearestValue  QAbstractSpinBox__CorrectionMode = QAbstractSpinBox__CorrectionMode(1)
)

//go:generate stringer -type=QAbstractSpinBox__StepEnabledFlag
//QAbstractSpinBox::StepEnabledFlag
type QAbstractSpinBox__StepEnabledFlag int64

const (
	QAbstractSpinBox__StepNone        QAbstractSpinBox__StepEnabledFlag = QAbstractSpinBox__StepEnabledFlag(0x00)
	QAbstractSpinBox__StepUpEnabled   QAbstractSpinBox__StepEnabledFlag = QAbstractSpinBox__StepEnabledFlag(0x01)
	QAbstractSpinBox__StepDownEnabled QAbstractSpinBox__StepEnabledFlag = QAbstractSpinBox__StepEnabledFlag(0x02)
)

//go:generate stringer -type=QAbstractSpinBox__StepType
//QAbstractSpinBox::StepType
type QAbstractSpinBox__StepType int64

const (
	QAbstractSpinBox__DefaultStepType         QAbstractSpinBox__StepType = QAbstractSpinBox__StepType(0)
	QAbstractSpinBox__AdaptiveDecimalStepType QAbstractSpinBox__StepType = QAbstractSpinBox__StepType(1)
)

func NewQAbstractSpinBox(parent QWidget_ITF) *QAbstractSpinBox {
	tmpValue := NewQAbstractSpinBoxFromPointer(C.QAbstractSpinBox_NewQAbstractSpinBox(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQAbstractSpinBox_Clear
func callbackQAbstractSpinBox_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractSpinBoxFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QAbstractSpinBox) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) DisconnectClear() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) Clear() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_Clear(ptr.Pointer())
	}
}

func (ptr *QAbstractSpinBox) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_ClearDefault(ptr.Pointer())
	}
}

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

}

func (ptr *QAbstractSpinBox) ConnectEditingFinished(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "editingFinished") {
			C.QAbstractSpinBox_ConnectEditingFinished(ptr.Pointer())
		}

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

func (ptr *QAbstractSpinBox) DisconnectEditingFinished() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_DisconnectEditingFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "editingFinished")
	}
}

func (ptr *QAbstractSpinBox) EditingFinished() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_EditingFinished(ptr.Pointer())
	}
}

func (ptr *QAbstractSpinBox) InterpretText() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_InterpretText(ptr.Pointer())
	}
}

//export callbackQAbstractSpinBox_SelectAll
func callbackQAbstractSpinBox_SelectAll(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectAll"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractSpinBoxFromPointer(ptr).SelectAllDefault()
	}
}

func (ptr *QAbstractSpinBox) ConnectSelectAll(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) DisconnectSelectAll() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) SelectAll() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SelectAll(ptr.Pointer())
	}
}

func (ptr *QAbstractSpinBox) SelectAllDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SelectAllDefault(ptr.Pointer())
	}
}

func (ptr *QAbstractSpinBox) SetAccelerated(on bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetAccelerated(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QAbstractSpinBox) SetAlignment(flag core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetAlignment(ptr.Pointer(), C.longlong(flag))
	}
}

func (ptr *QAbstractSpinBox) SetButtonSymbols(bs QAbstractSpinBox__ButtonSymbols) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetButtonSymbols(ptr.Pointer(), C.longlong(bs))
	}
}

func (ptr *QAbstractSpinBox) SetCorrectionMode(cm QAbstractSpinBox__CorrectionMode) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetCorrectionMode(ptr.Pointer(), C.longlong(cm))
	}
}

func (ptr *QAbstractSpinBox) SetFrame(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetFrame(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAbstractSpinBox) SetGroupSeparatorShown(shown bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetGroupSeparatorShown(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(shown))))
	}
}

func (ptr *QAbstractSpinBox) SetKeyboardTracking(kt bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetKeyboardTracking(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(kt))))
	}
}

func (ptr *QAbstractSpinBox) SetLineEdit(lineEdit QLineEdit_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetLineEdit(ptr.Pointer(), PointerFromQLineEdit(lineEdit))
	}
}

func (ptr *QAbstractSpinBox) SetReadOnly(r bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetReadOnly(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(r))))
	}
}

func (ptr *QAbstractSpinBox) SetSpecialValueText(txt string) {
	if ptr.Pointer() != nil {
		var txtC *C.char
		if txt != "" {
			txtC = C.CString(txt)
			defer C.free(unsafe.Pointer(txtC))
		}
		C.QAbstractSpinBox_SetSpecialValueText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: txtC, len: C.longlong(len(txt))})
	}
}

func (ptr *QAbstractSpinBox) SetWrapping(w bool) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_SetWrapping(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(w))))
	}
}

//export callbackQAbstractSpinBox_StepBy
func callbackQAbstractSpinBox_StepBy(ptr unsafe.Pointer, steps C.int) {
	if signal := qt.GetSignal(ptr, "stepBy"); signal != nil {
		(*(*func(int))(signal))(int(int32(steps)))
	} else {
		NewQAbstractSpinBoxFromPointer(ptr).StepByDefault(int(int32(steps)))
	}
}

func (ptr *QAbstractSpinBox) ConnectStepBy(f func(steps int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) DisconnectStepBy() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) StepBy(steps int) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_StepBy(ptr.Pointer(), C.int(int32(steps)))
	}
}

func (ptr *QAbstractSpinBox) StepByDefault(steps int) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_StepByDefault(ptr.Pointer(), C.int(int32(steps)))
	}
}

//export callbackQAbstractSpinBox_StepDown
func callbackQAbstractSpinBox_StepDown(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "stepDown"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractSpinBoxFromPointer(ptr).StepDownDefault()
	}
}

func (ptr *QAbstractSpinBox) ConnectStepDown(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) DisconnectStepDown() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) StepDown() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_StepDown(ptr.Pointer())
	}
}

func (ptr *QAbstractSpinBox) StepDownDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_StepDownDefault(ptr.Pointer())
	}
}

//export callbackQAbstractSpinBox_StepUp
func callbackQAbstractSpinBox_StepUp(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "stepUp"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractSpinBoxFromPointer(ptr).StepUpDefault()
	}
}

func (ptr *QAbstractSpinBox) ConnectStepUp(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) DisconnectStepUp() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) StepUp() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_StepUp(ptr.Pointer())
	}
}

func (ptr *QAbstractSpinBox) StepUpDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_StepUpDefault(ptr.Pointer())
	}
}

//export callbackQAbstractSpinBox_DestroyQAbstractSpinBox
func callbackQAbstractSpinBox_DestroyQAbstractSpinBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAbstractSpinBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAbstractSpinBoxFromPointer(ptr).DestroyQAbstractSpinBoxDefault()
	}
}

func (ptr *QAbstractSpinBox) ConnectDestroyQAbstractSpinBox(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) DisconnectDestroyQAbstractSpinBox() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) DestroyQAbstractSpinBox() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_DestroyQAbstractSpinBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractSpinBox) DestroyQAbstractSpinBoxDefault() {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_DestroyQAbstractSpinBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAbstractSpinBox) ButtonSymbols() QAbstractSpinBox__ButtonSymbols {
	if ptr.Pointer() != nil {
		return QAbstractSpinBox__ButtonSymbols(C.QAbstractSpinBox_ButtonSymbols(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractSpinBox) CorrectionMode() QAbstractSpinBox__CorrectionMode {
	if ptr.Pointer() != nil {
		return QAbstractSpinBox__CorrectionMode(C.QAbstractSpinBox_CorrectionMode(ptr.Pointer()))
	}
	return 0
}

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

	return C.longlong(NewQAbstractSpinBoxFromPointer(ptr).StepEnabledDefault())
}

func (ptr *QAbstractSpinBox) ConnectStepEnabled(f func() QAbstractSpinBox__StepEnabledFlag) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) DisconnectStepEnabled() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) StepEnabled() QAbstractSpinBox__StepEnabledFlag {
	if ptr.Pointer() != nil {
		return QAbstractSpinBox__StepEnabledFlag(C.QAbstractSpinBox_StepEnabled(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractSpinBox) StepEnabledDefault() QAbstractSpinBox__StepEnabledFlag {
	if ptr.Pointer() != nil {
		return QAbstractSpinBox__StepEnabledFlag(C.QAbstractSpinBox_StepEnabledDefault(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractSpinBox) LineEdit() *QLineEdit {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineEditFromPointer(C.QAbstractSpinBox_LineEdit(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAbstractSpinBox) SpecialValueText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAbstractSpinBox_SpecialValueText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QAbstractSpinBox) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAbstractSpinBox_Text(ptr.Pointer()))
	}
	return ""
}

//export callbackQAbstractSpinBox_Validate
func callbackQAbstractSpinBox_Validate(ptr unsafe.Pointer, input C.struct_QtWidgets_PackedString, pos C.int) C.longlong {
	if signal := qt.GetSignal(ptr, "validate"); signal != nil {
		return C.longlong((*(*func(string, int) gui.QValidator__State)(signal))(cGoUnpackString(input), int(int32(pos))))
	}

	return C.longlong(NewQAbstractSpinBoxFromPointer(ptr).ValidateDefault(cGoUnpackString(input), int(int32(pos))))
}

func (ptr *QAbstractSpinBox) ConnectValidate(f func(input string, pos int) gui.QValidator__State) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "validate"); signal != nil {
			f := func(input string, pos int) gui.QValidator__State {
				(*(*func(string, int) gui.QValidator__State)(signal))(input, pos)
				return f(input, pos)
			}
			qt.ConnectSignal(ptr.Pointer(), "validate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "validate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAbstractSpinBox) DisconnectValidate() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) Validate(input string, pos int) gui.QValidator__State {
	if ptr.Pointer() != nil {
		var inputC *C.char
		if input != "" {
			inputC = C.CString(input)
			defer C.free(unsafe.Pointer(inputC))
		}
		return gui.QValidator__State(C.QAbstractSpinBox_Validate(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: inputC, len: C.longlong(len(input))}, C.int(int32(pos))))
	}
	return 0
}

func (ptr *QAbstractSpinBox) ValidateDefault(input string, pos int) gui.QValidator__State {
	if ptr.Pointer() != nil {
		var inputC *C.char
		if input != "" {
			inputC = C.CString(input)
			defer C.free(unsafe.Pointer(inputC))
		}
		return gui.QValidator__State(C.QAbstractSpinBox_ValidateDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: inputC, len: C.longlong(len(input))}, C.int(int32(pos))))
	}
	return 0
}

func (ptr *QAbstractSpinBox) Alignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QAbstractSpinBox_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAbstractSpinBox) HasAcceptableInput() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSpinBox_HasAcceptableInput(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSpinBox) HasFrame() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSpinBox_HasFrame(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSpinBox) IsAccelerated() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSpinBox_IsAccelerated(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSpinBox) IsGroupSeparatorShown() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSpinBox_IsGroupSeparatorShown(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSpinBox) IsReadOnly() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSpinBox_IsReadOnly(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSpinBox) KeyboardTracking() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSpinBox_KeyboardTracking(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAbstractSpinBox) Wrapping() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAbstractSpinBox_Wrapping(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQAbstractSpinBox_Fixup
func callbackQAbstractSpinBox_Fixup(ptr unsafe.Pointer, input C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "fixup"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(input))
	} else {
		NewQAbstractSpinBoxFromPointer(ptr).FixupDefault(cGoUnpackString(input))
	}
}

func (ptr *QAbstractSpinBox) ConnectFixup(f func(input string)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) DisconnectFixup() {
	if ptr.Pointer() != nil {

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

func (ptr *QAbstractSpinBox) Fixup(input string) {
	if ptr.Pointer() != nil {
		var inputC *C.char
		if input != "" {
			inputC = C.CString(input)
			defer C.free(unsafe.Pointer(inputC))
		}
		C.QAbstractSpinBox_Fixup(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: inputC, len: C.longlong(len(input))})
	}
}

func (ptr *QAbstractSpinBox) FixupDefault(input string) {
	if ptr.Pointer() != nil {
		var inputC *C.char
		if input != "" {
			inputC = C.CString(input)
			defer C.free(unsafe.Pointer(inputC))
		}
		C.QAbstractSpinBox_FixupDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: inputC, len: C.longlong(len(input))})
	}
}

func (ptr *QAbstractSpinBox) InitStyleOption(option QStyleOptionSpinBox_ITF) {
	if ptr.Pointer() != nil {
		C.QAbstractSpinBox_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionSpinBox(option))
	}
}

type QAccessibleWidget struct {
	gui.QAccessibleObject
	gui.QAccessibleActionInterface
}

type QAccessibleWidget_ITF interface {
	gui.QAccessibleObject_ITF
	gui.QAccessibleActionInterface_ITF
	QAccessibleWidget_PTR() *QAccessibleWidget
}

func (ptr *QAccessibleWidget) QAccessibleWidget_PTR() *QAccessibleWidget {
	return ptr
}

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

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

func PointerFromQAccessibleWidget(ptr QAccessibleWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleWidget_PTR().Pointer()
	}
	return nil
}

func NewQAccessibleWidgetFromPointer(ptr unsafe.Pointer) (n *QAccessibleWidget) {
	n = new(QAccessibleWidget)
	n.SetPointer(ptr)
	return
}

//export callbackQAccessibleWidget_Interface_cast
func callbackQAccessibleWidget_Interface_cast(ptr unsafe.Pointer, t C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "interface_cast"); signal != nil {
		return (*(*func(gui.QAccessible__InterfaceType) unsafe.Pointer)(signal))(gui.QAccessible__InterfaceType(t))
	}

	return NewQAccessibleWidgetFromPointer(ptr).Interface_castDefault(gui.QAccessible__InterfaceType(t))
}

func (ptr *QAccessibleWidget) ConnectInterface_cast(f func(t gui.QAccessible__InterfaceType) unsafe.Pointer) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectInterface_cast() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) Interface_cast(t gui.QAccessible__InterfaceType) unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QAccessibleWidget_Interface_cast(ptr.Pointer(), C.longlong(t))
	}
	return nil
}

func (ptr *QAccessibleWidget) Interface_castDefault(t gui.QAccessible__InterfaceType) unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QAccessibleWidget_Interface_castDefault(ptr.Pointer(), C.longlong(t))
	}
	return nil
}

func (ptr *QAccessibleWidget) AddControllingSignal(sign string) {
	if ptr.Pointer() != nil {
		var signC *C.char
		if sign != "" {
			signC = C.CString(sign)
			defer C.free(unsafe.Pointer(signC))
		}
		C.QAccessibleWidget_AddControllingSignal(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: signC, len: C.longlong(len(sign))})
	}
}

//export callbackQAccessibleWidget_DoAction
func callbackQAccessibleWidget_DoAction(ptr unsafe.Pointer, actionName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "doAction"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(actionName))
	} else {
		NewQAccessibleWidgetFromPointer(ptr).DoActionDefault(cGoUnpackString(actionName))
	}
}

func (ptr *QAccessibleWidget) ConnectDoAction(f func(actionName string)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectDoAction() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DoAction(actionName string) {
	if ptr.Pointer() != nil {
		var actionNameC *C.char
		if actionName != "" {
			actionNameC = C.CString(actionName)
			defer C.free(unsafe.Pointer(actionNameC))
		}
		C.QAccessibleWidget_DoAction(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: actionNameC, len: C.longlong(len(actionName))})
	}
}

func (ptr *QAccessibleWidget) DoActionDefault(actionName string) {
	if ptr.Pointer() != nil {
		var actionNameC *C.char
		if actionName != "" {
			actionNameC = C.CString(actionName)
			defer C.free(unsafe.Pointer(actionNameC))
		}
		C.QAccessibleWidget_DoActionDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: actionNameC, len: C.longlong(len(actionName))})
	}
}

//export callbackQAccessibleWidget_DestroyQAccessibleWidget
func callbackQAccessibleWidget_DestroyQAccessibleWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAccessibleWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQAccessibleWidgetFromPointer(ptr).DestroyQAccessibleWidgetDefault()
	}
}

func (ptr *QAccessibleWidget) ConnectDestroyQAccessibleWidget(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectDestroyQAccessibleWidget() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DestroyQAccessibleWidget() {
	if ptr.Pointer() != nil {
		C.QAccessibleWidget_DestroyQAccessibleWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAccessibleWidget) DestroyQAccessibleWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QAccessibleWidget_DestroyQAccessibleWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQAccessibleWidget_Role
func callbackQAccessibleWidget_Role(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "role"); signal != nil {
		return C.longlong((*(*func() gui.QAccessible__Role)(signal))())
	}

	return C.longlong(NewQAccessibleWidgetFromPointer(ptr).RoleDefault())
}

func (ptr *QAccessibleWidget) ConnectRole(f func() gui.QAccessible__Role) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectRole() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) Role() gui.QAccessible__Role {
	if ptr.Pointer() != nil {
		return gui.QAccessible__Role(C.QAccessibleWidget_Role(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAccessibleWidget) RoleDefault() gui.QAccessible__Role {
	if ptr.Pointer() != nil {
		return gui.QAccessible__Role(C.QAccessibleWidget_RoleDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQAccessibleWidget_Child
func callbackQAccessibleWidget_Child(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "child"); signal != nil {
		return gui.PointerFromQAccessibleInterface((*(*func(int) *gui.QAccessibleInterface)(signal))(int(int32(index))))
	}

	return gui.PointerFromQAccessibleInterface(NewQAccessibleWidgetFromPointer(ptr).ChildDefault(int(int32(index))))
}

func (ptr *QAccessibleWidget) ConnectChild(f func(index int) *gui.QAccessibleInterface) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectChild() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) Child(index int) *gui.QAccessibleInterface {
	if ptr.Pointer() != nil {
		return gui.NewQAccessibleInterfaceFromPointer(C.QAccessibleWidget_Child(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QAccessibleWidget) ChildDefault(index int) *gui.QAccessibleInterface {
	if ptr.Pointer() != nil {
		return gui.NewQAccessibleInterfaceFromPointer(C.QAccessibleWidget_ChildDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

//export callbackQAccessibleWidget_FocusChild
func callbackQAccessibleWidget_FocusChild(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "focusChild"); signal != nil {
		return gui.PointerFromQAccessibleInterface((*(*func() *gui.QAccessibleInterface)(signal))())
	}

	return gui.PointerFromQAccessibleInterface(NewQAccessibleWidgetFromPointer(ptr).FocusChildDefault())
}

func (ptr *QAccessibleWidget) ConnectFocusChild(f func() *gui.QAccessibleInterface) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectFocusChild() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) FocusChild() *gui.QAccessibleInterface {
	if ptr.Pointer() != nil {
		return gui.NewQAccessibleInterfaceFromPointer(C.QAccessibleWidget_FocusChild(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleWidget) FocusChildDefault() *gui.QAccessibleInterface {
	if ptr.Pointer() != nil {
		return gui.NewQAccessibleInterfaceFromPointer(C.QAccessibleWidget_FocusChildDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQAccessibleWidget_Parent
func callbackQAccessibleWidget_Parent(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return gui.PointerFromQAccessibleInterface((*(*func() *gui.QAccessibleInterface)(signal))())
	}

	return gui.PointerFromQAccessibleInterface(NewQAccessibleWidgetFromPointer(ptr).ParentDefault())
}

func (ptr *QAccessibleWidget) ConnectParent(f func() *gui.QAccessibleInterface) {
	if ptr.Pointer() != nil {

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

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

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

func (ptr *QAccessibleWidget) Parent() *gui.QAccessibleInterface {
	if ptr.Pointer() != nil {
		return gui.NewQAccessibleInterfaceFromPointer(C.QAccessibleWidget_Parent(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleWidget) ParentDefault() *gui.QAccessibleInterface {
	if ptr.Pointer() != nil {
		return gui.NewQAccessibleInterfaceFromPointer(C.QAccessibleWidget_ParentDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQAccessibleWidget_BackgroundColor
func callbackQAccessibleWidget_BackgroundColor(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "backgroundColor"); signal != nil {
		return gui.PointerFromQColor((*(*func() *gui.QColor)(signal))())
	}

	return gui.PointerFromQColor(NewQAccessibleWidgetFromPointer(ptr).BackgroundColorDefault())
}

func (ptr *QAccessibleWidget) ConnectBackgroundColor(f func() *gui.QColor) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectBackgroundColor() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) BackgroundColor() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QAccessibleWidget_BackgroundColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QAccessibleWidget) BackgroundColorDefault() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QAccessibleWidget_BackgroundColorDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

//export callbackQAccessibleWidget_ForegroundColor
func callbackQAccessibleWidget_ForegroundColor(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "foregroundColor"); signal != nil {
		return gui.PointerFromQColor((*(*func() *gui.QColor)(signal))())
	}

	return gui.PointerFromQColor(NewQAccessibleWidgetFromPointer(ptr).ForegroundColorDefault())
}

func (ptr *QAccessibleWidget) ConnectForegroundColor(f func() *gui.QColor) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectForegroundColor() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) ForegroundColor() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QAccessibleWidget_ForegroundColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QAccessibleWidget) ForegroundColorDefault() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QAccessibleWidget_ForegroundColorDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QAccessibleWidget) ParentObject() *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QAccessibleWidget_ParentObject(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAccessibleWidget_Rect
func callbackQAccessibleWidget_Rect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "rect"); signal != nil {
		return core.PointerFromQRect((*(*func() *core.QRect)(signal))())
	}

	return core.PointerFromQRect(NewQAccessibleWidgetFromPointer(ptr).RectDefault())
}

func (ptr *QAccessibleWidget) ConnectRect(f func() *core.QRect) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectRect() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) Rect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QAccessibleWidget_Rect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QAccessibleWidget) RectDefault() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QAccessibleWidget_RectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQAccessibleWidget_Text
func callbackQAccessibleWidget_Text(ptr unsafe.Pointer, t C.longlong) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "text"); signal != nil {
		tempVal := (*(*func(gui.QAccessible__Text) string)(signal))(gui.QAccessible__Text(t))
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQAccessibleWidgetFromPointer(ptr).TextDefault(gui.QAccessible__Text(t))
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QAccessibleWidget) ConnectText(f func(t gui.QAccessible__Text) string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "text"); signal != nil {
			f := func(t gui.QAccessible__Text) string {
				(*(*func(gui.QAccessible__Text) string)(signal))(t)
				return f(t)
			}
			qt.ConnectSignal(ptr.Pointer(), "text", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "text", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QAccessibleWidget) DisconnectText() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) Text(t gui.QAccessible__Text) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAccessibleWidget_Text(ptr.Pointer(), C.longlong(t)))
	}
	return ""
}

func (ptr *QAccessibleWidget) TextDefault(t gui.QAccessible__Text) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAccessibleWidget_TextDefault(ptr.Pointer(), C.longlong(t)))
	}
	return ""
}

//export callbackQAccessibleWidget_ActionNames
func callbackQAccessibleWidget_ActionNames(ptr unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "actionNames"); signal != nil {
		tempVal := (*(*func() []string)(signal))()
		return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
	}
	tempVal := NewQAccessibleWidgetFromPointer(ptr).ActionNamesDefault()
	return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
}

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

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

func (ptr *QAccessibleWidget) DisconnectActionNames() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) ActionNames() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QAccessibleWidget_ActionNames(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QAccessibleWidget) ActionNamesDefault() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QAccessibleWidget_ActionNamesDefault(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

//export callbackQAccessibleWidget_KeyBindingsForAction
func callbackQAccessibleWidget_KeyBindingsForAction(ptr unsafe.Pointer, actionName C.struct_QtWidgets_PackedString) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "keyBindingsForAction"); signal != nil {
		tempVal := (*(*func(string) []string)(signal))(cGoUnpackString(actionName))
		return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
	}
	tempVal := NewQAccessibleWidgetFromPointer(ptr).KeyBindingsForActionDefault(cGoUnpackString(actionName))
	return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
}

func (ptr *QAccessibleWidget) ConnectKeyBindingsForAction(f func(actionName string) []string) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectKeyBindingsForAction() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) KeyBindingsForAction(actionName string) []string {
	if ptr.Pointer() != nil {
		var actionNameC *C.char
		if actionName != "" {
			actionNameC = C.CString(actionName)
			defer C.free(unsafe.Pointer(actionNameC))
		}
		return strings.Split(cGoUnpackString(C.QAccessibleWidget_KeyBindingsForAction(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: actionNameC, len: C.longlong(len(actionName))})), "|")
	}
	return make([]string, 0)
}

func (ptr *QAccessibleWidget) KeyBindingsForActionDefault(actionName string) []string {
	if ptr.Pointer() != nil {
		var actionNameC *C.char
		if actionName != "" {
			actionNameC = C.CString(actionName)
			defer C.free(unsafe.Pointer(actionNameC))
		}
		return strings.Split(cGoUnpackString(C.QAccessibleWidget_KeyBindingsForActionDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: actionNameC, len: C.longlong(len(actionName))})), "|")
	}
	return make([]string, 0)
}

func (ptr *QAccessibleWidget) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QAccessibleWidget_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAccessibleWidget_Window
func callbackQAccessibleWidget_Window(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "window"); signal != nil {
		return gui.PointerFromQWindow((*(*func() *gui.QWindow)(signal))())
	}

	return gui.PointerFromQWindow(NewQAccessibleWidgetFromPointer(ptr).WindowDefault())
}

func (ptr *QAccessibleWidget) ConnectWindow(f func() *gui.QWindow) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectWindow() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) Window() *gui.QWindow {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQWindowFromPointer(C.QAccessibleWidget_Window(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAccessibleWidget) WindowDefault() *gui.QWindow {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQWindowFromPointer(C.QAccessibleWidget_WindowDefault(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

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

	return C.char(int8(qt.GoBoolToInt(NewQAccessibleWidgetFromPointer(ptr).IsValidDefault())))
}

func (ptr *QAccessibleWidget) ConnectIsValid(f func() bool) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectIsValid() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAccessibleWidget_IsValid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAccessibleWidget) IsValidDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAccessibleWidget_IsValidDefault(ptr.Pointer())) != 0
	}
	return false
}

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

	return C.int(int32(NewQAccessibleWidgetFromPointer(ptr).ChildCountDefault()))
}

func (ptr *QAccessibleWidget) ConnectChildCount(f func() int) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectChildCount() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) ChildCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAccessibleWidget_ChildCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QAccessibleWidget) ChildCountDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAccessibleWidget_ChildCountDefault(ptr.Pointer())))
	}
	return 0
}

//export callbackQAccessibleWidget_IndexOfChild
func callbackQAccessibleWidget_IndexOfChild(ptr unsafe.Pointer, child unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "indexOfChild"); signal != nil {
		return C.int(int32((*(*func(*gui.QAccessibleInterface) int)(signal))(gui.NewQAccessibleInterfaceFromPointer(child))))
	}

	return C.int(int32(NewQAccessibleWidgetFromPointer(ptr).IndexOfChildDefault(gui.NewQAccessibleInterfaceFromPointer(child))))
}

func (ptr *QAccessibleWidget) ConnectIndexOfChild(f func(child *gui.QAccessibleInterface) int) {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) DisconnectIndexOfChild() {
	if ptr.Pointer() != nil {

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

func (ptr *QAccessibleWidget) IndexOfChild(child gui.QAccessibleInterface_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAccessibleWidget_IndexOfChild(ptr.Pointer(), gui.PointerFromQAccessibleInterface(child))))
	}
	return 0
}

func (ptr *QAccessibleWidget) IndexOfChildDefault(child gui.QAccessibleInterface_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QAccessibleWidget_IndexOfChildDefault(ptr.Pointer(), gui.PointerFromQAccessibleInterface(child))))
	}
	return 0
}

//export callbackQAccessibleWidget_SetText
func callbackQAccessibleWidget_SetText(ptr unsafe.Pointer, t C.longlong, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setText"); signal != nil {
		(*(*func(gui.QAccessible__Text, string))(signal))(gui.QAccessible__Text(t), cGoUnpackString(text))
	} else {
		NewQAccessibleWidgetFromPointer(ptr).SetTextDefault(gui.QAccessible__Text(t), cGoUnpackString(text))
	}
}

func (ptr *QAccessibleWidget) SetText(t gui.QAccessible__Text, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QAccessibleWidget_SetText(ptr.Pointer(), C.longlong(t), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QAccessibleWidget) SetTextDefault(t gui.QAccessible__Text, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QAccessibleWidget_SetTextDefault(ptr.Pointer(), C.longlong(t), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQAccessibleWidget_ChildAt
func callbackQAccessibleWidget_ChildAt(ptr unsafe.Pointer, x C.int, y C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "childAt"); signal != nil {
		return gui.PointerFromQAccessibleInterface((*(*func(int, int) *gui.QAccessibleInterface)(signal))(int(int32(x)), int(int32(y))))
	}

	return gui.PointerFromQAccessibleInterface(NewQAccessibleWidgetFromPointer(ptr).ChildAtDefault(int(int32(x)), int(int32(y))))
}

func (ptr *QAccessibleWidget) ChildAt(x int, y int) *gui.QAccessibleInterface {
	if ptr.Pointer() != nil {
		return gui.NewQAccessibleInterfaceFromPointer(C.QAccessibleWidget_ChildAt(ptr.Pointer(), C.int(int32(x)), C.int(int32(y))))
	}
	return nil
}

func (ptr *QAccessibleWidget) ChildAtDefault(x int, y int) *gui.QAccessibleInterface {
	if ptr.Pointer() != nil {
		return gui.NewQAccessibleInterfaceFromPointer(C.QAccessibleWidget_ChildAtDefault(ptr.Pointer(), C.int(int32(x)), C.int(int32(y))))
	}
	return nil
}

//export callbackQAccessibleWidget_Object
func callbackQAccessibleWidget_Object(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "object"); signal != nil {
		return core.PointerFromQObject((*(*func() *core.QObject)(signal))())
	}

	return core.PointerFromQObject(NewQAccessibleWidgetFromPointer(ptr).ObjectDefault())
}

func (ptr *QAccessibleWidget) Object() *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QAccessibleWidget_Object(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAccessibleWidget) ObjectDefault() *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QAccessibleWidget_ObjectDefault(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQAccessibleWidget_LocalizedActionDescription
func callbackQAccessibleWidget_LocalizedActionDescription(ptr unsafe.Pointer, actionName C.struct_QtWidgets_PackedString) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "localizedActionDescription"); signal != nil {
		tempVal := (*(*func(string) string)(signal))(cGoUnpackString(actionName))
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQAccessibleWidgetFromPointer(ptr).LocalizedActionDescriptionDefault(cGoUnpackString(actionName))
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QAccessibleWidget) LocalizedActionDescription(actionName string) string {
	if ptr.Pointer() != nil {
		var actionNameC *C.char
		if actionName != "" {
			actionNameC = C.CString(actionName)
			defer C.free(unsafe.Pointer(actionNameC))
		}
		return cGoUnpackString(C.QAccessibleWidget_LocalizedActionDescription(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: actionNameC, len: C.longlong(len(actionName))}))
	}
	return ""
}

func (ptr *QAccessibleWidget) LocalizedActionDescriptionDefault(actionName string) string {
	if ptr.Pointer() != nil {
		var actionNameC *C.char
		if actionName != "" {
			actionNameC = C.CString(actionName)
			defer C.free(unsafe.Pointer(actionNameC))
		}
		return cGoUnpackString(C.QAccessibleWidget_LocalizedActionDescriptionDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: actionNameC, len: C.longlong(len(actionName))}))
	}
	return ""
}

//export callbackQAccessibleWidget_LocalizedActionName
func callbackQAccessibleWidget_LocalizedActionName(ptr unsafe.Pointer, actionName C.struct_QtWidgets_PackedString) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "localizedActionName"); signal != nil {
		tempVal := (*(*func(string) string)(signal))(cGoUnpackString(actionName))
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQAccessibleWidgetFromPointer(ptr).LocalizedActionNameDefault(cGoUnpackString(actionName))
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QAccessibleWidget) LocalizedActionName(actionName string) string {
	if ptr.Pointer() != nil {
		var actionNameC *C.char
		if actionName != "" {
			actionNameC = C.CString(actionName)
			defer C.free(unsafe.Pointer(actionNameC))
		}
		return cGoUnpackString(C.QAccessibleWidget_LocalizedActionName(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: actionNameC, len: C.longlong(len(actionName))}))
	}
	return ""
}

func (ptr *QAccessibleWidget) LocalizedActionNameDefault(actionName string) string {
	if ptr.Pointer() != nil {
		var actionNameC *C.char
		if actionName != "" {
			actionNameC = C.CString(actionName)
			defer C.free(unsafe.Pointer(actionNameC))
		}
		return cGoUnpackString(C.QAccessibleWidget_LocalizedActionNameDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: actionNameC, len: C.longlong(len(actionName))}))
	}
	return ""
}

type QAction struct {
	core.QObject
}

type QAction_ITF interface {
	core.QObject_ITF
	QAction_PTR() *QAction
}

func (ptr *QAction) QAction_PTR() *QAction {
	return ptr
}

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

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

func PointerFromQAction(ptr QAction_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAction_PTR().Pointer()
	}
	return nil
}

func NewQActionFromPointer(ptr unsafe.Pointer) (n *QAction) {
	n = new(QAction)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QAction__ActionEvent
//QAction::ActionEvent
type QAction__ActionEvent int64

const (
	QAction__Trigger QAction__ActionEvent = QAction__ActionEvent(0)
	QAction__Hover   QAction__ActionEvent = QAction__ActionEvent(1)
)

//go:generate stringer -type=QAction__MenuRole
//QAction::MenuRole
type QAction__MenuRole int64

const (
	QAction__NoRole                  QAction__MenuRole = QAction__MenuRole(0)
	QAction__TextHeuristicRole       QAction__MenuRole = QAction__MenuRole(1)
	QAction__ApplicationSpecificRole QAction__MenuRole = QAction__MenuRole(2)
	QAction__AboutQtRole             QAction__MenuRole = QAction__MenuRole(3)
	QAction__AboutRole               QAction__MenuRole = QAction__MenuRole(4)
	QAction__PreferencesRole         QAction__MenuRole = QAction__MenuRole(5)
	QAction__QuitRole                QAction__MenuRole = QAction__MenuRole(6)
)

//go:generate stringer -type=QAction__Priority
//QAction::Priority
type QAction__Priority int64

const (
	QAction__LowPriority    QAction__Priority = QAction__Priority(0)
	QAction__NormalPriority QAction__Priority = QAction__Priority(128)
	QAction__HighPriority   QAction__Priority = QAction__Priority(256)
)

func NewQAction(parent core.QObject_ITF) *QAction {
	tmpValue := NewQActionFromPointer(C.QAction_NewQAction(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQAction3(icon gui.QIcon_ITF, text string, parent core.QObject_ITF) *QAction {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQActionFromPointer(C.QAction_NewQAction3(gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQAction2(text string, parent core.QObject_ITF) *QAction {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQActionFromPointer(C.QAction_NewQAction2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QAction_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QAction_QAction_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QAction) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QAction_QAction_Tr(sC, cC, C.int(int32(n))))
}

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

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

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

func (ptr *QAction) ShowStatusText(widget QWidget_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QAction_ShowStatusText(ptr.Pointer(), PointerFromQWidget(widget))) != 0
	}
	return false
}

func (ptr *QAction) Activate(event QAction__ActionEvent) {
	if ptr.Pointer() != nil {
		C.QAction_Activate(ptr.Pointer(), C.longlong(event))
	}
}

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

}

func (ptr *QAction) ConnectChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "changed") {
			C.QAction_ConnectChanged(ptr.Pointer())
		}

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

func (ptr *QAction) DisconnectChanged() {
	if ptr.Pointer() != nil {
		C.QAction_DisconnectChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "changed")
	}
}

func (ptr *QAction) Changed() {
	if ptr.Pointer() != nil {
		C.QAction_Changed(ptr.Pointer())
	}
}

//export callbackQAction_Hover
func callbackQAction_Hover(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hover"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQActionFromPointer(ptr).HoverDefault()
	}
}

func (ptr *QAction) ConnectHover(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) DisconnectHover() {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) Hover() {
	if ptr.Pointer() != nil {
		C.QAction_Hover(ptr.Pointer())
	}
}

func (ptr *QAction) HoverDefault() {
	if ptr.Pointer() != nil {
		C.QAction_HoverDefault(ptr.Pointer())
	}
}

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

}

func (ptr *QAction) ConnectHovered(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "hovered") {
			C.QAction_ConnectHovered(ptr.Pointer())
		}

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

func (ptr *QAction) DisconnectHovered() {
	if ptr.Pointer() != nil {
		C.QAction_DisconnectHovered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "hovered")
	}
}

func (ptr *QAction) Hovered() {
	if ptr.Pointer() != nil {
		C.QAction_Hovered(ptr.Pointer())
	}
}

func (ptr *QAction) SetActionGroup(group QActionGroup_ITF) {
	if ptr.Pointer() != nil {
		C.QAction_SetActionGroup(ptr.Pointer(), PointerFromQActionGroup(group))
	}
}

func (ptr *QAction) SetAutoRepeat(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetAutoRepeat(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAction) SetCheckable(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetCheckable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQAction_SetChecked
func callbackQAction_SetChecked(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setChecked"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQActionFromPointer(ptr).SetCheckedDefault(int8(vbo) != 0)
	}
}

func (ptr *QAction) ConnectSetChecked(f func(vbo bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) DisconnectSetChecked() {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) SetChecked(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetChecked(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAction) SetCheckedDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetCheckedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAction) SetData(userData core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QAction_SetData(ptr.Pointer(), core.PointerFromQVariant(userData))
	}
}

//export callbackQAction_SetDisabled
func callbackQAction_SetDisabled(ptr unsafe.Pointer, b C.char) {
	if signal := qt.GetSignal(ptr, "setDisabled"); signal != nil {
		(*(*func(bool))(signal))(int8(b) != 0)
	} else {
		NewQActionFromPointer(ptr).SetDisabledDefault(int8(b) != 0)
	}
}

func (ptr *QAction) ConnectSetDisabled(f func(b bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) DisconnectSetDisabled() {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) SetDisabled(b bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetDisabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QAction) SetDisabledDefault(b bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetDisabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

//export callbackQAction_SetEnabled
func callbackQAction_SetEnabled(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setEnabled"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQActionFromPointer(ptr).SetEnabledDefault(int8(vbo) != 0)
	}
}

func (ptr *QAction) ConnectSetEnabled(f func(vbo bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) DisconnectSetEnabled() {
	if ptr.Pointer() != nil {

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

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

func (ptr *QAction) SetEnabledDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAction) SetFont(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QAction_SetFont(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

func (ptr *QAction) SetIcon(icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QAction_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QAction) SetIconText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QAction_SetIconText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QAction) SetIconVisibleInMenu(visible bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetIconVisibleInMenu(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QAction) SetMenu(menu QMenu_ITF) {
	if ptr.Pointer() != nil {
		C.QAction_SetMenu(ptr.Pointer(), PointerFromQMenu(menu))
	}
}

func (ptr *QAction) SetMenuRole(menuRole QAction__MenuRole) {
	if ptr.Pointer() != nil {
		C.QAction_SetMenuRole(ptr.Pointer(), C.longlong(menuRole))
	}
}

func (ptr *QAction) SetPriority(priority QAction__Priority) {
	if ptr.Pointer() != nil {
		C.QAction_SetPriority(ptr.Pointer(), C.longlong(priority))
	}
}

func (ptr *QAction) SetSeparator(b bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetSeparator(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QAction) SetShortcut(shortcut gui.QKeySequence_ITF) {
	if ptr.Pointer() != nil {
		C.QAction_SetShortcut(ptr.Pointer(), gui.PointerFromQKeySequence(shortcut))
	}
}

func (ptr *QAction) SetShortcutContext(context core.Qt__ShortcutContext) {
	if ptr.Pointer() != nil {
		C.QAction_SetShortcutContext(ptr.Pointer(), C.longlong(context))
	}
}

func (ptr *QAction) SetShortcutVisibleInContextMenu(show bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetShortcutVisibleInContextMenu(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(show))))
	}
}

func (ptr *QAction) SetShortcuts2(key gui.QKeySequence__StandardKey) {
	if ptr.Pointer() != nil {
		C.QAction_SetShortcuts2(ptr.Pointer(), C.longlong(key))
	}
}

func (ptr *QAction) SetShortcuts(shortcuts []*gui.QKeySequence) {
	if ptr.Pointer() != nil {
		C.QAction_SetShortcuts(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQActionFromPointer(NewQActionFromPointer(nil).__setShortcuts_shortcuts_newList())
			for _, v := range shortcuts {
				tmpList.__setShortcuts_shortcuts_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QAction) SetStatusTip(statusTip string) {
	if ptr.Pointer() != nil {
		var statusTipC *C.char
		if statusTip != "" {
			statusTipC = C.CString(statusTip)
			defer C.free(unsafe.Pointer(statusTipC))
		}
		C.QAction_SetStatusTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: statusTipC, len: C.longlong(len(statusTip))})
	}
}

func (ptr *QAction) SetText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QAction_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QAction) SetToolTip(tip string) {
	if ptr.Pointer() != nil {
		var tipC *C.char
		if tip != "" {
			tipC = C.CString(tip)
			defer C.free(unsafe.Pointer(tipC))
		}
		C.QAction_SetToolTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: tipC, len: C.longlong(len(tip))})
	}
}

//export callbackQAction_SetVisible
func callbackQAction_SetVisible(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQActionFromPointer(ptr).SetVisibleDefault(int8(vbo) != 0)
	}
}

func (ptr *QAction) ConnectSetVisible(f func(vbo bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) DisconnectSetVisible() {
	if ptr.Pointer() != nil {

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

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

func (ptr *QAction) SetVisibleDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QAction_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QAction) SetWhatsThis(what string) {
	if ptr.Pointer() != nil {
		var whatC *C.char
		if what != "" {
			whatC = C.CString(what)
			defer C.free(unsafe.Pointer(whatC))
		}
		C.QAction_SetWhatsThis(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: whatC, len: C.longlong(len(what))})
	}
}

//export callbackQAction_Toggle
func callbackQAction_Toggle(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "toggle"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQActionFromPointer(ptr).ToggleDefault()
	}
}

func (ptr *QAction) ConnectToggle(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) DisconnectToggle() {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) Toggle() {
	if ptr.Pointer() != nil {
		C.QAction_Toggle(ptr.Pointer())
	}
}

func (ptr *QAction) ToggleDefault() {
	if ptr.Pointer() != nil {
		C.QAction_ToggleDefault(ptr.Pointer())
	}
}

//export callbackQAction_Toggled
func callbackQAction_Toggled(ptr unsafe.Pointer, checked C.char) {
	if signal := qt.GetSignal(ptr, "toggled"); signal != nil {
		(*(*func(bool))(signal))(int8(checked) != 0)
	}

}

func (ptr *QAction) ConnectToggled(f func(checked bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "toggled") {
			C.QAction_ConnectToggled(ptr.Pointer())
		}

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

func (ptr *QAction) DisconnectToggled() {
	if ptr.Pointer() != nil {
		C.QAction_DisconnectToggled(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "toggled")
	}
}

func (ptr *QAction) Toggled(checked bool) {
	if ptr.Pointer() != nil {
		C.QAction_Toggled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(checked))))
	}
}

//export callbackQAction_Trigger
func callbackQAction_Trigger(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "trigger"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQActionFromPointer(ptr).TriggerDefault()
	}
}

func (ptr *QAction) ConnectTrigger(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) DisconnectTrigger() {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) Trigger() {
	if ptr.Pointer() != nil {
		C.QAction_Trigger(ptr.Pointer())
	}
}

func (ptr *QAction) TriggerDefault() {
	if ptr.Pointer() != nil {
		C.QAction_TriggerDefault(ptr.Pointer())
	}
}

//export callbackQAction_Triggered
func callbackQAction_Triggered(ptr unsafe.Pointer, checked C.char) {
	if signal := qt.GetSignal(ptr, "triggered"); signal != nil {
		(*(*func(bool))(signal))(int8(checked) != 0)
	}

}

func (ptr *QAction) ConnectTriggered(f func(checked bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "triggered") {
			C.QAction_ConnectTriggered(ptr.Pointer())
		}

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

func (ptr *QAction) DisconnectTriggered() {
	if ptr.Pointer() != nil {
		C.QAction_DisconnectTriggered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "triggered")
	}
}

func (ptr *QAction) Triggered(checked bool) {
	if ptr.Pointer() != nil {
		C.QAction_Triggered(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(checked))))
	}
}

//export callbackQAction_DestroyQAction
func callbackQAction_DestroyQAction(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QAction"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQActionFromPointer(ptr).DestroyQActionDefault()
	}
}

func (ptr *QAction) ConnectDestroyQAction(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) DisconnectDestroyQAction() {
	if ptr.Pointer() != nil {

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

func (ptr *QAction) DestroyQAction() {
	if ptr.Pointer() != nil {
		C.QAction_DestroyQAction(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAction) DestroyQActionDefault() {
	if ptr.Pointer() != nil {
		C.QAction_DestroyQActionDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QAction) MenuRole() QAction__MenuRole {
	if ptr.Pointer() != nil {
		return QAction__MenuRole(C.QAction_MenuRole(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAction) Priority() QAction__Priority {
	if ptr.Pointer() != nil {
		return QAction__Priority(C.QAction_Priority(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAction) ActionGroup() *QActionGroup {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionGroupFromPointer(C.QAction_ActionGroup(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAction) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QAction_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QAction) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QAction_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QAction) Shortcut() *gui.QKeySequence {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQKeySequenceFromPointer(C.QAction_Shortcut(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QKeySequence).DestroyQKeySequence)
		return tmpValue
	}
	return nil
}

func (ptr *QAction) AssociatedGraphicsWidgets() []*QGraphicsWidget {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsWidget {
			out := make([]*QGraphicsWidget, int(l.len))
			tmpList := NewQActionFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__associatedGraphicsWidgets_atList(i)
			}
			return out
		}(C.QAction_AssociatedGraphicsWidgets(ptr.Pointer()))
	}
	return make([]*QGraphicsWidget, 0)
}

func (ptr *QAction) Shortcuts() []*gui.QKeySequence {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*gui.QKeySequence {
			out := make([]*gui.QKeySequence, int(l.len))
			tmpList := NewQActionFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__shortcuts_atList(i)
			}
			return out
		}(C.QAction_Shortcuts(ptr.Pointer()))
	}
	return make([]*gui.QKeySequence, 0)
}

func (ptr *QAction) AssociatedWidgets() []*QWidget {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QWidget {
			out := make([]*QWidget, int(l.len))
			tmpList := NewQActionFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__associatedWidgets_atList(i)
			}
			return out
		}(C.QAction_AssociatedWidgets(ptr.Pointer()))
	}
	return make([]*QWidget, 0)
}

func (ptr *QAction) Menu() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QAction_Menu(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAction) IconText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAction_IconText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QAction) StatusTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAction_StatusTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QAction) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAction_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QAction) ToolTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAction_ToolTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QAction) WhatsThis() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QAction_WhatsThis(ptr.Pointer()))
	}
	return ""
}

func (ptr *QAction) Data() *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QAction_Data(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QAction) ParentWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QAction_ParentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAction) ShortcutContext() core.Qt__ShortcutContext {
	if ptr.Pointer() != nil {
		return core.Qt__ShortcutContext(C.QAction_ShortcutContext(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAction) AutoRepeat() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAction_AutoRepeat(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAction) IsCheckable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAction_IsCheckable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAction) IsChecked() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAction_IsChecked(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAction) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAction_IsEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAction) IsIconVisibleInMenu() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAction_IsIconVisibleInMenu(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAction) IsSeparator() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAction_IsSeparator(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAction) IsShortcutVisibleInContextMenu() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAction_IsShortcutVisibleInContextMenu(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QAction) IsVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QAction_IsVisible(ptr.Pointer())) != 0
	}
	return false
}

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

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

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

func (ptr *QAction) __setShortcuts_shortcuts_atList(i int) *gui.QKeySequence {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQKeySequenceFromPointer(C.QAction___setShortcuts_shortcuts_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*gui.QKeySequence).DestroyQKeySequence)
		return tmpValue
	}
	return nil
}

func (ptr *QAction) __setShortcuts_shortcuts_setList(i gui.QKeySequence_ITF) {
	if ptr.Pointer() != nil {
		C.QAction___setShortcuts_shortcuts_setList(ptr.Pointer(), gui.PointerFromQKeySequence(i))
	}
}

func (ptr *QAction) __setShortcuts_shortcuts_newList() unsafe.Pointer {
	return C.QAction___setShortcuts_shortcuts_newList(ptr.Pointer())
}

func (ptr *QAction) __associatedGraphicsWidgets_atList(i int) *QGraphicsWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsWidgetFromPointer(C.QAction___associatedGraphicsWidgets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAction) __associatedGraphicsWidgets_setList(i QGraphicsWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAction___associatedGraphicsWidgets_setList(ptr.Pointer(), PointerFromQGraphicsWidget(i))
	}
}

func (ptr *QAction) __associatedGraphicsWidgets_newList() unsafe.Pointer {
	return C.QAction___associatedGraphicsWidgets_newList(ptr.Pointer())
}

func (ptr *QAction) __shortcuts_atList(i int) *gui.QKeySequence {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQKeySequenceFromPointer(C.QAction___shortcuts_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*gui.QKeySequence).DestroyQKeySequence)
		return tmpValue
	}
	return nil
}

func (ptr *QAction) __shortcuts_setList(i gui.QKeySequence_ITF) {
	if ptr.Pointer() != nil {
		C.QAction___shortcuts_setList(ptr.Pointer(), gui.PointerFromQKeySequence(i))
	}
}

func (ptr *QAction) __shortcuts_newList() unsafe.Pointer {
	return C.QAction___shortcuts_newList(ptr.Pointer())
}

func (ptr *QAction) __associatedWidgets_atList(i int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QAction___associatedWidgets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QAction) __associatedWidgets_setList(i QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QAction___associatedWidgets_setList(ptr.Pointer(), PointerFromQWidget(i))
	}
}

func (ptr *QAction) __associatedWidgets_newList() unsafe.Pointer {
	return C.QAction___associatedWidgets_newList(ptr.Pointer())
}

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

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

func (ptr *QAction) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QAction___dynamicPropertyNames_newList(ptr.Pointer())
}

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

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

func (ptr *QAction) __findChildren_newList2() unsafe.Pointer {
	return C.QAction___findChildren_newList2(ptr.Pointer())
}

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

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

func (ptr *QAction) __findChildren_newList3() unsafe.Pointer {
	return C.QAction___findChildren_newList3(ptr.Pointer())
}

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

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

func (ptr *QAction) __findChildren_newList() unsafe.Pointer {
	return C.QAction___findChildren_newList(ptr.Pointer())
}

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

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

func (ptr *QAction) __children_newList() unsafe.Pointer {
	return C.QAction___children_newList(ptr.Pointer())
}

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

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

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

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

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

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

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

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

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

//export callbackQAction_DeleteLater
func callbackQAction_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQActionFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QAction) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QAction_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

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

}

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

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

//export callbackQAction_ObjectNameChanged
func callbackQAction_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

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

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

type QActionGroup struct {
	core.QObject
}

type QActionGroup_ITF interface {
	core.QObject_ITF
	QActionGroup_PTR() *QActionGroup
}

func (ptr *QActionGroup) QActionGroup_PTR() *QActionGroup {
	return ptr
}

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

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

func PointerFromQActionGroup(ptr QActionGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QActionGroup_PTR().Pointer()
	}
	return nil
}

func NewQActionGroupFromPointer(ptr unsafe.Pointer) (n *QActionGroup) {
	n = new(QActionGroup)
	n.SetPointer(ptr)
	return
}
func (ptr *QActionGroup) AddAction(action QAction_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QActionGroup_AddAction(ptr.Pointer(), PointerFromQAction(action)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QActionGroup) AddAction3(icon gui.QIcon_ITF, text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QActionGroup_AddAction3(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QActionGroup) AddAction2(text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QActionGroup_AddAction2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQActionGroup(parent core.QObject_ITF) *QActionGroup {
	tmpValue := NewQActionGroupFromPointer(C.QActionGroup_NewQActionGroup(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QActionGroup_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QActionGroup_QActionGroup_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QActionGroup) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QActionGroup_QActionGroup_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQActionGroup_Hovered
func callbackQActionGroup_Hovered(ptr unsafe.Pointer, action unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hovered"); signal != nil {
		(*(*func(*QAction))(signal))(NewQActionFromPointer(action))
	}

}

func (ptr *QActionGroup) ConnectHovered(f func(action *QAction)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "hovered") {
			C.QActionGroup_ConnectHovered(ptr.Pointer())
		}

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

func (ptr *QActionGroup) DisconnectHovered() {
	if ptr.Pointer() != nil {
		C.QActionGroup_DisconnectHovered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "hovered")
	}
}

func (ptr *QActionGroup) Hovered(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QActionGroup_Hovered(ptr.Pointer(), PointerFromQAction(action))
	}
}

func (ptr *QActionGroup) RemoveAction(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QActionGroup_RemoveAction(ptr.Pointer(), PointerFromQAction(action))
	}
}

//export callbackQActionGroup_SetDisabled
func callbackQActionGroup_SetDisabled(ptr unsafe.Pointer, b C.char) {
	if signal := qt.GetSignal(ptr, "setDisabled"); signal != nil {
		(*(*func(bool))(signal))(int8(b) != 0)
	} else {
		NewQActionGroupFromPointer(ptr).SetDisabledDefault(int8(b) != 0)
	}
}

func (ptr *QActionGroup) ConnectSetDisabled(f func(b bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QActionGroup) DisconnectSetDisabled() {
	if ptr.Pointer() != nil {

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

func (ptr *QActionGroup) SetDisabled(b bool) {
	if ptr.Pointer() != nil {
		C.QActionGroup_SetDisabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QActionGroup) SetDisabledDefault(b bool) {
	if ptr.Pointer() != nil {
		C.QActionGroup_SetDisabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

//export callbackQActionGroup_SetEnabled
func callbackQActionGroup_SetEnabled(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setEnabled"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQActionGroupFromPointer(ptr).SetEnabledDefault(int8(vbo) != 0)
	}
}

func (ptr *QActionGroup) ConnectSetEnabled(f func(vbo bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QActionGroup) DisconnectSetEnabled() {
	if ptr.Pointer() != nil {

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

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

func (ptr *QActionGroup) SetEnabledDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QActionGroup_SetEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQActionGroup_SetExclusive
func callbackQActionGroup_SetExclusive(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setExclusive"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQActionGroupFromPointer(ptr).SetExclusiveDefault(int8(vbo) != 0)
	}
}

func (ptr *QActionGroup) ConnectSetExclusive(f func(vbo bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QActionGroup) DisconnectSetExclusive() {
	if ptr.Pointer() != nil {

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

func (ptr *QActionGroup) SetExclusive(vbo bool) {
	if ptr.Pointer() != nil {
		C.QActionGroup_SetExclusive(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QActionGroup) SetExclusiveDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QActionGroup_SetExclusiveDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQActionGroup_SetVisible
func callbackQActionGroup_SetVisible(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQActionGroupFromPointer(ptr).SetVisibleDefault(int8(vbo) != 0)
	}
}

func (ptr *QActionGroup) ConnectSetVisible(f func(vbo bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QActionGroup) DisconnectSetVisible() {
	if ptr.Pointer() != nil {

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

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

func (ptr *QActionGroup) SetVisibleDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QActionGroup_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQActionGroup_Triggered
func callbackQActionGroup_Triggered(ptr unsafe.Pointer, action unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "triggered"); signal != nil {
		(*(*func(*QAction))(signal))(NewQActionFromPointer(action))
	}

}

func (ptr *QActionGroup) ConnectTriggered(f func(action *QAction)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "triggered") {
			C.QActionGroup_ConnectTriggered(ptr.Pointer())
		}

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

func (ptr *QActionGroup) DisconnectTriggered() {
	if ptr.Pointer() != nil {
		C.QActionGroup_DisconnectTriggered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "triggered")
	}
}

func (ptr *QActionGroup) Triggered(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QActionGroup_Triggered(ptr.Pointer(), PointerFromQAction(action))
	}
}

//export callbackQActionGroup_DestroyQActionGroup
func callbackQActionGroup_DestroyQActionGroup(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QActionGroup"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQActionGroupFromPointer(ptr).DestroyQActionGroupDefault()
	}
}

func (ptr *QActionGroup) ConnectDestroyQActionGroup(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QActionGroup) DisconnectDestroyQActionGroup() {
	if ptr.Pointer() != nil {

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

func (ptr *QActionGroup) DestroyQActionGroup() {
	if ptr.Pointer() != nil {
		C.QActionGroup_DestroyQActionGroup(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QActionGroup) DestroyQActionGroupDefault() {
	if ptr.Pointer() != nil {
		C.QActionGroup_DestroyQActionGroupDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QActionGroup) CheckedAction() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QActionGroup_CheckedAction(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QActionGroup) Actions() []*QAction {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QAction {
			out := make([]*QAction, int(l.len))
			tmpList := NewQActionGroupFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__actions_atList(i)
			}
			return out
		}(C.QActionGroup_Actions(ptr.Pointer()))
	}
	return make([]*QAction, 0)
}

func (ptr *QActionGroup) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QActionGroup_IsEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QActionGroup) IsExclusive() bool {
	if ptr.Pointer() != nil {
		return int8(C.QActionGroup_IsExclusive(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QActionGroup) IsVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QActionGroup_IsVisible(ptr.Pointer())) != 0
	}
	return false
}

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

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

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

func (ptr *QActionGroup) __actions_atList(i int) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QActionGroup___actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QActionGroup) __actions_setList(i QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QActionGroup___actions_setList(ptr.Pointer(), PointerFromQAction(i))
	}
}

func (ptr *QActionGroup) __actions_newList() unsafe.Pointer {
	return C.QActionGroup___actions_newList(ptr.Pointer())
}

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

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

func (ptr *QActionGroup) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QActionGroup___dynamicPropertyNames_newList(ptr.Pointer())
}

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

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

func (ptr *QActionGroup) __findChildren_newList2() unsafe.Pointer {
	return C.QActionGroup___findChildren_newList2(ptr.Pointer())
}

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

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

func (ptr *QActionGroup) __findChildren_newList3() unsafe.Pointer {
	return C.QActionGroup___findChildren_newList3(ptr.Pointer())
}

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

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

func (ptr *QActionGroup) __findChildren_newList() unsafe.Pointer {
	return C.QActionGroup___findChildren_newList(ptr.Pointer())
}

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

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

func (ptr *QActionGroup) __children_newList() unsafe.Pointer {
	return C.QActionGroup___children_newList(ptr.Pointer())
}

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

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

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

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

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

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

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

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

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

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

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

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

//export callbackQActionGroup_DeleteLater
func callbackQActionGroup_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQActionGroupFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QActionGroup) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QActionGroup_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

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

}

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

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

//export callbackQActionGroup_ObjectNameChanged
func callbackQActionGroup_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

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

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

type QApplication struct {
	gui.QGuiApplication
}

type QApplication_ITF interface {
	gui.QGuiApplication_ITF
	QApplication_PTR() *QApplication
}

func (ptr *QApplication) QApplication_PTR() *QApplication {
	return ptr
}

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

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

func PointerFromQApplication(ptr QApplication_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QApplication_PTR().Pointer()
	}
	return nil
}

func NewQApplicationFromPointer(ptr unsafe.Pointer) (n *QApplication) {
	n = new(QApplication)
	n.SetPointer(ptr)
	return
}
func NewQApplication(argc int, argv []string) *QApplication {
	argvC := C.CString(strings.Join(argv, "|"))
	defer C.free(unsafe.Pointer(argvC))
	tmpValue := NewQApplicationFromPointer(C.QApplication_NewQApplication(C.int(int32(argc)), argvC))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_Desktop() *QDesktopWidget {
	tmpValue := NewQDesktopWidgetFromPointer(C.QApplication_QApplication_Desktop())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) Desktop() *QDesktopWidget {
	tmpValue := NewQDesktopWidgetFromPointer(C.QApplication_QApplication_Desktop())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_Font() *gui.QFont {
	tmpValue := gui.NewQFontFromPointer(C.QApplication_QApplication_Font())
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func (ptr *QApplication) Font() *gui.QFont {
	tmpValue := gui.NewQFontFromPointer(C.QApplication_QApplication_Font())
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func QApplication_Font2(widget QWidget_ITF) *gui.QFont {
	tmpValue := gui.NewQFontFromPointer(C.QApplication_QApplication_Font2(PointerFromQWidget(widget)))
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func (ptr *QApplication) Font2(widget QWidget_ITF) *gui.QFont {
	tmpValue := gui.NewQFontFromPointer(C.QApplication_QApplication_Font2(PointerFromQWidget(widget)))
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func QApplication_Font3(className string) *gui.QFont {
	var classNameC *C.char
	if className != "" {
		classNameC = C.CString(className)
		defer C.free(unsafe.Pointer(classNameC))
	}
	tmpValue := gui.NewQFontFromPointer(C.QApplication_QApplication_Font3(classNameC))
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func (ptr *QApplication) Font3(className string) *gui.QFont {
	var classNameC *C.char
	if className != "" {
		classNameC = C.CString(className)
		defer C.free(unsafe.Pointer(classNameC))
	}
	tmpValue := gui.NewQFontFromPointer(C.QApplication_QApplication_Font3(classNameC))
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func QApplication_FontMetrics() *gui.QFontMetrics {
	tmpValue := gui.NewQFontMetricsFromPointer(C.QApplication_QApplication_FontMetrics())
	runtime.SetFinalizer(tmpValue, (*gui.QFontMetrics).DestroyQFontMetrics)
	return tmpValue
}

func (ptr *QApplication) FontMetrics() *gui.QFontMetrics {
	tmpValue := gui.NewQFontMetricsFromPointer(C.QApplication_QApplication_FontMetrics())
	runtime.SetFinalizer(tmpValue, (*gui.QFontMetrics).DestroyQFontMetrics)
	return tmpValue
}

func QApplication_WindowIcon() *gui.QIcon {
	tmpValue := gui.NewQIconFromPointer(C.QApplication_QApplication_WindowIcon())
	runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
	return tmpValue
}

func (ptr *QApplication) WindowIcon() *gui.QIcon {
	tmpValue := gui.NewQIconFromPointer(C.QApplication_QApplication_WindowIcon())
	runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
	return tmpValue
}

func QApplication_Palette(widget QWidget_ITF) *gui.QPalette {
	tmpValue := gui.NewQPaletteFromPointer(C.QApplication_QApplication_Palette(PointerFromQWidget(widget)))
	runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
	return tmpValue
}

func (ptr *QApplication) Palette(widget QWidget_ITF) *gui.QPalette {
	tmpValue := gui.NewQPaletteFromPointer(C.QApplication_QApplication_Palette(PointerFromQWidget(widget)))
	runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
	return tmpValue
}

func QApplication_Palette2(className string) *gui.QPalette {
	var classNameC *C.char
	if className != "" {
		classNameC = C.CString(className)
		defer C.free(unsafe.Pointer(classNameC))
	}
	tmpValue := gui.NewQPaletteFromPointer(C.QApplication_QApplication_Palette2(classNameC))
	runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
	return tmpValue
}

func (ptr *QApplication) Palette2(className string) *gui.QPalette {
	var classNameC *C.char
	if className != "" {
		classNameC = C.CString(className)
		defer C.free(unsafe.Pointer(classNameC))
	}
	tmpValue := gui.NewQPaletteFromPointer(C.QApplication_QApplication_Palette2(classNameC))
	runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
	return tmpValue
}

func QApplication_GlobalStrut() *core.QSize {
	tmpValue := core.NewQSizeFromPointer(C.QApplication_QApplication_GlobalStrut())
	runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
	return tmpValue
}

func (ptr *QApplication) GlobalStrut() *core.QSize {
	tmpValue := core.NewQSizeFromPointer(C.QApplication_QApplication_GlobalStrut())
	runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
	return tmpValue
}

func QApplication_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QApplication_QApplication_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QApplication) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QApplication_QApplication_Tr(sC, cC, C.int(int32(n))))
}

func QApplication_SetStyle2(style string) *QStyle {
	var styleC *C.char
	if style != "" {
		styleC = C.CString(style)
		defer C.free(unsafe.Pointer(styleC))
	}
	tmpValue := NewQStyleFromPointer(C.QApplication_QApplication_SetStyle2(C.struct_QtWidgets_PackedString{data: styleC, len: C.longlong(len(style))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) SetStyle2(style string) *QStyle {
	var styleC *C.char
	if style != "" {
		styleC = C.CString(style)
		defer C.free(unsafe.Pointer(styleC))
	}
	tmpValue := NewQStyleFromPointer(C.QApplication_QApplication_SetStyle2(C.struct_QtWidgets_PackedString{data: styleC, len: C.longlong(len(style))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_Style() *QStyle {
	tmpValue := NewQStyleFromPointer(C.QApplication_QApplication_Style())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) Style() *QStyle {
	tmpValue := NewQStyleFromPointer(C.QApplication_QApplication_Style())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_ActiveModalWidget() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_ActiveModalWidget())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) ActiveModalWidget() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_ActiveModalWidget())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_ActivePopupWidget() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_ActivePopupWidget())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) ActivePopupWidget() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_ActivePopupWidget())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_ActiveWindow() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_ActiveWindow())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) ActiveWindow() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_ActiveWindow())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_FocusWidget() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_FocusWidget())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) FocusWidget() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_FocusWidget())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_TopLevelAt(point core.QPoint_ITF) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_TopLevelAt(core.PointerFromQPoint(point)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) TopLevelAt(point core.QPoint_ITF) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_TopLevelAt(core.PointerFromQPoint(point)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_TopLevelAt2(x int, y int) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_TopLevelAt2(C.int(int32(x)), C.int(int32(y))))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) TopLevelAt2(x int, y int) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_TopLevelAt2(C.int(int32(x)), C.int(int32(y))))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_WidgetAt(point core.QPoint_ITF) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_WidgetAt(core.PointerFromQPoint(point)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) WidgetAt(point core.QPoint_ITF) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_WidgetAt(core.PointerFromQPoint(point)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_WidgetAt2(x int, y int) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_WidgetAt2(C.int(int32(x)), C.int(int32(y))))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QApplication) WidgetAt2(x int, y int) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QApplication_QApplication_WidgetAt2(C.int(int32(x)), C.int(int32(y))))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QApplication_AllWidgets() []*QWidget {
	return func(l C.struct_QtWidgets_PackedList) []*QWidget {
		out := make([]*QWidget, int(l.len))
		tmpList := NewQApplicationFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__allWidgets_atList(i)
		}
		return out
	}(C.QApplication_QApplication_AllWidgets())
}

func (ptr *QApplication) AllWidgets() []*QWidget {
	return func(l C.struct_QtWidgets_PackedList) []*QWidget {
		out := make([]*QWidget, int(l.len))
		tmpList := NewQApplicationFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__allWidgets_atList(i)
		}
		return out
	}(C.QApplication_QApplication_AllWidgets())
}

func QApplication_TopLevelWidgets() []*QWidget {
	return func(l C.struct_QtWidgets_PackedList) []*QWidget {
		out := make([]*QWidget, int(l.len))
		tmpList := NewQApplicationFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__topLevelWidgets_atList(i)
		}
		return out
	}(C.QApplication_QApplication_TopLevelWidgets())
}

func (ptr *QApplication) TopLevelWidgets() []*QWidget {
	return func(l C.struct_QtWidgets_PackedList) []*QWidget {
		out := make([]*QWidget, int(l.len))
		tmpList := NewQApplicationFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__topLevelWidgets_atList(i)
		}
		return out
	}(C.QApplication_QApplication_TopLevelWidgets())
}

func QApplication_NavigationMode() core.Qt__NavigationMode {
	return core.Qt__NavigationMode(C.QApplication_QApplication_NavigationMode())
}

func (ptr *QApplication) NavigationMode() core.Qt__NavigationMode {
	return core.Qt__NavigationMode(C.QApplication_QApplication_NavigationMode())
}

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

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

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

func QApplication_IsEffectEnabled(effect core.Qt__UIEffect) bool {
	return int8(C.QApplication_QApplication_IsEffectEnabled(C.longlong(effect))) != 0
}

func (ptr *QApplication) IsEffectEnabled(effect core.Qt__UIEffect) bool {
	return int8(C.QApplication_QApplication_IsEffectEnabled(C.longlong(effect))) != 0
}

func QApplication_CursorFlashTime() int {
	return int(int32(C.QApplication_QApplication_CursorFlashTime()))
}

func (ptr *QApplication) CursorFlashTime() int {
	return int(int32(C.QApplication_QApplication_CursorFlashTime()))
}

func QApplication_DoubleClickInterval() int {
	return int(int32(C.QApplication_QApplication_DoubleClickInterval()))
}

func (ptr *QApplication) DoubleClickInterval() int {
	return int(int32(C.QApplication_QApplication_DoubleClickInterval()))
}

func QApplication_Exec() int {
	return int(int32(C.QApplication_QApplication_Exec()))
}

func (ptr *QApplication) Exec() int {
	return int(int32(C.QApplication_QApplication_Exec()))
}

func QApplication_KeyboardInputInterval() int {
	return int(int32(C.QApplication_QApplication_KeyboardInputInterval()))
}

func (ptr *QApplication) KeyboardInputInterval() int {
	return int(int32(C.QApplication_QApplication_KeyboardInputInterval()))
}

func QApplication_StartDragDistance() int {
	return int(int32(C.QApplication_QApplication_StartDragDistance()))
}

func (ptr *QApplication) StartDragDistance() int {
	return int(int32(C.QApplication_QApplication_StartDragDistance()))
}

func QApplication_StartDragTime() int {
	return int(int32(C.QApplication_QApplication_StartDragTime()))
}

func (ptr *QApplication) StartDragTime() int {
	return int(int32(C.QApplication_QApplication_StartDragTime()))
}

func QApplication_WheelScrollLines() int {
	return int(int32(C.QApplication_QApplication_WheelScrollLines()))
}

func (ptr *QApplication) WheelScrollLines() int {
	return int(int32(C.QApplication_QApplication_WheelScrollLines()))
}

//export callbackQApplication_AboutQt
func callbackQApplication_AboutQt(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "aboutQt"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQApplicationFromPointer(ptr).AboutQtDefault()
	}
}

func (ptr *QApplication) ConnectAboutQt(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) DisconnectAboutQt() {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) AboutQt() {
	if ptr.Pointer() != nil {
		C.QApplication_AboutQt(ptr.Pointer())
	}
}

func (ptr *QApplication) AboutQtDefault() {
	if ptr.Pointer() != nil {
		C.QApplication_AboutQtDefault(ptr.Pointer())
	}
}

func QApplication_Alert(widget QWidget_ITF, msec int) {
	C.QApplication_QApplication_Alert(PointerFromQWidget(widget), C.int(int32(msec)))
}

func (ptr *QApplication) Alert(widget QWidget_ITF, msec int) {
	C.QApplication_QApplication_Alert(PointerFromQWidget(widget), C.int(int32(msec)))
}

func QApplication_Beep() {
	C.QApplication_QApplication_Beep()
}

func (ptr *QApplication) Beep() {
	C.QApplication_QApplication_Beep()
}

//export callbackQApplication_CloseAllWindows
func callbackQApplication_CloseAllWindows(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "closeAllWindows"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQApplicationFromPointer(ptr).CloseAllWindowsDefault()
	}
}

func (ptr *QApplication) ConnectCloseAllWindows(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) DisconnectCloseAllWindows() {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) CloseAllWindows() {
	if ptr.Pointer() != nil {
		C.QApplication_CloseAllWindows(ptr.Pointer())
	}
}

func (ptr *QApplication) CloseAllWindowsDefault() {
	if ptr.Pointer() != nil {
		C.QApplication_CloseAllWindowsDefault(ptr.Pointer())
	}
}

//export callbackQApplication_FocusChanged
func callbackQApplication_FocusChanged(ptr unsafe.Pointer, old unsafe.Pointer, now unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "focusChanged"); signal != nil {
		(*(*func(*QWidget, *QWidget))(signal))(NewQWidgetFromPointer(old), NewQWidgetFromPointer(now))
	}

}

func (ptr *QApplication) ConnectFocusChanged(f func(old *QWidget, now *QWidget)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "focusChanged") {
			C.QApplication_ConnectFocusChanged(ptr.Pointer())
		}

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

func (ptr *QApplication) DisconnectFocusChanged() {
	if ptr.Pointer() != nil {
		C.QApplication_DisconnectFocusChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "focusChanged")
	}
}

func (ptr *QApplication) FocusChanged(old QWidget_ITF, now QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QApplication_FocusChanged(ptr.Pointer(), PointerFromQWidget(old), PointerFromQWidget(now))
	}
}

func QApplication_SetActiveWindow(active QWidget_ITF) {
	C.QApplication_QApplication_SetActiveWindow(PointerFromQWidget(active))
}

func (ptr *QApplication) SetActiveWindow(active QWidget_ITF) {
	C.QApplication_QApplication_SetActiveWindow(PointerFromQWidget(active))
}

//export callbackQApplication_SetAutoSipEnabled
func callbackQApplication_SetAutoSipEnabled(ptr unsafe.Pointer, enabled C.char) {
	if signal := qt.GetSignal(ptr, "setAutoSipEnabled"); signal != nil {
		(*(*func(bool))(signal))(int8(enabled) != 0)
	} else {
		NewQApplicationFromPointer(ptr).SetAutoSipEnabledDefault(int8(enabled) != 0)
	}
}

func (ptr *QApplication) ConnectSetAutoSipEnabled(f func(enabled bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) DisconnectSetAutoSipEnabled() {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) SetAutoSipEnabled(enabled bool) {
	if ptr.Pointer() != nil {
		C.QApplication_SetAutoSipEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QApplication) SetAutoSipEnabledDefault(enabled bool) {
	if ptr.Pointer() != nil {
		C.QApplication_SetAutoSipEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func QApplication_SetCursorFlashTime(vin int) {
	C.QApplication_QApplication_SetCursorFlashTime(C.int(int32(vin)))
}

func (ptr *QApplication) SetCursorFlashTime(vin int) {
	C.QApplication_QApplication_SetCursorFlashTime(C.int(int32(vin)))
}

func QApplication_SetDoubleClickInterval(vin int) {
	C.QApplication_QApplication_SetDoubleClickInterval(C.int(int32(vin)))
}

func (ptr *QApplication) SetDoubleClickInterval(vin int) {
	C.QApplication_QApplication_SetDoubleClickInterval(C.int(int32(vin)))
}

func QApplication_SetEffectEnabled(effect core.Qt__UIEffect, enable bool) {
	C.QApplication_QApplication_SetEffectEnabled(C.longlong(effect), C.char(int8(qt.GoBoolToInt(enable))))
}

func (ptr *QApplication) SetEffectEnabled(effect core.Qt__UIEffect, enable bool) {
	C.QApplication_QApplication_SetEffectEnabled(C.longlong(effect), C.char(int8(qt.GoBoolToInt(enable))))
}

func QApplication_SetFont(font gui.QFont_ITF, className string) {
	var classNameC *C.char
	if className != "" {
		classNameC = C.CString(className)
		defer C.free(unsafe.Pointer(classNameC))
	}
	C.QApplication_QApplication_SetFont(gui.PointerFromQFont(font), classNameC)
}

func (ptr *QApplication) SetFont(font gui.QFont_ITF, className string) {
	var classNameC *C.char
	if className != "" {
		classNameC = C.CString(className)
		defer C.free(unsafe.Pointer(classNameC))
	}
	C.QApplication_QApplication_SetFont(gui.PointerFromQFont(font), classNameC)
}

func QApplication_SetGlobalStrut(vqs core.QSize_ITF) {
	C.QApplication_QApplication_SetGlobalStrut(core.PointerFromQSize(vqs))
}

func (ptr *QApplication) SetGlobalStrut(vqs core.QSize_ITF) {
	C.QApplication_QApplication_SetGlobalStrut(core.PointerFromQSize(vqs))
}

func QApplication_SetKeyboardInputInterval(vin int) {
	C.QApplication_QApplication_SetKeyboardInputInterval(C.int(int32(vin)))
}

func (ptr *QApplication) SetKeyboardInputInterval(vin int) {
	C.QApplication_QApplication_SetKeyboardInputInterval(C.int(int32(vin)))
}

func QApplication_SetNavigationMode(mode core.Qt__NavigationMode) {
	C.QApplication_QApplication_SetNavigationMode(C.longlong(mode))
}

func (ptr *QApplication) SetNavigationMode(mode core.Qt__NavigationMode) {
	C.QApplication_QApplication_SetNavigationMode(C.longlong(mode))
}

func QApplication_SetPalette(palette gui.QPalette_ITF, className string) {
	var classNameC *C.char
	if className != "" {
		classNameC = C.CString(className)
		defer C.free(unsafe.Pointer(classNameC))
	}
	C.QApplication_QApplication_SetPalette(gui.PointerFromQPalette(palette), classNameC)
}

func (ptr *QApplication) SetPalette(palette gui.QPalette_ITF, className string) {
	var classNameC *C.char
	if className != "" {
		classNameC = C.CString(className)
		defer C.free(unsafe.Pointer(classNameC))
	}
	C.QApplication_QApplication_SetPalette(gui.PointerFromQPalette(palette), classNameC)
}

func QApplication_SetStartDragDistance(l int) {
	C.QApplication_QApplication_SetStartDragDistance(C.int(int32(l)))
}

func (ptr *QApplication) SetStartDragDistance(l int) {
	C.QApplication_QApplication_SetStartDragDistance(C.int(int32(l)))
}

func QApplication_SetStartDragTime(ms int) {
	C.QApplication_QApplication_SetStartDragTime(C.int(int32(ms)))
}

func (ptr *QApplication) SetStartDragTime(ms int) {
	C.QApplication_QApplication_SetStartDragTime(C.int(int32(ms)))
}

func QApplication_SetStyle(style QStyle_ITF) {
	C.QApplication_QApplication_SetStyle(PointerFromQStyle(style))
}

func (ptr *QApplication) SetStyle(style QStyle_ITF) {
	C.QApplication_QApplication_SetStyle(PointerFromQStyle(style))
}

//export callbackQApplication_SetStyleSheet
func callbackQApplication_SetStyleSheet(ptr unsafe.Pointer, sheet C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setStyleSheet"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(sheet))
	} else {
		NewQApplicationFromPointer(ptr).SetStyleSheetDefault(cGoUnpackString(sheet))
	}
}

func (ptr *QApplication) ConnectSetStyleSheet(f func(sheet string)) {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) DisconnectSetStyleSheet() {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) SetStyleSheet(sheet string) {
	if ptr.Pointer() != nil {
		var sheetC *C.char
		if sheet != "" {
			sheetC = C.CString(sheet)
			defer C.free(unsafe.Pointer(sheetC))
		}
		C.QApplication_SetStyleSheet(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: sheetC, len: C.longlong(len(sheet))})
	}
}

func (ptr *QApplication) SetStyleSheetDefault(sheet string) {
	if ptr.Pointer() != nil {
		var sheetC *C.char
		if sheet != "" {
			sheetC = C.CString(sheet)
			defer C.free(unsafe.Pointer(sheetC))
		}
		C.QApplication_SetStyleSheetDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: sheetC, len: C.longlong(len(sheet))})
	}
}

func QApplication_SetWheelScrollLines(vin int) {
	C.QApplication_QApplication_SetWheelScrollLines(C.int(int32(vin)))
}

func (ptr *QApplication) SetWheelScrollLines(vin int) {
	C.QApplication_QApplication_SetWheelScrollLines(C.int(int32(vin)))
}

func QApplication_SetWindowIcon(icon gui.QIcon_ITF) {
	C.QApplication_QApplication_SetWindowIcon(gui.PointerFromQIcon(icon))
}

func (ptr *QApplication) SetWindowIcon(icon gui.QIcon_ITF) {
	C.QApplication_QApplication_SetWindowIcon(gui.PointerFromQIcon(icon))
}

//export callbackQApplication_DestroyQApplication
func callbackQApplication_DestroyQApplication(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QApplication"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQApplicationFromPointer(ptr).DestroyQApplicationDefault()
	}
}

func (ptr *QApplication) ConnectDestroyQApplication(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) DisconnectDestroyQApplication() {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) DestroyQApplication() {
	if ptr.Pointer() != nil {
		C.QApplication_DestroyQApplication(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QApplication) DestroyQApplicationDefault() {
	if ptr.Pointer() != nil {
		C.QApplication_DestroyQApplicationDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QApplication) StyleSheet() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QApplication_StyleSheet(ptr.Pointer()))
	}
	return ""
}

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

	return C.char(int8(qt.GoBoolToInt(NewQApplicationFromPointer(ptr).AutoSipEnabledDefault())))
}

func (ptr *QApplication) ConnectAutoSipEnabled(f func() bool) {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) DisconnectAutoSipEnabled() {
	if ptr.Pointer() != nil {

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

func (ptr *QApplication) AutoSipEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QApplication_AutoSipEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QApplication) AutoSipEnabledDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QApplication_AutoSipEnabledDefault(ptr.Pointer())) != 0
	}
	return false
}

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

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

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

func (ptr *QApplication) __allWidgets_atList(i int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QApplication___allWidgets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QApplication) __allWidgets_setList(i QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QApplication___allWidgets_setList(ptr.Pointer(), PointerFromQWidget(i))
	}
}

func (ptr *QApplication) __allWidgets_newList() unsafe.Pointer {
	return C.QApplication___allWidgets_newList(ptr.Pointer())
}

func (ptr *QApplication) __topLevelWidgets_atList(i int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QApplication___topLevelWidgets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QApplication) __topLevelWidgets_setList(i QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QApplication___topLevelWidgets_setList(ptr.Pointer(), PointerFromQWidget(i))
	}
}

func (ptr *QApplication) __topLevelWidgets_newList() unsafe.Pointer {
	return C.QApplication___topLevelWidgets_newList(ptr.Pointer())
}

func (ptr *QApplication) __screens_atList(i int) *gui.QScreen {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQScreenFromPointer(C.QApplication___screens_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QApplication) __screens_setList(i gui.QScreen_ITF) {
	if ptr.Pointer() != nil {
		C.QApplication___screens_setList(ptr.Pointer(), gui.PointerFromQScreen(i))
	}
}

func (ptr *QApplication) __screens_newList() unsafe.Pointer {
	return C.QApplication___screens_newList(ptr.Pointer())
}

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

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

func (ptr *QApplication) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QApplication___dynamicPropertyNames_newList(ptr.Pointer())
}

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

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

func (ptr *QApplication) __findChildren_newList2() unsafe.Pointer {
	return C.QApplication___findChildren_newList2(ptr.Pointer())
}

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

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

func (ptr *QApplication) __findChildren_newList3() unsafe.Pointer {
	return C.QApplication___findChildren_newList3(ptr.Pointer())
}

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

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

func (ptr *QApplication) __findChildren_newList() unsafe.Pointer {
	return C.QApplication___findChildren_newList(ptr.Pointer())
}

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

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

func (ptr *QApplication) __children_newList() unsafe.Pointer {
	return C.QApplication___children_newList(ptr.Pointer())
}

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

}

//export callbackQApplication_ApplicationStateChanged
func callbackQApplication_ApplicationStateChanged(ptr unsafe.Pointer, state C.longlong) {
	if signal := qt.GetSignal(ptr, "applicationStateChanged"); signal != nil {
		(*(*func(core.Qt__ApplicationState))(signal))(core.Qt__ApplicationState(state))
	}

}

//export callbackQApplication_CommitDataRequest
func callbackQApplication_CommitDataRequest(ptr unsafe.Pointer, manager unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "commitDataRequest"); signal != nil {
		(*(*func(*gui.QSessionManager))(signal))(gui.NewQSessionManagerFromPointer(manager))
	}

}

//export callbackQApplication_FocusObjectChanged
func callbackQApplication_FocusObjectChanged(ptr unsafe.Pointer, focusObject unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "focusObjectChanged"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(focusObject))
	}

}

//export callbackQApplication_FocusWindowChanged
func callbackQApplication_FocusWindowChanged(ptr unsafe.Pointer, focusWindow unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "focusWindowChanged"); signal != nil {
		(*(*func(*gui.QWindow))(signal))(gui.NewQWindowFromPointer(focusWindow))
	}

}

//export callbackQApplication_FontChanged
func callbackQApplication_FontChanged(ptr unsafe.Pointer, font unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "fontChanged"); signal != nil {
		(*(*func(*gui.QFont))(signal))(gui.NewQFontFromPointer(font))
	}

}

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

}

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

}

//export callbackQApplication_LayoutDirectionChanged
func callbackQApplication_LayoutDirectionChanged(ptr unsafe.Pointer, direction C.longlong) {
	if signal := qt.GetSignal(ptr, "layoutDirectionChanged"); signal != nil {
		(*(*func(core.Qt__LayoutDirection))(signal))(core.Qt__LayoutDirection(direction))
	}

}

//export callbackQApplication_PaletteChanged
func callbackQApplication_PaletteChanged(ptr unsafe.Pointer, palette unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paletteChanged"); signal != nil {
		(*(*func(*gui.QPalette))(signal))(gui.NewQPaletteFromPointer(palette))
	}

}

//export callbackQApplication_PrimaryScreenChanged
func callbackQApplication_PrimaryScreenChanged(ptr unsafe.Pointer, screen unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "primaryScreenChanged"); signal != nil {
		(*(*func(*gui.QScreen))(signal))(gui.NewQScreenFromPointer(screen))
	}

}

//export callbackQApplication_SaveStateRequest
func callbackQApplication_SaveStateRequest(ptr unsafe.Pointer, manager unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "saveStateRequest"); signal != nil {
		(*(*func(*gui.QSessionManager))(signal))(gui.NewQSessionManagerFromPointer(manager))
	}

}

//export callbackQApplication_ScreenAdded
func callbackQApplication_ScreenAdded(ptr unsafe.Pointer, screen unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "screenAdded"); signal != nil {
		(*(*func(*gui.QScreen))(signal))(gui.NewQScreenFromPointer(screen))
	}

}

//export callbackQApplication_ScreenRemoved
func callbackQApplication_ScreenRemoved(ptr unsafe.Pointer, screen unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "screenRemoved"); signal != nil {
		(*(*func(*gui.QScreen))(signal))(gui.NewQScreenFromPointer(screen))
	}

}

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

}

//export callbackQApplication_Quit
func callbackQApplication_Quit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "quit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQApplicationFromPointer(ptr).QuitDefault()
	}
}

func (ptr *QApplication) QuitDefault() {
	if ptr.Pointer() != nil {
		C.QApplication_QuitDefault(ptr.Pointer())
	}
}

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

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

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

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

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

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

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

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

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

//export callbackQApplication_DeleteLater
func callbackQApplication_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQApplicationFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QApplication) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QApplication_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

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

}

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

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

//export callbackQApplication_ObjectNameChanged
func callbackQApplication_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

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

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

type QBoxLayout struct {
	QLayout
}

type QBoxLayout_ITF interface {
	QLayout_ITF
	QBoxLayout_PTR() *QBoxLayout
}

func (ptr *QBoxLayout) QBoxLayout_PTR() *QBoxLayout {
	return ptr
}

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

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

func PointerFromQBoxLayout(ptr QBoxLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBoxLayout_PTR().Pointer()
	}
	return nil
}

func NewQBoxLayoutFromPointer(ptr unsafe.Pointer) (n *QBoxLayout) {
	n = new(QBoxLayout)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QBoxLayout__Direction
//QBoxLayout::Direction
type QBoxLayout__Direction int64

const (
	QBoxLayout__LeftToRight QBoxLayout__Direction = QBoxLayout__Direction(0)
	QBoxLayout__RightToLeft QBoxLayout__Direction = QBoxLayout__Direction(1)
	QBoxLayout__TopToBottom QBoxLayout__Direction = QBoxLayout__Direction(2)
	QBoxLayout__BottomToTop QBoxLayout__Direction = QBoxLayout__Direction(3)
	QBoxLayout__Down        QBoxLayout__Direction = QBoxLayout__Direction(QBoxLayout__TopToBottom)
	QBoxLayout__Up          QBoxLayout__Direction = QBoxLayout__Direction(QBoxLayout__BottomToTop)
)

func NewQBoxLayout(dir QBoxLayout__Direction, parent QWidget_ITF) *QBoxLayout {
	tmpValue := NewQBoxLayoutFromPointer(C.QBoxLayout_NewQBoxLayout(C.longlong(dir), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQBoxLayout_TakeAt
func callbackQBoxLayout_TakeAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "takeAt"); signal != nil {
		return PointerFromQLayoutItem((*(*func(int) *QLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQLayoutItem(NewQBoxLayoutFromPointer(ptr).TakeAtDefault(int(int32(index))))
}

func (ptr *QBoxLayout) ConnectTakeAt(f func(index int) *QLayoutItem) {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) DisconnectTakeAt() {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) TakeAt(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QBoxLayout_TakeAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QBoxLayout) TakeAtDefault(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QBoxLayout_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QBoxLayout) SetStretchFactor2(layout QLayout_ITF, stretch int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QBoxLayout_SetStretchFactor2(ptr.Pointer(), PointerFromQLayout(layout), C.int(int32(stretch)))) != 0
	}
	return false
}

func (ptr *QBoxLayout) SetStretchFactor(widget QWidget_ITF, stretch int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QBoxLayout_SetStretchFactor(ptr.Pointer(), PointerFromQWidget(widget), C.int(int32(stretch)))) != 0
	}
	return false
}

//export callbackQBoxLayout_AddItem
func callbackQBoxLayout_AddItem(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "addItem"); signal != nil {
		(*(*func(*QLayoutItem))(signal))(NewQLayoutItemFromPointer(item))
	} else {
		NewQBoxLayoutFromPointer(ptr).AddItemDefault(NewQLayoutItemFromPointer(item))
	}
}

func (ptr *QBoxLayout) ConnectAddItem(f func(item *QLayoutItem)) {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) DisconnectAddItem() {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) AddItem(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_AddItem(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

func (ptr *QBoxLayout) AddItemDefault(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_AddItemDefault(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

func (ptr *QBoxLayout) AddLayout(layout QLayout_ITF, stretch int) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_AddLayout(ptr.Pointer(), PointerFromQLayout(layout), C.int(int32(stretch)))
	}
}

func (ptr *QBoxLayout) AddSpacerItem(spacerItem QSpacerItem_ITF) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_AddSpacerItem(ptr.Pointer(), PointerFromQSpacerItem(spacerItem))
	}
}

func (ptr *QBoxLayout) AddSpacing(size int) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_AddSpacing(ptr.Pointer(), C.int(int32(size)))
	}
}

func (ptr *QBoxLayout) AddStretch(stretch int) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_AddStretch(ptr.Pointer(), C.int(int32(stretch)))
	}
}

func (ptr *QBoxLayout) AddStrut(size int) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_AddStrut(ptr.Pointer(), C.int(int32(size)))
	}
}

func (ptr *QBoxLayout) AddWidget(widget QWidget_ITF, stretch int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_AddWidget(ptr.Pointer(), PointerFromQWidget(widget), C.int(int32(stretch)), C.longlong(alignment))
	}
}

func (ptr *QBoxLayout) InsertItem(index int, item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_InsertItem(ptr.Pointer(), C.int(int32(index)), PointerFromQLayoutItem(item))
	}
}

func (ptr *QBoxLayout) InsertLayout(index int, layout QLayout_ITF, stretch int) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_InsertLayout(ptr.Pointer(), C.int(int32(index)), PointerFromQLayout(layout), C.int(int32(stretch)))
	}
}

func (ptr *QBoxLayout) InsertSpacerItem(index int, spacerItem QSpacerItem_ITF) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_InsertSpacerItem(ptr.Pointer(), C.int(int32(index)), PointerFromQSpacerItem(spacerItem))
	}
}

func (ptr *QBoxLayout) InsertSpacing(index int, size int) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_InsertSpacing(ptr.Pointer(), C.int(int32(index)), C.int(int32(size)))
	}
}

func (ptr *QBoxLayout) InsertStretch(index int, stretch int) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_InsertStretch(ptr.Pointer(), C.int(int32(index)), C.int(int32(stretch)))
	}
}

func (ptr *QBoxLayout) InsertWidget(index int, widget QWidget_ITF, stretch int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_InsertWidget(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(widget), C.int(int32(stretch)), C.longlong(alignment))
	}
}

func (ptr *QBoxLayout) SetDirection(direction QBoxLayout__Direction) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_SetDirection(ptr.Pointer(), C.longlong(direction))
	}
}

func (ptr *QBoxLayout) SetStretch(index int, stretch int) {
	if ptr.Pointer() != nil {
		C.QBoxLayout_SetStretch(ptr.Pointer(), C.int(int32(index)), C.int(int32(stretch)))
	}
}

//export callbackQBoxLayout_DestroyQBoxLayout
func callbackQBoxLayout_DestroyQBoxLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QBoxLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQBoxLayoutFromPointer(ptr).DestroyQBoxLayoutDefault()
	}
}

func (ptr *QBoxLayout) ConnectDestroyQBoxLayout(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) DisconnectDestroyQBoxLayout() {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) DestroyQBoxLayout() {
	if ptr.Pointer() != nil {
		C.QBoxLayout_DestroyQBoxLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QBoxLayout) DestroyQBoxLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QBoxLayout_DestroyQBoxLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QBoxLayout) Direction() QBoxLayout__Direction {
	if ptr.Pointer() != nil {
		return QBoxLayout__Direction(C.QBoxLayout_Direction(ptr.Pointer()))
	}
	return 0
}

//export callbackQBoxLayout_ItemAt
func callbackQBoxLayout_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemAt"); signal != nil {
		return PointerFromQLayoutItem((*(*func(int) *QLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQLayoutItem(NewQBoxLayoutFromPointer(ptr).ItemAtDefault(int(int32(index))))
}

func (ptr *QBoxLayout) ConnectItemAt(f func(index int) *QLayoutItem) {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) DisconnectItemAt() {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) ItemAt(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QBoxLayout_ItemAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QBoxLayout) ItemAtDefault(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QBoxLayout_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

//export callbackQBoxLayout_SizeHint
func callbackQBoxLayout_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQBoxLayoutFromPointer(ptr).SizeHintDefault())
}

func (ptr *QBoxLayout) ConnectSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QBoxLayout_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QBoxLayout) SizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QBoxLayout_SizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

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

	return C.int(int32(NewQBoxLayoutFromPointer(ptr).CountDefault()))
}

func (ptr *QBoxLayout) ConnectCount(f func() int) {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) DisconnectCount() {
	if ptr.Pointer() != nil {

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

func (ptr *QBoxLayout) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QBoxLayout_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QBoxLayout) CountDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QBoxLayout_CountDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QBoxLayout) Stretch(index int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QBoxLayout_Stretch(ptr.Pointer(), C.int(int32(index)))))
	}
	return 0
}

type QButtonGroup struct {
	core.QObject
}

type QButtonGroup_ITF interface {
	core.QObject_ITF
	QButtonGroup_PTR() *QButtonGroup
}

func (ptr *QButtonGroup) QButtonGroup_PTR() *QButtonGroup {
	return ptr
}

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

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

func PointerFromQButtonGroup(ptr QButtonGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QButtonGroup_PTR().Pointer()
	}
	return nil
}

func NewQButtonGroupFromPointer(ptr unsafe.Pointer) (n *QButtonGroup) {
	n = new(QButtonGroup)
	n.SetPointer(ptr)
	return
}
func NewQButtonGroup(parent core.QObject_ITF) *QButtonGroup {
	tmpValue := NewQButtonGroupFromPointer(C.QButtonGroup_NewQButtonGroup(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QButtonGroup_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QButtonGroup_QButtonGroup_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QButtonGroup) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QButtonGroup_QButtonGroup_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QButtonGroup) AddButton(button QAbstractButton_ITF, id int) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_AddButton(ptr.Pointer(), PointerFromQAbstractButton(button), C.int(int32(id)))
	}
}

//export callbackQButtonGroup_ButtonClicked
func callbackQButtonGroup_ButtonClicked(ptr unsafe.Pointer, button unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "buttonClicked"); signal != nil {
		(*(*func(*QAbstractButton))(signal))(NewQAbstractButtonFromPointer(button))
	}

}

func (ptr *QButtonGroup) ConnectButtonClicked(f func(button *QAbstractButton)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "buttonClicked") {
			C.QButtonGroup_ConnectButtonClicked(ptr.Pointer())
		}

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

func (ptr *QButtonGroup) DisconnectButtonClicked() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DisconnectButtonClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "buttonClicked")
	}
}

func (ptr *QButtonGroup) ButtonClicked(button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_ButtonClicked(ptr.Pointer(), PointerFromQAbstractButton(button))
	}
}

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

}

func (ptr *QButtonGroup) ConnectButtonClicked2(f func(id int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "buttonClicked2") {
			C.QButtonGroup_ConnectButtonClicked2(ptr.Pointer())
		}

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

func (ptr *QButtonGroup) DisconnectButtonClicked2() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DisconnectButtonClicked2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "buttonClicked2")
	}
}

func (ptr *QButtonGroup) ButtonClicked2(id int) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_ButtonClicked2(ptr.Pointer(), C.int(int32(id)))
	}
}

//export callbackQButtonGroup_ButtonPressed
func callbackQButtonGroup_ButtonPressed(ptr unsafe.Pointer, button unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "buttonPressed"); signal != nil {
		(*(*func(*QAbstractButton))(signal))(NewQAbstractButtonFromPointer(button))
	}

}

func (ptr *QButtonGroup) ConnectButtonPressed(f func(button *QAbstractButton)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "buttonPressed") {
			C.QButtonGroup_ConnectButtonPressed(ptr.Pointer())
		}

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

func (ptr *QButtonGroup) DisconnectButtonPressed() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DisconnectButtonPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "buttonPressed")
	}
}

func (ptr *QButtonGroup) ButtonPressed(button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_ButtonPressed(ptr.Pointer(), PointerFromQAbstractButton(button))
	}
}

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

}

func (ptr *QButtonGroup) ConnectButtonPressed2(f func(id int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "buttonPressed2") {
			C.QButtonGroup_ConnectButtonPressed2(ptr.Pointer())
		}

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

func (ptr *QButtonGroup) DisconnectButtonPressed2() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DisconnectButtonPressed2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "buttonPressed2")
	}
}

func (ptr *QButtonGroup) ButtonPressed2(id int) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_ButtonPressed2(ptr.Pointer(), C.int(int32(id)))
	}
}

//export callbackQButtonGroup_ButtonReleased
func callbackQButtonGroup_ButtonReleased(ptr unsafe.Pointer, button unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "buttonReleased"); signal != nil {
		(*(*func(*QAbstractButton))(signal))(NewQAbstractButtonFromPointer(button))
	}

}

func (ptr *QButtonGroup) ConnectButtonReleased(f func(button *QAbstractButton)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "buttonReleased") {
			C.QButtonGroup_ConnectButtonReleased(ptr.Pointer())
		}

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

func (ptr *QButtonGroup) DisconnectButtonReleased() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DisconnectButtonReleased(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "buttonReleased")
	}
}

func (ptr *QButtonGroup) ButtonReleased(button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_ButtonReleased(ptr.Pointer(), PointerFromQAbstractButton(button))
	}
}

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

}

func (ptr *QButtonGroup) ConnectButtonReleased2(f func(id int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "buttonReleased2") {
			C.QButtonGroup_ConnectButtonReleased2(ptr.Pointer())
		}

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

func (ptr *QButtonGroup) DisconnectButtonReleased2() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DisconnectButtonReleased2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "buttonReleased2")
	}
}

func (ptr *QButtonGroup) ButtonReleased2(id int) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_ButtonReleased2(ptr.Pointer(), C.int(int32(id)))
	}
}

//export callbackQButtonGroup_ButtonToggled
func callbackQButtonGroup_ButtonToggled(ptr unsafe.Pointer, button unsafe.Pointer, checked C.char) {
	if signal := qt.GetSignal(ptr, "buttonToggled"); signal != nil {
		(*(*func(*QAbstractButton, bool))(signal))(NewQAbstractButtonFromPointer(button), int8(checked) != 0)
	}

}

func (ptr *QButtonGroup) ConnectButtonToggled(f func(button *QAbstractButton, checked bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "buttonToggled") {
			C.QButtonGroup_ConnectButtonToggled(ptr.Pointer())
		}

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

func (ptr *QButtonGroup) DisconnectButtonToggled() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DisconnectButtonToggled(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "buttonToggled")
	}
}

func (ptr *QButtonGroup) ButtonToggled(button QAbstractButton_ITF, checked bool) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_ButtonToggled(ptr.Pointer(), PointerFromQAbstractButton(button), C.char(int8(qt.GoBoolToInt(checked))))
	}
}

//export callbackQButtonGroup_ButtonToggled2
func callbackQButtonGroup_ButtonToggled2(ptr unsafe.Pointer, id C.int, checked C.char) {
	if signal := qt.GetSignal(ptr, "buttonToggled2"); signal != nil {
		(*(*func(int, bool))(signal))(int(int32(id)), int8(checked) != 0)
	}

}

func (ptr *QButtonGroup) ConnectButtonToggled2(f func(id int, checked bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "buttonToggled2") {
			C.QButtonGroup_ConnectButtonToggled2(ptr.Pointer())
		}

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

func (ptr *QButtonGroup) DisconnectButtonToggled2() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DisconnectButtonToggled2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "buttonToggled2")
	}
}

func (ptr *QButtonGroup) ButtonToggled2(id int, checked bool) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_ButtonToggled2(ptr.Pointer(), C.int(int32(id)), C.char(int8(qt.GoBoolToInt(checked))))
	}
}

func (ptr *QButtonGroup) RemoveButton(button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_RemoveButton(ptr.Pointer(), PointerFromQAbstractButton(button))
	}
}

func (ptr *QButtonGroup) SetExclusive(vbo bool) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_SetExclusive(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QButtonGroup) SetId(button QAbstractButton_ITF, id int) {
	if ptr.Pointer() != nil {
		C.QButtonGroup_SetId(ptr.Pointer(), PointerFromQAbstractButton(button), C.int(int32(id)))
	}
}

//export callbackQButtonGroup_DestroyQButtonGroup
func callbackQButtonGroup_DestroyQButtonGroup(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QButtonGroup"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQButtonGroupFromPointer(ptr).DestroyQButtonGroupDefault()
	}
}

func (ptr *QButtonGroup) ConnectDestroyQButtonGroup(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QButtonGroup) DisconnectDestroyQButtonGroup() {
	if ptr.Pointer() != nil {

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

func (ptr *QButtonGroup) DestroyQButtonGroup() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DestroyQButtonGroup(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QButtonGroup) DestroyQButtonGroupDefault() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DestroyQButtonGroupDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QButtonGroup) Button(id int) *QAbstractButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractButtonFromPointer(C.QButtonGroup_Button(ptr.Pointer(), C.int(int32(id))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QButtonGroup) CheckedButton() *QAbstractButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractButtonFromPointer(C.QButtonGroup_CheckedButton(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QButtonGroup) Buttons() []*QAbstractButton {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QAbstractButton {
			out := make([]*QAbstractButton, int(l.len))
			tmpList := NewQButtonGroupFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__buttons_atList(i)
			}
			return out
		}(C.QButtonGroup_Buttons(ptr.Pointer()))
	}
	return make([]*QAbstractButton, 0)
}

func (ptr *QButtonGroup) Exclusive() bool {
	if ptr.Pointer() != nil {
		return int8(C.QButtonGroup_Exclusive(ptr.Pointer())) != 0
	}
	return false
}

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

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

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

func (ptr *QButtonGroup) CheckedId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QButtonGroup_CheckedId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QButtonGroup) Id(button QAbstractButton_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QButtonGroup_Id(ptr.Pointer(), PointerFromQAbstractButton(button))))
	}
	return 0
}

func (ptr *QButtonGroup) __buttons_atList(i int) *QAbstractButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractButtonFromPointer(C.QButtonGroup___buttons_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QButtonGroup) __buttons_setList(i QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QButtonGroup___buttons_setList(ptr.Pointer(), PointerFromQAbstractButton(i))
	}
}

func (ptr *QButtonGroup) __buttons_newList() unsafe.Pointer {
	return C.QButtonGroup___buttons_newList(ptr.Pointer())
}

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

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

func (ptr *QButtonGroup) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QButtonGroup___dynamicPropertyNames_newList(ptr.Pointer())
}

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

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

func (ptr *QButtonGroup) __findChildren_newList2() unsafe.Pointer {
	return C.QButtonGroup___findChildren_newList2(ptr.Pointer())
}

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

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

func (ptr *QButtonGroup) __findChildren_newList3() unsafe.Pointer {
	return C.QButtonGroup___findChildren_newList3(ptr.Pointer())
}

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

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

func (ptr *QButtonGroup) __findChildren_newList() unsafe.Pointer {
	return C.QButtonGroup___findChildren_newList(ptr.Pointer())
}

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

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

func (ptr *QButtonGroup) __children_newList() unsafe.Pointer {
	return C.QButtonGroup___children_newList(ptr.Pointer())
}

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

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

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

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

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

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

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

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

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

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

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

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

//export callbackQButtonGroup_DeleteLater
func callbackQButtonGroup_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQButtonGroupFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QButtonGroup) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QButtonGroup_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

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

}

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

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

//export callbackQButtonGroup_ObjectNameChanged
func callbackQButtonGroup_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

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

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

type QCalendarWidget struct {
	QWidget
}

type QCalendarWidget_ITF interface {
	QWidget_ITF
	QCalendarWidget_PTR() *QCalendarWidget
}

func (ptr *QCalendarWidget) QCalendarWidget_PTR() *QCalendarWidget {
	return ptr
}

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

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

func PointerFromQCalendarWidget(ptr QCalendarWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCalendarWidget_PTR().Pointer()
	}
	return nil
}

func NewQCalendarWidgetFromPointer(ptr unsafe.Pointer) (n *QCalendarWidget) {
	n = new(QCalendarWidget)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QCalendarWidget__HorizontalHeaderFormat
//QCalendarWidget::HorizontalHeaderFormat
type QCalendarWidget__HorizontalHeaderFormat int64

const (
	QCalendarWidget__NoHorizontalHeader   QCalendarWidget__HorizontalHeaderFormat = QCalendarWidget__HorizontalHeaderFormat(0)
	QCalendarWidget__SingleLetterDayNames QCalendarWidget__HorizontalHeaderFormat = QCalendarWidget__HorizontalHeaderFormat(1)
	QCalendarWidget__ShortDayNames        QCalendarWidget__HorizontalHeaderFormat = QCalendarWidget__HorizontalHeaderFormat(2)
	QCalendarWidget__LongDayNames         QCalendarWidget__HorizontalHeaderFormat = QCalendarWidget__HorizontalHeaderFormat(3)
)

//go:generate stringer -type=QCalendarWidget__SelectionMode
//QCalendarWidget::SelectionMode
type QCalendarWidget__SelectionMode int64

const (
	QCalendarWidget__NoSelection     QCalendarWidget__SelectionMode = QCalendarWidget__SelectionMode(0)
	QCalendarWidget__SingleSelection QCalendarWidget__SelectionMode = QCalendarWidget__SelectionMode(1)
)

//go:generate stringer -type=QCalendarWidget__VerticalHeaderFormat
//QCalendarWidget::VerticalHeaderFormat
type QCalendarWidget__VerticalHeaderFormat int64

const (
	QCalendarWidget__NoVerticalHeader QCalendarWidget__VerticalHeaderFormat = QCalendarWidget__VerticalHeaderFormat(0)
	QCalendarWidget__ISOWeekNumbers   QCalendarWidget__VerticalHeaderFormat = QCalendarWidget__VerticalHeaderFormat(1)
)

func NewQCalendarWidget(parent QWidget_ITF) *QCalendarWidget {
	tmpValue := NewQCalendarWidgetFromPointer(C.QCalendarWidget_NewQCalendarWidget(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQCalendarWidget_Activated
func callbackQCalendarWidget_Activated(ptr unsafe.Pointer, date unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "activated"); signal != nil {
		(*(*func(*core.QDate))(signal))(core.NewQDateFromPointer(date))
	}

}

func (ptr *QCalendarWidget) ConnectActivated(f func(date *core.QDate)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activated") {
			C.QCalendarWidget_ConnectActivated(ptr.Pointer())
		}

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

func (ptr *QCalendarWidget) DisconnectActivated() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_DisconnectActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activated")
	}
}

func (ptr *QCalendarWidget) Activated(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_Activated(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

//export callbackQCalendarWidget_Clicked
func callbackQCalendarWidget_Clicked(ptr unsafe.Pointer, date unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clicked"); signal != nil {
		(*(*func(*core.QDate))(signal))(core.NewQDateFromPointer(date))
	}

}

func (ptr *QCalendarWidget) ConnectClicked(f func(date *core.QDate)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "clicked") {
			C.QCalendarWidget_ConnectClicked(ptr.Pointer())
		}

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

func (ptr *QCalendarWidget) DisconnectClicked() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_DisconnectClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "clicked")
	}
}

func (ptr *QCalendarWidget) Clicked(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_Clicked(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

//export callbackQCalendarWidget_CurrentPageChanged
func callbackQCalendarWidget_CurrentPageChanged(ptr unsafe.Pointer, year C.int, month C.int) {
	if signal := qt.GetSignal(ptr, "currentPageChanged"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(year)), int(int32(month)))
	}

}

func (ptr *QCalendarWidget) ConnectCurrentPageChanged(f func(year int, month int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentPageChanged") {
			C.QCalendarWidget_ConnectCurrentPageChanged(ptr.Pointer())
		}

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

func (ptr *QCalendarWidget) DisconnectCurrentPageChanged() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_DisconnectCurrentPageChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentPageChanged")
	}
}

func (ptr *QCalendarWidget) CurrentPageChanged(year int, month int) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_CurrentPageChanged(ptr.Pointer(), C.int(int32(year)), C.int(int32(month)))
	}
}

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

}

func (ptr *QCalendarWidget) ConnectSelectionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "selectionChanged") {
			C.QCalendarWidget_ConnectSelectionChanged(ptr.Pointer())
		}

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

func (ptr *QCalendarWidget) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_DisconnectSelectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "selectionChanged")
	}
}

func (ptr *QCalendarWidget) SelectionChanged() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SelectionChanged(ptr.Pointer())
	}
}

//export callbackQCalendarWidget_SetCurrentPage
func callbackQCalendarWidget_SetCurrentPage(ptr unsafe.Pointer, year C.int, month C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentPage"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(year)), int(int32(month)))
	} else {
		NewQCalendarWidgetFromPointer(ptr).SetCurrentPageDefault(int(int32(year)), int(int32(month)))
	}
}

func (ptr *QCalendarWidget) ConnectSetCurrentPage(f func(year int, month int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectSetCurrentPage() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) SetCurrentPage(year int, month int) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetCurrentPage(ptr.Pointer(), C.int(int32(year)), C.int(int32(month)))
	}
}

func (ptr *QCalendarWidget) SetCurrentPageDefault(year int, month int) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetCurrentPageDefault(ptr.Pointer(), C.int(int32(year)), C.int(int32(month)))
	}
}

func (ptr *QCalendarWidget) SetDateEditAcceptDelay(delay int) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetDateEditAcceptDelay(ptr.Pointer(), C.int(int32(delay)))
	}
}

func (ptr *QCalendarWidget) SetDateEditEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetDateEditEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQCalendarWidget_SetDateRange
func callbackQCalendarWidget_SetDateRange(ptr unsafe.Pointer, min unsafe.Pointer, max unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setDateRange"); signal != nil {
		(*(*func(*core.QDate, *core.QDate))(signal))(core.NewQDateFromPointer(min), core.NewQDateFromPointer(max))
	} else {
		NewQCalendarWidgetFromPointer(ptr).SetDateRangeDefault(core.NewQDateFromPointer(min), core.NewQDateFromPointer(max))
	}
}

func (ptr *QCalendarWidget) ConnectSetDateRange(f func(min *core.QDate, max *core.QDate)) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectSetDateRange() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) SetDateRange(min core.QDate_ITF, max core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetDateRange(ptr.Pointer(), core.PointerFromQDate(min), core.PointerFromQDate(max))
	}
}

func (ptr *QCalendarWidget) SetDateRangeDefault(min core.QDate_ITF, max core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetDateRangeDefault(ptr.Pointer(), core.PointerFromQDate(min), core.PointerFromQDate(max))
	}
}

func (ptr *QCalendarWidget) SetDateTextFormat(date core.QDate_ITF, format gui.QTextCharFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetDateTextFormat(ptr.Pointer(), core.PointerFromQDate(date), gui.PointerFromQTextCharFormat(format))
	}
}

func (ptr *QCalendarWidget) SetFirstDayOfWeek(dayOfWeek core.Qt__DayOfWeek) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetFirstDayOfWeek(ptr.Pointer(), C.longlong(dayOfWeek))
	}
}

//export callbackQCalendarWidget_SetGridVisible
func callbackQCalendarWidget_SetGridVisible(ptr unsafe.Pointer, show C.char) {
	if signal := qt.GetSignal(ptr, "setGridVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(show) != 0)
	} else {
		NewQCalendarWidgetFromPointer(ptr).SetGridVisibleDefault(int8(show) != 0)
	}
}

func (ptr *QCalendarWidget) ConnectSetGridVisible(f func(show bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectSetGridVisible() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) SetGridVisible(show bool) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetGridVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(show))))
	}
}

func (ptr *QCalendarWidget) SetGridVisibleDefault(show bool) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetGridVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(show))))
	}
}

func (ptr *QCalendarWidget) SetHeaderTextFormat(format gui.QTextCharFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetHeaderTextFormat(ptr.Pointer(), gui.PointerFromQTextCharFormat(format))
	}
}

func (ptr *QCalendarWidget) SetHorizontalHeaderFormat(format QCalendarWidget__HorizontalHeaderFormat) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetHorizontalHeaderFormat(ptr.Pointer(), C.longlong(format))
	}
}

func (ptr *QCalendarWidget) SetMaximumDate(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetMaximumDate(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

func (ptr *QCalendarWidget) SetMinimumDate(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetMinimumDate(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

//export callbackQCalendarWidget_SetNavigationBarVisible
func callbackQCalendarWidget_SetNavigationBarVisible(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(ptr, "setNavigationBarVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(visible) != 0)
	} else {
		NewQCalendarWidgetFromPointer(ptr).SetNavigationBarVisibleDefault(int8(visible) != 0)
	}
}

func (ptr *QCalendarWidget) ConnectSetNavigationBarVisible(f func(visible bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectSetNavigationBarVisible() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) SetNavigationBarVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetNavigationBarVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QCalendarWidget) SetNavigationBarVisibleDefault(visible bool) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetNavigationBarVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQCalendarWidget_SetSelectedDate
func callbackQCalendarWidget_SetSelectedDate(ptr unsafe.Pointer, date unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setSelectedDate"); signal != nil {
		(*(*func(*core.QDate))(signal))(core.NewQDateFromPointer(date))
	} else {
		NewQCalendarWidgetFromPointer(ptr).SetSelectedDateDefault(core.NewQDateFromPointer(date))
	}
}

func (ptr *QCalendarWidget) ConnectSetSelectedDate(f func(date *core.QDate)) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectSetSelectedDate() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) SetSelectedDate(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetSelectedDate(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

func (ptr *QCalendarWidget) SetSelectedDateDefault(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetSelectedDateDefault(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

func (ptr *QCalendarWidget) SetSelectionMode(mode QCalendarWidget__SelectionMode) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetSelectionMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QCalendarWidget) SetVerticalHeaderFormat(format QCalendarWidget__VerticalHeaderFormat) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetVerticalHeaderFormat(ptr.Pointer(), C.longlong(format))
	}
}

func (ptr *QCalendarWidget) SetWeekdayTextFormat(dayOfWeek core.Qt__DayOfWeek, format gui.QTextCharFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_SetWeekdayTextFormat(ptr.Pointer(), C.longlong(dayOfWeek), gui.PointerFromQTextCharFormat(format))
	}
}

//export callbackQCalendarWidget_ShowNextMonth
func callbackQCalendarWidget_ShowNextMonth(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showNextMonth"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCalendarWidgetFromPointer(ptr).ShowNextMonthDefault()
	}
}

func (ptr *QCalendarWidget) ConnectShowNextMonth(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectShowNextMonth() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) ShowNextMonth() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowNextMonth(ptr.Pointer())
	}
}

func (ptr *QCalendarWidget) ShowNextMonthDefault() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowNextMonthDefault(ptr.Pointer())
	}
}

//export callbackQCalendarWidget_ShowNextYear
func callbackQCalendarWidget_ShowNextYear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showNextYear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCalendarWidgetFromPointer(ptr).ShowNextYearDefault()
	}
}

func (ptr *QCalendarWidget) ConnectShowNextYear(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectShowNextYear() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) ShowNextYear() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowNextYear(ptr.Pointer())
	}
}

func (ptr *QCalendarWidget) ShowNextYearDefault() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowNextYearDefault(ptr.Pointer())
	}
}

//export callbackQCalendarWidget_ShowPreviousMonth
func callbackQCalendarWidget_ShowPreviousMonth(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showPreviousMonth"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCalendarWidgetFromPointer(ptr).ShowPreviousMonthDefault()
	}
}

func (ptr *QCalendarWidget) ConnectShowPreviousMonth(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectShowPreviousMonth() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) ShowPreviousMonth() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowPreviousMonth(ptr.Pointer())
	}
}

func (ptr *QCalendarWidget) ShowPreviousMonthDefault() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowPreviousMonthDefault(ptr.Pointer())
	}
}

//export callbackQCalendarWidget_ShowPreviousYear
func callbackQCalendarWidget_ShowPreviousYear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showPreviousYear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCalendarWidgetFromPointer(ptr).ShowPreviousYearDefault()
	}
}

func (ptr *QCalendarWidget) ConnectShowPreviousYear(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectShowPreviousYear() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) ShowPreviousYear() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowPreviousYear(ptr.Pointer())
	}
}

func (ptr *QCalendarWidget) ShowPreviousYearDefault() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowPreviousYearDefault(ptr.Pointer())
	}
}

//export callbackQCalendarWidget_ShowSelectedDate
func callbackQCalendarWidget_ShowSelectedDate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showSelectedDate"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCalendarWidgetFromPointer(ptr).ShowSelectedDateDefault()
	}
}

func (ptr *QCalendarWidget) ConnectShowSelectedDate(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectShowSelectedDate() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) ShowSelectedDate() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowSelectedDate(ptr.Pointer())
	}
}

func (ptr *QCalendarWidget) ShowSelectedDateDefault() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowSelectedDateDefault(ptr.Pointer())
	}
}

//export callbackQCalendarWidget_ShowToday
func callbackQCalendarWidget_ShowToday(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showToday"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCalendarWidgetFromPointer(ptr).ShowTodayDefault()
	}
}

func (ptr *QCalendarWidget) ConnectShowToday(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectShowToday() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) ShowToday() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowToday(ptr.Pointer())
	}
}

func (ptr *QCalendarWidget) ShowTodayDefault() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_ShowTodayDefault(ptr.Pointer())
	}
}

func (ptr *QCalendarWidget) UpdateCell(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_UpdateCell(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

func (ptr *QCalendarWidget) UpdateCells() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_UpdateCells(ptr.Pointer())
	}
}

//export callbackQCalendarWidget_DestroyQCalendarWidget
func callbackQCalendarWidget_DestroyQCalendarWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QCalendarWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCalendarWidgetFromPointer(ptr).DestroyQCalendarWidgetDefault()
	}
}

func (ptr *QCalendarWidget) ConnectDestroyQCalendarWidget(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DisconnectDestroyQCalendarWidget() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) DestroyQCalendarWidget() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_DestroyQCalendarWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCalendarWidget) DestroyQCalendarWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_DestroyQCalendarWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCalendarWidget) HorizontalHeaderFormat() QCalendarWidget__HorizontalHeaderFormat {
	if ptr.Pointer() != nil {
		return QCalendarWidget__HorizontalHeaderFormat(C.QCalendarWidget_HorizontalHeaderFormat(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCalendarWidget) SelectionMode() QCalendarWidget__SelectionMode {
	if ptr.Pointer() != nil {
		return QCalendarWidget__SelectionMode(C.QCalendarWidget_SelectionMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCalendarWidget) VerticalHeaderFormat() QCalendarWidget__VerticalHeaderFormat {
	if ptr.Pointer() != nil {
		return QCalendarWidget__VerticalHeaderFormat(C.QCalendarWidget_VerticalHeaderFormat(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCalendarWidget) MaximumDate() *core.QDate {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateFromPointer(C.QCalendarWidget_MaximumDate(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QCalendarWidget) MinimumDate() *core.QDate {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateFromPointer(C.QCalendarWidget_MinimumDate(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QCalendarWidget) SelectedDate() *core.QDate {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateFromPointer(C.QCalendarWidget_SelectedDate(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QCalendarWidget) DateTextFormat() map[*core.QDate]*gui.QTextCharFormat {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) map[*core.QDate]*gui.QTextCharFormat {
			out := make(map[*core.QDate]*gui.QTextCharFormat, int(l.len))
			tmpList := NewQCalendarWidgetFromPointer(l.data)
			for i, v := range tmpList.__dateTextFormat_keyList() {
				out[v] = tmpList.__dateTextFormat_atList(v, i)
			}
			return out
		}(C.QCalendarWidget_DateTextFormat(ptr.Pointer()))
	}
	return make(map[*core.QDate]*gui.QTextCharFormat, 0)
}

func (ptr *QCalendarWidget) DateTextFormat2(date core.QDate_ITF) *gui.QTextCharFormat {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCharFormatFromPointer(C.QCalendarWidget_DateTextFormat2(ptr.Pointer(), core.PointerFromQDate(date)))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCharFormat).DestroyQTextCharFormat)
		return tmpValue
	}
	return nil
}

func (ptr *QCalendarWidget) HeaderTextFormat() *gui.QTextCharFormat {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCharFormatFromPointer(C.QCalendarWidget_HeaderTextFormat(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCharFormat).DestroyQTextCharFormat)
		return tmpValue
	}
	return nil
}

func (ptr *QCalendarWidget) WeekdayTextFormat(dayOfWeek core.Qt__DayOfWeek) *gui.QTextCharFormat {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCharFormatFromPointer(C.QCalendarWidget_WeekdayTextFormat(ptr.Pointer(), C.longlong(dayOfWeek)))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCharFormat).DestroyQTextCharFormat)
		return tmpValue
	}
	return nil
}

func (ptr *QCalendarWidget) FirstDayOfWeek() core.Qt__DayOfWeek {
	if ptr.Pointer() != nil {
		return core.Qt__DayOfWeek(C.QCalendarWidget_FirstDayOfWeek(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCalendarWidget) IsDateEditEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCalendarWidget_IsDateEditEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QCalendarWidget) IsGridVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCalendarWidget_IsGridVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QCalendarWidget) IsNavigationBarVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCalendarWidget_IsNavigationBarVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QCalendarWidget) DateEditAcceptDelay() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCalendarWidget_DateEditAcceptDelay(ptr.Pointer())))
	}
	return 0
}

func (ptr *QCalendarWidget) MonthShown() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCalendarWidget_MonthShown(ptr.Pointer())))
	}
	return 0
}

func (ptr *QCalendarWidget) YearShown() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCalendarWidget_YearShown(ptr.Pointer())))
	}
	return 0
}

//export callbackQCalendarWidget_PaintCell
func callbackQCalendarWidget_PaintCell(ptr unsafe.Pointer, painter unsafe.Pointer, rect unsafe.Pointer, date unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paintCell"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRect, *core.QDate))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rect), core.NewQDateFromPointer(date))
	} else {
		NewQCalendarWidgetFromPointer(ptr).PaintCellDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rect), core.NewQDateFromPointer(date))
	}
}

func (ptr *QCalendarWidget) ConnectPaintCell(f func(painter *gui.QPainter, rect *core.QRect, date *core.QDate)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paintCell"); signal != nil {
			f := func(painter *gui.QPainter, rect *core.QRect, date *core.QDate) {
				(*(*func(*gui.QPainter, *core.QRect, *core.QDate))(signal))(painter, rect, date)
				f(painter, rect, date)
			}
			qt.ConnectSignal(ptr.Pointer(), "paintCell", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paintCell", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCalendarWidget) DisconnectPaintCell() {
	if ptr.Pointer() != nil {

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

func (ptr *QCalendarWidget) PaintCell(painter gui.QPainter_ITF, rect core.QRect_ITF, date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_PaintCell(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rect), core.PointerFromQDate(date))
	}
}

func (ptr *QCalendarWidget) PaintCellDefault(painter gui.QPainter_ITF, rect core.QRect_ITF, date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_PaintCellDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rect), core.PointerFromQDate(date))
	}
}

func (ptr *QCalendarWidget) __dateTextFormat_atList(v core.QDate_ITF, i int) *gui.QTextCharFormat {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCharFormatFromPointer(C.QCalendarWidget___dateTextFormat_atList(ptr.Pointer(), core.PointerFromQDate(v), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCharFormat).DestroyQTextCharFormat)
		return tmpValue
	}
	return nil
}

func (ptr *QCalendarWidget) __dateTextFormat_setList(key core.QDate_ITF, i gui.QTextCharFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget___dateTextFormat_setList(ptr.Pointer(), core.PointerFromQDate(key), gui.PointerFromQTextCharFormat(i))
	}
}

func (ptr *QCalendarWidget) __dateTextFormat_newList() unsafe.Pointer {
	return C.QCalendarWidget___dateTextFormat_newList(ptr.Pointer())
}

func (ptr *QCalendarWidget) __dateTextFormat_keyList() []*core.QDate {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*core.QDate {
			out := make([]*core.QDate, int(l.len))
			tmpList := NewQCalendarWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____dateTextFormat_keyList_atList(i)
			}
			return out
		}(C.QCalendarWidget___dateTextFormat_keyList(ptr.Pointer()))
	}
	return make([]*core.QDate, 0)
}

func (ptr *QCalendarWidget) ____dateTextFormat_keyList_atList(i int) *core.QDate {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateFromPointer(C.QCalendarWidget_____dateTextFormat_keyList_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QCalendarWidget) ____dateTextFormat_keyList_setList(i core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QCalendarWidget_____dateTextFormat_keyList_setList(ptr.Pointer(), core.PointerFromQDate(i))
	}
}

func (ptr *QCalendarWidget) ____dateTextFormat_keyList_newList() unsafe.Pointer {
	return C.QCalendarWidget_____dateTextFormat_keyList_newList(ptr.Pointer())
}

type QCheckBox struct {
	QAbstractButton
}

type QCheckBox_ITF interface {
	QAbstractButton_ITF
	QCheckBox_PTR() *QCheckBox
}

func (ptr *QCheckBox) QCheckBox_PTR() *QCheckBox {
	return ptr
}

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

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

func PointerFromQCheckBox(ptr QCheckBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCheckBox_PTR().Pointer()
	}
	return nil
}

func NewQCheckBoxFromPointer(ptr unsafe.Pointer) (n *QCheckBox) {
	n = new(QCheckBox)
	n.SetPointer(ptr)
	return
}
func NewQCheckBox(parent QWidget_ITF) *QCheckBox {
	tmpValue := NewQCheckBoxFromPointer(C.QCheckBox_NewQCheckBox(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQCheckBox2(text string, parent QWidget_ITF) *QCheckBox {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQCheckBoxFromPointer(C.QCheckBox_NewQCheckBox2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQCheckBox_PaintEvent
func callbackQCheckBox_PaintEvent(ptr unsafe.Pointer, vqp unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paintEvent"); signal != nil {
		(*(*func(*gui.QPaintEvent))(signal))(gui.NewQPaintEventFromPointer(vqp))
	} else {
		NewQCheckBoxFromPointer(ptr).PaintEventDefault(gui.NewQPaintEventFromPointer(vqp))
	}
}

func (ptr *QCheckBox) ConnectPaintEvent(f func(vqp *gui.QPaintEvent)) {
	if ptr.Pointer() != nil {

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

func (ptr *QCheckBox) DisconnectPaintEvent() {
	if ptr.Pointer() != nil {

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

func (ptr *QCheckBox) PaintEvent(vqp gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QCheckBox_PaintEvent(ptr.Pointer(), gui.PointerFromQPaintEvent(vqp))
	}
}

func (ptr *QCheckBox) PaintEventDefault(vqp gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QCheckBox_PaintEventDefault(ptr.Pointer(), gui.PointerFromQPaintEvent(vqp))
	}
}

func (ptr *QCheckBox) SetCheckState(state core.Qt__CheckState) {
	if ptr.Pointer() != nil {
		C.QCheckBox_SetCheckState(ptr.Pointer(), C.longlong(state))
	}
}

func (ptr *QCheckBox) SetTristate(y bool) {
	if ptr.Pointer() != nil {
		C.QCheckBox_SetTristate(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(y))))
	}
}

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

}

func (ptr *QCheckBox) ConnectStateChanged(f func(state int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
			C.QCheckBox_ConnectStateChanged(ptr.Pointer())
		}

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

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

func (ptr *QCheckBox) StateChanged(state int) {
	if ptr.Pointer() != nil {
		C.QCheckBox_StateChanged(ptr.Pointer(), C.int(int32(state)))
	}
}

//export callbackQCheckBox_DestroyQCheckBox
func callbackQCheckBox_DestroyQCheckBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QCheckBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCheckBoxFromPointer(ptr).DestroyQCheckBoxDefault()
	}
}

func (ptr *QCheckBox) ConnectDestroyQCheckBox(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCheckBox) DisconnectDestroyQCheckBox() {
	if ptr.Pointer() != nil {

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

func (ptr *QCheckBox) DestroyQCheckBox() {
	if ptr.Pointer() != nil {
		C.QCheckBox_DestroyQCheckBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCheckBox) DestroyQCheckBoxDefault() {
	if ptr.Pointer() != nil {
		C.QCheckBox_DestroyQCheckBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCheckBox) CheckState() core.Qt__CheckState {
	if ptr.Pointer() != nil {
		return core.Qt__CheckState(C.QCheckBox_CheckState(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCheckBox) IsTristate() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCheckBox_IsTristate(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QCheckBox) InitStyleOption(option QStyleOptionButton_ITF) {
	if ptr.Pointer() != nil {
		C.QCheckBox_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionButton(option))
	}
}

type QColorDialog struct {
	QDialog
}

type QColorDialog_ITF interface {
	QDialog_ITF
	QColorDialog_PTR() *QColorDialog
}

func (ptr *QColorDialog) QColorDialog_PTR() *QColorDialog {
	return ptr
}

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

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

func PointerFromQColorDialog(ptr QColorDialog_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QColorDialog_PTR().Pointer()
	}
	return nil
}

func NewQColorDialogFromPointer(ptr unsafe.Pointer) (n *QColorDialog) {
	n = new(QColorDialog)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QColorDialog__ColorDialogOption
//QColorDialog::ColorDialogOption
type QColorDialog__ColorDialogOption int64

const (
	QColorDialog__ShowAlphaChannel    QColorDialog__ColorDialogOption = QColorDialog__ColorDialogOption(0x00000001)
	QColorDialog__NoButtons           QColorDialog__ColorDialogOption = QColorDialog__ColorDialogOption(0x00000002)
	QColorDialog__DontUseNativeDialog QColorDialog__ColorDialogOption = QColorDialog__ColorDialogOption(0x00000004)
)

func QColorDialog_CustomColor(index int) *gui.QColor {
	tmpValue := gui.NewQColorFromPointer(C.QColorDialog_QColorDialog_CustomColor(C.int(int32(index))))
	runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
	return tmpValue
}

func (ptr *QColorDialog) CustomColor(index int) *gui.QColor {
	tmpValue := gui.NewQColorFromPointer(C.QColorDialog_QColorDialog_CustomColor(C.int(int32(index))))
	runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
	return tmpValue
}

func QColorDialog_GetColor(initial gui.QColor_ITF, parent QWidget_ITF, title string, options QColorDialog__ColorDialogOption) *gui.QColor {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	tmpValue := gui.NewQColorFromPointer(C.QColorDialog_QColorDialog_GetColor(gui.PointerFromQColor(initial), PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.longlong(options)))
	runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
	return tmpValue
}

func (ptr *QColorDialog) GetColor(initial gui.QColor_ITF, parent QWidget_ITF, title string, options QColorDialog__ColorDialogOption) *gui.QColor {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	tmpValue := gui.NewQColorFromPointer(C.QColorDialog_QColorDialog_GetColor(gui.PointerFromQColor(initial), PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.longlong(options)))
	runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
	return tmpValue
}

func QColorDialog_StandardColor(index int) *gui.QColor {
	tmpValue := gui.NewQColorFromPointer(C.QColorDialog_QColorDialog_StandardColor(C.int(int32(index))))
	runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
	return tmpValue
}

func (ptr *QColorDialog) StandardColor(index int) *gui.QColor {
	tmpValue := gui.NewQColorFromPointer(C.QColorDialog_QColorDialog_StandardColor(C.int(int32(index))))
	runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
	return tmpValue
}

func NewQColorDialog(parent QWidget_ITF) *QColorDialog {
	tmpValue := NewQColorDialogFromPointer(C.QColorDialog_NewQColorDialog(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQColorDialog2(initial gui.QColor_ITF, parent QWidget_ITF) *QColorDialog {
	tmpValue := NewQColorDialogFromPointer(C.QColorDialog_NewQColorDialog2(gui.PointerFromQColor(initial), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QColorDialog_CustomCount() int {
	return int(int32(C.QColorDialog_QColorDialog_CustomCount()))
}

func (ptr *QColorDialog) CustomCount() int {
	return int(int32(C.QColorDialog_QColorDialog_CustomCount()))
}

//export callbackQColorDialog_ColorSelected
func callbackQColorDialog_ColorSelected(ptr unsafe.Pointer, color unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "colorSelected"); signal != nil {
		(*(*func(*gui.QColor))(signal))(gui.NewQColorFromPointer(color))
	}

}

func (ptr *QColorDialog) ConnectColorSelected(f func(color *gui.QColor)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "colorSelected") {
			C.QColorDialog_ConnectColorSelected(ptr.Pointer())
		}

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

func (ptr *QColorDialog) DisconnectColorSelected() {
	if ptr.Pointer() != nil {
		C.QColorDialog_DisconnectColorSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "colorSelected")
	}
}

func (ptr *QColorDialog) ColorSelected(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QColorDialog_ColorSelected(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

//export callbackQColorDialog_CurrentColorChanged
func callbackQColorDialog_CurrentColorChanged(ptr unsafe.Pointer, color unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentColorChanged"); signal != nil {
		(*(*func(*gui.QColor))(signal))(gui.NewQColorFromPointer(color))
	}

}

func (ptr *QColorDialog) ConnectCurrentColorChanged(f func(color *gui.QColor)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentColorChanged") {
			C.QColorDialog_ConnectCurrentColorChanged(ptr.Pointer())
		}

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

func (ptr *QColorDialog) DisconnectCurrentColorChanged() {
	if ptr.Pointer() != nil {
		C.QColorDialog_DisconnectCurrentColorChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentColorChanged")
	}
}

func (ptr *QColorDialog) CurrentColorChanged(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QColorDialog_CurrentColorChanged(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

//export callbackQColorDialog_Done
func callbackQColorDialog_Done(ptr unsafe.Pointer, result C.int) {
	if signal := qt.GetSignal(ptr, "done"); signal != nil {
		(*(*func(int))(signal))(int(int32(result)))
	} else {
		NewQColorDialogFromPointer(ptr).DoneDefault(int(int32(result)))
	}
}

func (ptr *QColorDialog) ConnectDone(f func(result int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QColorDialog) DisconnectDone() {
	if ptr.Pointer() != nil {

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

func (ptr *QColorDialog) Done(result int) {
	if ptr.Pointer() != nil {
		C.QColorDialog_Done(ptr.Pointer(), C.int(int32(result)))
	}
}

func (ptr *QColorDialog) DoneDefault(result int) {
	if ptr.Pointer() != nil {
		C.QColorDialog_DoneDefault(ptr.Pointer(), C.int(int32(result)))
	}
}

func (ptr *QColorDialog) Open(receiver core.QObject_ITF, member string) {
	if ptr.Pointer() != nil {
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		C.QColorDialog_Open(ptr.Pointer(), core.PointerFromQObject(receiver), memberC)
	}
}

func (ptr *QColorDialog) SetCurrentColor(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QColorDialog_SetCurrentColor(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

func QColorDialog_SetCustomColor(index int, color gui.QColor_ITF) {
	C.QColorDialog_QColorDialog_SetCustomColor(C.int(int32(index)), gui.PointerFromQColor(color))
}

func (ptr *QColorDialog) SetCustomColor(index int, color gui.QColor_ITF) {
	C.QColorDialog_QColorDialog_SetCustomColor(C.int(int32(index)), gui.PointerFromQColor(color))
}

func (ptr *QColorDialog) SetOption(option QColorDialog__ColorDialogOption, on bool) {
	if ptr.Pointer() != nil {
		C.QColorDialog_SetOption(ptr.Pointer(), C.longlong(option), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QColorDialog) SetOptions(options QColorDialog__ColorDialogOption) {
	if ptr.Pointer() != nil {
		C.QColorDialog_SetOptions(ptr.Pointer(), C.longlong(options))
	}
}

func QColorDialog_SetStandardColor(index int, color gui.QColor_ITF) {
	C.QColorDialog_QColorDialog_SetStandardColor(C.int(int32(index)), gui.PointerFromQColor(color))
}

func (ptr *QColorDialog) SetStandardColor(index int, color gui.QColor_ITF) {
	C.QColorDialog_QColorDialog_SetStandardColor(C.int(int32(index)), gui.PointerFromQColor(color))
}

//export callbackQColorDialog_DestroyQColorDialog
func callbackQColorDialog_DestroyQColorDialog(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QColorDialog"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQColorDialogFromPointer(ptr).DestroyQColorDialogDefault()
	}
}

func (ptr *QColorDialog) ConnectDestroyQColorDialog(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QColorDialog) DisconnectDestroyQColorDialog() {
	if ptr.Pointer() != nil {

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

func (ptr *QColorDialog) DestroyQColorDialog() {
	if ptr.Pointer() != nil {
		C.QColorDialog_DestroyQColorDialog(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QColorDialog) DestroyQColorDialogDefault() {
	if ptr.Pointer() != nil {
		C.QColorDialog_DestroyQColorDialogDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QColorDialog) CurrentColor() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QColorDialog_CurrentColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QColorDialog) SelectedColor() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QColorDialog_SelectedColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QColorDialog) Options() QColorDialog__ColorDialogOption {
	if ptr.Pointer() != nil {
		return QColorDialog__ColorDialogOption(C.QColorDialog_Options(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColorDialog) TestOption(option QColorDialog__ColorDialogOption) bool {
	if ptr.Pointer() != nil {
		return int8(C.QColorDialog_TestOption(ptr.Pointer(), C.longlong(option))) != 0
	}
	return false
}

type QColormap struct {
	ptr unsafe.Pointer
}

type QColormap_ITF interface {
	QColormap_PTR() *QColormap
}

func (ptr *QColormap) QColormap_PTR() *QColormap {
	return ptr
}

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

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

func PointerFromQColormap(ptr QColormap_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QColormap_PTR().Pointer()
	}
	return nil
}

func NewQColormapFromPointer(ptr unsafe.Pointer) (n *QColormap) {
	n = new(QColormap)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QColormap__Mode
//QColormap::Mode
type QColormap__Mode int64

const (
	QColormap__Direct  QColormap__Mode = QColormap__Mode(0)
	QColormap__Indexed QColormap__Mode = QColormap__Mode(1)
	QColormap__Gray    QColormap__Mode = QColormap__Mode(2)
)

func QColormap_Instance(screen int) *QColormap {
	tmpValue := NewQColormapFromPointer(C.QColormap_QColormap_Instance(C.int(int32(screen))))
	runtime.SetFinalizer(tmpValue, (*QColormap).DestroyQColormap)
	return tmpValue
}

func (ptr *QColormap) Instance(screen int) *QColormap {
	tmpValue := NewQColormapFromPointer(C.QColormap_QColormap_Instance(C.int(int32(screen))))
	runtime.SetFinalizer(tmpValue, (*QColormap).DestroyQColormap)
	return tmpValue
}

func NewQColormap(colormap QColormap_ITF) *QColormap {
	tmpValue := NewQColormapFromPointer(C.QColormap_NewQColormap(PointerFromQColormap(colormap)))
	runtime.SetFinalizer(tmpValue, (*QColormap).DestroyQColormap)
	return tmpValue
}

func (ptr *QColormap) DestroyQColormap() {
	if ptr.Pointer() != nil {
		C.QColormap_DestroyQColormap(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QColormap) Mode() QColormap__Mode {
	if ptr.Pointer() != nil {
		return QColormap__Mode(C.QColormap_Mode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColormap) ColorAt(pixel uint) *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QColormap_ColorAt(ptr.Pointer(), C.uint(uint32(pixel))))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QColormap) Colormap() []*gui.QColor {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*gui.QColor {
			out := make([]*gui.QColor, int(l.len))
			tmpList := NewQColormapFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__colormap_atList(i)
			}
			return out
		}(C.QColormap_Colormap(ptr.Pointer()))
	}
	return make([]*gui.QColor, 0)
}

func (ptr *QColormap) Depth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QColormap_Depth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QColormap) Size() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QColormap_Size(ptr.Pointer())))
	}
	return 0
}

func (ptr *QColormap) Pixel(color gui.QColor_ITF) uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QColormap_Pixel(ptr.Pointer(), gui.PointerFromQColor(color))))
	}
	return 0
}

func (ptr *QColormap) __colormap_atList(i int) *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QColormap___colormap_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QColormap) __colormap_setList(i gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QColormap___colormap_setList(ptr.Pointer(), gui.PointerFromQColor(i))
	}
}

func (ptr *QColormap) __colormap_newList() unsafe.Pointer {
	return C.QColormap___colormap_newList(ptr.Pointer())
}

type QColumnView struct {
	QAbstractItemView
}

type QColumnView_ITF interface {
	QAbstractItemView_ITF
	QColumnView_PTR() *QColumnView
}

func (ptr *QColumnView) QColumnView_PTR() *QColumnView {
	return ptr
}

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

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

func PointerFromQColumnView(ptr QColumnView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QColumnView_PTR().Pointer()
	}
	return nil
}

func NewQColumnViewFromPointer(ptr unsafe.Pointer) (n *QColumnView) {
	n = new(QColumnView)
	n.SetPointer(ptr)
	return
}

//export callbackQColumnView_CreateColumn
func callbackQColumnView_CreateColumn(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "createColumn"); signal != nil {
		return PointerFromQAbstractItemView((*(*func(*core.QModelIndex) *QAbstractItemView)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return PointerFromQAbstractItemView(NewQColumnViewFromPointer(ptr).CreateColumnDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QColumnView) ConnectCreateColumn(f func(index *core.QModelIndex) *QAbstractItemView) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectCreateColumn() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) CreateColumn(index core.QModelIndex_ITF) *QAbstractItemView {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemViewFromPointer(C.QColumnView_CreateColumn(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QColumnView) CreateColumnDefault(index core.QModelIndex_ITF) *QAbstractItemView {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemViewFromPointer(C.QColumnView_CreateColumnDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQColumnView(parent QWidget_ITF) *QColumnView {
	tmpValue := NewQColumnViewFromPointer(C.QColumnView_NewQColumnView(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQColumnView_MoveCursor
func callbackQColumnView_MoveCursor(ptr unsafe.Pointer, cursorAction C.longlong, modifiers C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "moveCursor"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
	}

	return core.PointerFromQModelIndex(NewQColumnViewFromPointer(ptr).MoveCursorDefault(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
}

func (ptr *QColumnView) ConnectMoveCursor(f func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "moveCursor"); signal != nil {
			f := func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
				(*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(cursorAction, modifiers)
				return f(cursorAction, modifiers)
			}
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QColumnView) DisconnectMoveCursor() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) MoveCursor(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QColumnView_MoveCursor(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QColumnView) MoveCursorDefault(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QColumnView_MoveCursorDefault(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQColumnView_CurrentChanged
func callbackQColumnView_CurrentChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	} else {
		NewQColumnViewFromPointer(ptr).CurrentChangedDefault(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	}
}

func (ptr *QColumnView) ConnectCurrentChanged(f func(current *core.QModelIndex, previous *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) CurrentChanged(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QColumnView_CurrentChanged(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

func (ptr *QColumnView) CurrentChangedDefault(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QColumnView_CurrentChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

//export callbackQColumnView_RowsInserted
func callbackQColumnView_RowsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	} else {
		NewQColumnViewFromPointer(ptr).RowsInsertedDefault(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}
}

func (ptr *QColumnView) ConnectRowsInserted(f func(parent *core.QModelIndex, start int, end int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectRowsInserted() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) RowsInserted(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QColumnView_RowsInserted(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

func (ptr *QColumnView) RowsInsertedDefault(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QColumnView_RowsInsertedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

//export callbackQColumnView_ScrollTo
func callbackQColumnView_ScrollTo(ptr unsafe.Pointer, index unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "scrollTo"); signal != nil {
		(*(*func(*core.QModelIndex, QAbstractItemView__ScrollHint))(signal))(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	} else {
		NewQColumnViewFromPointer(ptr).ScrollToDefault(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	}
}

func (ptr *QColumnView) ConnectScrollTo(f func(index *core.QModelIndex, hint QAbstractItemView__ScrollHint)) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectScrollTo() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) ScrollTo(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QColumnView_ScrollTo(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

func (ptr *QColumnView) ScrollToDefault(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QColumnView_ScrollToDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

//export callbackQColumnView_SelectAll
func callbackQColumnView_SelectAll(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectAll"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQColumnViewFromPointer(ptr).SelectAllDefault()
	}
}

func (ptr *QColumnView) ConnectSelectAll(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectSelectAll() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) SelectAll() {
	if ptr.Pointer() != nil {
		C.QColumnView_SelectAll(ptr.Pointer())
	}
}

func (ptr *QColumnView) SelectAllDefault() {
	if ptr.Pointer() != nil {
		C.QColumnView_SelectAllDefault(ptr.Pointer())
	}
}

func (ptr *QColumnView) SetColumnWidths(list []int) {
	if ptr.Pointer() != nil {
		C.QColumnView_SetColumnWidths(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQColumnViewFromPointer(NewQColumnViewFromPointer(nil).__setColumnWidths_list_newList())
			for _, v := range list {
				tmpList.__setColumnWidths_list_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QColumnView) SetPreviewWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QColumnView_SetPreviewWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QColumnView) SetResizeGripsVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QColumnView_SetResizeGripsVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQColumnView_SetRootIndex
func callbackQColumnView_SetRootIndex(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setRootIndex"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQColumnViewFromPointer(ptr).SetRootIndexDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QColumnView) ConnectSetRootIndex(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectSetRootIndex() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) SetRootIndex(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QColumnView_SetRootIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QColumnView) SetRootIndexDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QColumnView_SetRootIndexDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQColumnView_SetSelection
func callbackQColumnView_SetSelection(ptr unsafe.Pointer, rect unsafe.Pointer, command C.longlong) {
	if signal := qt.GetSignal(ptr, "setSelection"); signal != nil {
		(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(command))
	} else {
		NewQColumnViewFromPointer(ptr).SetSelectionDefault(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(command))
	}
}

func (ptr *QColumnView) ConnectSetSelection(f func(rect *core.QRect, command core.QItemSelectionModel__SelectionFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setSelection"); signal != nil {
			f := func(rect *core.QRect, command core.QItemSelectionModel__SelectionFlag) {
				(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(rect, command)
				f(rect, command)
			}
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QColumnView) DisconnectSetSelection() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) SetSelection(rect core.QRect_ITF, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QColumnView_SetSelection(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(command))
	}
}

func (ptr *QColumnView) SetSelectionDefault(rect core.QRect_ITF, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QColumnView_SetSelectionDefault(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(command))
	}
}

//export callbackQColumnView_UpdatePreviewWidget
func callbackQColumnView_UpdatePreviewWidget(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updatePreviewWidget"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QColumnView) ConnectUpdatePreviewWidget(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "updatePreviewWidget") {
			C.QColumnView_ConnectUpdatePreviewWidget(ptr.Pointer())
		}

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

func (ptr *QColumnView) DisconnectUpdatePreviewWidget() {
	if ptr.Pointer() != nil {
		C.QColumnView_DisconnectUpdatePreviewWidget(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "updatePreviewWidget")
	}
}

func (ptr *QColumnView) UpdatePreviewWidget(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QColumnView_UpdatePreviewWidget(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQColumnView_DestroyQColumnView
func callbackQColumnView_DestroyQColumnView(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QColumnView"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQColumnViewFromPointer(ptr).DestroyQColumnViewDefault()
	}
}

func (ptr *QColumnView) ConnectDestroyQColumnView(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectDestroyQColumnView() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DestroyQColumnView() {
	if ptr.Pointer() != nil {
		C.QColumnView_DestroyQColumnView(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QColumnView) DestroyQColumnViewDefault() {
	if ptr.Pointer() != nil {
		C.QColumnView_DestroyQColumnViewDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QColumnView) ColumnWidths() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQColumnViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__columnWidths_atList(i)
			}
			return out
		}(C.QColumnView_ColumnWidths(ptr.Pointer()))
	}
	return make([]int, 0)
}

//export callbackQColumnView_IndexAt
func callbackQColumnView_IndexAt(ptr unsafe.Pointer, point unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "indexAt"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QPoint) *core.QModelIndex)(signal))(core.NewQPointFromPointer(point)))
	}

	return core.PointerFromQModelIndex(NewQColumnViewFromPointer(ptr).IndexAtDefault(core.NewQPointFromPointer(point)))
}

func (ptr *QColumnView) ConnectIndexAt(f func(point *core.QPoint) *core.QModelIndex) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectIndexAt() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) IndexAt(point core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QColumnView_IndexAt(ptr.Pointer(), core.PointerFromQPoint(point)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QColumnView) IndexAtDefault(point core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QColumnView_IndexAtDefault(ptr.Pointer(), core.PointerFromQPoint(point)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQColumnView_VisualRect
func callbackQColumnView_VisualRect(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRect"); signal != nil {
		return core.PointerFromQRect((*(*func(*core.QModelIndex) *core.QRect)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQRect(NewQColumnViewFromPointer(ptr).VisualRectDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QColumnView) ConnectVisualRect(f func(index *core.QModelIndex) *core.QRect) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectVisualRect() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) VisualRect(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QColumnView_VisualRect(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QColumnView) VisualRectDefault(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QColumnView_VisualRectDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQColumnView_VisualRegionForSelection
func callbackQColumnView_VisualRegionForSelection(ptr unsafe.Pointer, selection unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRegionForSelection"); signal != nil {
		return gui.PointerFromQRegion((*(*func(*core.QItemSelection) *gui.QRegion)(signal))(core.NewQItemSelectionFromPointer(selection)))
	}

	return gui.PointerFromQRegion(NewQColumnViewFromPointer(ptr).VisualRegionForSelectionDefault(core.NewQItemSelectionFromPointer(selection)))
}

func (ptr *QColumnView) ConnectVisualRegionForSelection(f func(selection *core.QItemSelection) *gui.QRegion) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "visualRegionForSelection"); signal != nil {
			f := func(selection *core.QItemSelection) *gui.QRegion {
				(*(*func(*core.QItemSelection) *gui.QRegion)(signal))(selection)
				return f(selection)
			}
			qt.ConnectSignal(ptr.Pointer(), "visualRegionForSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "visualRegionForSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QColumnView) DisconnectVisualRegionForSelection() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) VisualRegionForSelection(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QColumnView_VisualRegionForSelection(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QColumnView) VisualRegionForSelectionDefault(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QColumnView_VisualRegionForSelectionDefault(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QColumnView) PreviewWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QColumnView_PreviewWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

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

	return C.char(int8(qt.GoBoolToInt(NewQColumnViewFromPointer(ptr).IsIndexHiddenDefault(core.NewQModelIndexFromPointer(index)))))
}

func (ptr *QColumnView) ConnectIsIndexHidden(f func(index *core.QModelIndex) bool) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectIsIndexHidden() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) IsIndexHidden(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QColumnView_IsIndexHidden(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QColumnView) IsIndexHiddenDefault(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QColumnView_IsIndexHiddenDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QColumnView) ResizeGripsVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QColumnView_ResizeGripsVisible(ptr.Pointer())) != 0
	}
	return false
}

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

	return C.int(int32(NewQColumnViewFromPointer(ptr).HorizontalOffsetDefault()))
}

func (ptr *QColumnView) ConnectHorizontalOffset(f func() int) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectHorizontalOffset() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) HorizontalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QColumnView_HorizontalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QColumnView) HorizontalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QColumnView_HorizontalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

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

	return C.int(int32(NewQColumnViewFromPointer(ptr).VerticalOffsetDefault()))
}

func (ptr *QColumnView) ConnectVerticalOffset(f func() int) {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) DisconnectVerticalOffset() {
	if ptr.Pointer() != nil {

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

func (ptr *QColumnView) VerticalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QColumnView_VerticalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QColumnView) VerticalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QColumnView_VerticalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QColumnView) InitializeColumn(column QAbstractItemView_ITF) {
	if ptr.Pointer() != nil {
		C.QColumnView_InitializeColumn(ptr.Pointer(), PointerFromQAbstractItemView(column))
	}
}

func (ptr *QColumnView) __setColumnWidths_list_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QColumnView___setColumnWidths_list_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QColumnView) __setColumnWidths_list_setList(i int) {
	if ptr.Pointer() != nil {
		C.QColumnView___setColumnWidths_list_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QColumnView) __setColumnWidths_list_newList() unsafe.Pointer {
	return C.QColumnView___setColumnWidths_list_newList(ptr.Pointer())
}

func (ptr *QColumnView) __columnWidths_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QColumnView___columnWidths_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QColumnView) __columnWidths_setList(i int) {
	if ptr.Pointer() != nil {
		C.QColumnView___columnWidths_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QColumnView) __columnWidths_newList() unsafe.Pointer {
	return C.QColumnView___columnWidths_newList(ptr.Pointer())
}

type QComboBox struct {
	QWidget
}

type QComboBox_ITF interface {
	QWidget_ITF
	QComboBox_PTR() *QComboBox
}

func (ptr *QComboBox) QComboBox_PTR() *QComboBox {
	return ptr
}

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

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

func PointerFromQComboBox(ptr QComboBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QComboBox_PTR().Pointer()
	}
	return nil
}

func NewQComboBoxFromPointer(ptr unsafe.Pointer) (n *QComboBox) {
	n = new(QComboBox)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QComboBox__InsertPolicy
//QComboBox::InsertPolicy
type QComboBox__InsertPolicy int64

const (
	QComboBox__NoInsert             QComboBox__InsertPolicy = QComboBox__InsertPolicy(0)
	QComboBox__InsertAtTop          QComboBox__InsertPolicy = QComboBox__InsertPolicy(1)
	QComboBox__InsertAtCurrent      QComboBox__InsertPolicy = QComboBox__InsertPolicy(2)
	QComboBox__InsertAtBottom       QComboBox__InsertPolicy = QComboBox__InsertPolicy(3)
	QComboBox__InsertAfterCurrent   QComboBox__InsertPolicy = QComboBox__InsertPolicy(4)
	QComboBox__InsertBeforeCurrent  QComboBox__InsertPolicy = QComboBox__InsertPolicy(5)
	QComboBox__InsertAlphabetically QComboBox__InsertPolicy = QComboBox__InsertPolicy(6)
)

//go:generate stringer -type=QComboBox__SizeAdjustPolicy
//QComboBox::SizeAdjustPolicy
type QComboBox__SizeAdjustPolicy int64

const (
	QComboBox__AdjustToContents                      QComboBox__SizeAdjustPolicy = QComboBox__SizeAdjustPolicy(0)
	QComboBox__AdjustToContentsOnFirstShow           QComboBox__SizeAdjustPolicy = QComboBox__SizeAdjustPolicy(1)
	QComboBox__AdjustToMinimumContentsLength         QComboBox__SizeAdjustPolicy = QComboBox__SizeAdjustPolicy(2)
	QComboBox__AdjustToMinimumContentsLengthWithIcon QComboBox__SizeAdjustPolicy = QComboBox__SizeAdjustPolicy(3)
)

func NewQComboBox(parent QWidget_ITF) *QComboBox {
	tmpValue := NewQComboBoxFromPointer(C.QComboBox_NewQComboBox(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQComboBox_Activated2
func callbackQComboBox_Activated2(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "activated2"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QComboBox) ConnectActivated2(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activated2") {
			C.QComboBox_ConnectActivated2(ptr.Pointer())
		}

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

func (ptr *QComboBox) DisconnectActivated2() {
	if ptr.Pointer() != nil {
		C.QComboBox_DisconnectActivated2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activated2")
	}
}

func (ptr *QComboBox) Activated2(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_Activated2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

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

}

func (ptr *QComboBox) ConnectActivated(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activated") {
			C.QComboBox_ConnectActivated(ptr.Pointer())
		}

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

func (ptr *QComboBox) DisconnectActivated() {
	if ptr.Pointer() != nil {
		C.QComboBox_DisconnectActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activated")
	}
}

func (ptr *QComboBox) Activated(index int) {
	if ptr.Pointer() != nil {
		C.QComboBox_Activated(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QComboBox) AddItem2(icon gui.QIcon_ITF, text string, userData core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_AddItem2(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQVariant(userData))
	}
}

func (ptr *QComboBox) AddItem(text string, userData core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_AddItem(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQVariant(userData))
	}
}

func (ptr *QComboBox) AddItems(texts []string) {
	if ptr.Pointer() != nil {
		textsC := C.CString(strings.Join(texts, "|"))
		defer C.free(unsafe.Pointer(textsC))
		C.QComboBox_AddItems(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textsC, len: C.longlong(len(strings.Join(texts, "|")))})
	}
}

//export callbackQComboBox_Clear
func callbackQComboBox_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQComboBoxFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QComboBox) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) DisconnectClear() {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) Clear() {
	if ptr.Pointer() != nil {
		C.QComboBox_Clear(ptr.Pointer())
	}
}

func (ptr *QComboBox) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QComboBox_ClearDefault(ptr.Pointer())
	}
}

//export callbackQComboBox_ClearEditText
func callbackQComboBox_ClearEditText(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clearEditText"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQComboBoxFromPointer(ptr).ClearEditTextDefault()
	}
}

func (ptr *QComboBox) ConnectClearEditText(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) DisconnectClearEditText() {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) ClearEditText() {
	if ptr.Pointer() != nil {
		C.QComboBox_ClearEditText(ptr.Pointer())
	}
}

func (ptr *QComboBox) ClearEditTextDefault() {
	if ptr.Pointer() != nil {
		C.QComboBox_ClearEditTextDefault(ptr.Pointer())
	}
}

//export callbackQComboBox_CurrentIndexChanged2
func callbackQComboBox_CurrentIndexChanged2(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "currentIndexChanged2"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QComboBox) ConnectCurrentIndexChanged2(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentIndexChanged2") {
			C.QComboBox_ConnectCurrentIndexChanged2(ptr.Pointer())
		}

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

func (ptr *QComboBox) DisconnectCurrentIndexChanged2() {
	if ptr.Pointer() != nil {
		C.QComboBox_DisconnectCurrentIndexChanged2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentIndexChanged2")
	}
}

func (ptr *QComboBox) CurrentIndexChanged2(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_CurrentIndexChanged2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

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

}

func (ptr *QComboBox) ConnectCurrentIndexChanged(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentIndexChanged") {
			C.QComboBox_ConnectCurrentIndexChanged(ptr.Pointer())
		}

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

func (ptr *QComboBox) DisconnectCurrentIndexChanged() {
	if ptr.Pointer() != nil {
		C.QComboBox_DisconnectCurrentIndexChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentIndexChanged")
	}
}

func (ptr *QComboBox) CurrentIndexChanged(index int) {
	if ptr.Pointer() != nil {
		C.QComboBox_CurrentIndexChanged(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQComboBox_CurrentTextChanged
func callbackQComboBox_CurrentTextChanged(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "currentTextChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QComboBox) ConnectCurrentTextChanged(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentTextChanged") {
			C.QComboBox_ConnectCurrentTextChanged(ptr.Pointer())
		}

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

func (ptr *QComboBox) DisconnectCurrentTextChanged() {
	if ptr.Pointer() != nil {
		C.QComboBox_DisconnectCurrentTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentTextChanged")
	}
}

func (ptr *QComboBox) CurrentTextChanged(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_CurrentTextChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQComboBox_EditTextChanged
func callbackQComboBox_EditTextChanged(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "editTextChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QComboBox) ConnectEditTextChanged(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "editTextChanged") {
			C.QComboBox_ConnectEditTextChanged(ptr.Pointer())
		}

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

func (ptr *QComboBox) DisconnectEditTextChanged() {
	if ptr.Pointer() != nil {
		C.QComboBox_DisconnectEditTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "editTextChanged")
	}
}

func (ptr *QComboBox) EditTextChanged(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_EditTextChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQComboBox_HidePopup
func callbackQComboBox_HidePopup(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hidePopup"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQComboBoxFromPointer(ptr).HidePopupDefault()
	}
}

func (ptr *QComboBox) ConnectHidePopup(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) DisconnectHidePopup() {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) HidePopup() {
	if ptr.Pointer() != nil {
		C.QComboBox_HidePopup(ptr.Pointer())
	}
}

func (ptr *QComboBox) HidePopupDefault() {
	if ptr.Pointer() != nil {
		C.QComboBox_HidePopupDefault(ptr.Pointer())
	}
}

//export callbackQComboBox_Highlighted2
func callbackQComboBox_Highlighted2(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "highlighted2"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QComboBox) ConnectHighlighted2(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "highlighted2") {
			C.QComboBox_ConnectHighlighted2(ptr.Pointer())
		}

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

func (ptr *QComboBox) DisconnectHighlighted2() {
	if ptr.Pointer() != nil {
		C.QComboBox_DisconnectHighlighted2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "highlighted2")
	}
}

func (ptr *QComboBox) Highlighted2(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_Highlighted2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

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

}

func (ptr *QComboBox) ConnectHighlighted(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "highlighted") {
			C.QComboBox_ConnectHighlighted(ptr.Pointer())
		}

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

func (ptr *QComboBox) DisconnectHighlighted() {
	if ptr.Pointer() != nil {
		C.QComboBox_DisconnectHighlighted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "highlighted")
	}
}

func (ptr *QComboBox) Highlighted(index int) {
	if ptr.Pointer() != nil {
		C.QComboBox_Highlighted(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QComboBox) InsertItem2(index int, icon gui.QIcon_ITF, text string, userData core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_InsertItem2(ptr.Pointer(), C.int(int32(index)), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQVariant(userData))
	}
}

func (ptr *QComboBox) InsertItem(index int, text string, userData core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_InsertItem(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQVariant(userData))
	}
}

func (ptr *QComboBox) InsertItems(index int, list []string) {
	if ptr.Pointer() != nil {
		listC := C.CString(strings.Join(list, "|"))
		defer C.free(unsafe.Pointer(listC))
		C.QComboBox_InsertItems(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "|")))})
	}
}

func (ptr *QComboBox) InsertSeparator(index int) {
	if ptr.Pointer() != nil {
		C.QComboBox_InsertSeparator(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QComboBox) RemoveItem(index int) {
	if ptr.Pointer() != nil {
		C.QComboBox_RemoveItem(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QComboBox) SetCompleter(completer QCompleter_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetCompleter(ptr.Pointer(), PointerFromQCompleter(completer))
	}
}

//export callbackQComboBox_SetCurrentIndex
func callbackQComboBox_SetCurrentIndex(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQComboBoxFromPointer(ptr).SetCurrentIndexDefault(int(int32(index)))
	}
}

func (ptr *QComboBox) ConnectSetCurrentIndex(f func(index int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) DisconnectSetCurrentIndex() {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) SetCurrentIndex(index int) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetCurrentIndex(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QComboBox) SetCurrentIndexDefault(index int) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetCurrentIndexDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQComboBox_SetCurrentText
func callbackQComboBox_SetCurrentText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setCurrentText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQComboBoxFromPointer(ptr).SetCurrentTextDefault(cGoUnpackString(text))
	}
}

func (ptr *QComboBox) ConnectSetCurrentText(f func(text string)) {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) DisconnectSetCurrentText() {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) SetCurrentText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_SetCurrentText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QComboBox) SetCurrentTextDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_SetCurrentTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QComboBox) SetDuplicatesEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetDuplicatesEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQComboBox_SetEditText
func callbackQComboBox_SetEditText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setEditText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQComboBoxFromPointer(ptr).SetEditTextDefault(cGoUnpackString(text))
	}
}

func (ptr *QComboBox) ConnectSetEditText(f func(text string)) {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) DisconnectSetEditText() {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) SetEditText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_SetEditText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QComboBox) SetEditTextDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_SetEditTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QComboBox) SetEditable(editable bool) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetEditable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(editable))))
	}
}

func (ptr *QComboBox) SetFrame(vbo bool) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetFrame(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QComboBox) SetIconSize(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetIconSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QComboBox) SetInsertPolicy(policy QComboBox__InsertPolicy) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetInsertPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QComboBox) SetItemData(index int, value core.QVariant_ITF, role int) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetItemData(ptr.Pointer(), C.int(int32(index)), core.PointerFromQVariant(value), C.int(int32(role)))
	}
}

func (ptr *QComboBox) SetItemDelegate(delegate QAbstractItemDelegate_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetItemDelegate(ptr.Pointer(), PointerFromQAbstractItemDelegate(delegate))
	}
}

func (ptr *QComboBox) SetItemIcon(index int, icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetItemIcon(ptr.Pointer(), C.int(int32(index)), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QComboBox) SetItemText(index int, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QComboBox_SetItemText(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QComboBox) SetLineEdit(edit QLineEdit_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetLineEdit(ptr.Pointer(), PointerFromQLineEdit(edit))
	}
}

func (ptr *QComboBox) SetMaxCount(max int) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetMaxCount(ptr.Pointer(), C.int(int32(max)))
	}
}

func (ptr *QComboBox) SetMaxVisibleItems(maxItems int) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetMaxVisibleItems(ptr.Pointer(), C.int(int32(maxItems)))
	}
}

func (ptr *QComboBox) SetMinimumContentsLength(characters int) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetMinimumContentsLength(ptr.Pointer(), C.int(int32(characters)))
	}
}

func (ptr *QComboBox) SetModel(model core.QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetModel(ptr.Pointer(), core.PointerFromQAbstractItemModel(model))
	}
}

func (ptr *QComboBox) SetModelColumn(visibleColumn int) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetModelColumn(ptr.Pointer(), C.int(int32(visibleColumn)))
	}
}

func (ptr *QComboBox) SetRootModelIndex(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetRootModelIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QComboBox) SetSizeAdjustPolicy(policy QComboBox__SizeAdjustPolicy) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetSizeAdjustPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QComboBox) SetValidator(validator gui.QValidator_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetValidator(ptr.Pointer(), gui.PointerFromQValidator(validator))
	}
}

func (ptr *QComboBox) SetView(itemView QAbstractItemView_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_SetView(ptr.Pointer(), PointerFromQAbstractItemView(itemView))
	}
}

//export callbackQComboBox_ShowPopup
func callbackQComboBox_ShowPopup(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showPopup"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQComboBoxFromPointer(ptr).ShowPopupDefault()
	}
}

func (ptr *QComboBox) ConnectShowPopup(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) DisconnectShowPopup() {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) ShowPopup() {
	if ptr.Pointer() != nil {
		C.QComboBox_ShowPopup(ptr.Pointer())
	}
}

func (ptr *QComboBox) ShowPopupDefault() {
	if ptr.Pointer() != nil {
		C.QComboBox_ShowPopupDefault(ptr.Pointer())
	}
}

//export callbackQComboBox_DestroyQComboBox
func callbackQComboBox_DestroyQComboBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QComboBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQComboBoxFromPointer(ptr).DestroyQComboBoxDefault()
	}
}

func (ptr *QComboBox) ConnectDestroyQComboBox(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) DisconnectDestroyQComboBox() {
	if ptr.Pointer() != nil {

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

func (ptr *QComboBox) DestroyQComboBox() {
	if ptr.Pointer() != nil {
		C.QComboBox_DestroyQComboBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QComboBox) DestroyQComboBoxDefault() {
	if ptr.Pointer() != nil {
		C.QComboBox_DestroyQComboBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QComboBox) ItemDelegate() *QAbstractItemDelegate {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemDelegateFromPointer(C.QComboBox_ItemDelegate(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) Model() *core.QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractItemModelFromPointer(C.QComboBox_Model(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) View() *QAbstractItemView {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemViewFromPointer(C.QComboBox_View(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) InsertPolicy() QComboBox__InsertPolicy {
	if ptr.Pointer() != nil {
		return QComboBox__InsertPolicy(C.QComboBox_InsertPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QComboBox) SizeAdjustPolicy() QComboBox__SizeAdjustPolicy {
	if ptr.Pointer() != nil {
		return QComboBox__SizeAdjustPolicy(C.QComboBox_SizeAdjustPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QComboBox) Completer() *QCompleter {
	if ptr.Pointer() != nil {
		tmpValue := NewQCompleterFromPointer(C.QComboBox_Completer(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) ItemIcon(index int) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QComboBox_ItemIcon(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) LineEdit() *QLineEdit {
	if ptr.Pointer() != nil {
		tmpValue := NewQLineEditFromPointer(C.QComboBox_LineEdit(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) RootModelIndex() *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QComboBox_RootModelIndex(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QComboBox_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) CurrentText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QComboBox_CurrentText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QComboBox) ItemText(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QComboBox_ItemText(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QComboBox) CurrentData(role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QComboBox_CurrentData(ptr.Pointer(), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) ItemData(index int, role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QComboBox_ItemData(ptr.Pointer(), C.int(int32(index)), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) DuplicatesEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QComboBox_DuplicatesEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QComboBox) HasFrame() bool {
	if ptr.Pointer() != nil {
		return int8(C.QComboBox_HasFrame(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QComboBox) IsEditable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QComboBox_IsEditable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QComboBox) Validator() *gui.QValidator {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQValidatorFromPointer(C.QComboBox_Validator(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QComboBox) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QComboBox_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QComboBox) CurrentIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QComboBox_CurrentIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QComboBox) FindData(data core.QVariant_ITF, role int, flags core.Qt__MatchFlag) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QComboBox_FindData(ptr.Pointer(), core.PointerFromQVariant(data), C.int(int32(role)), C.longlong(flags))))
	}
	return 0
}

func (ptr *QComboBox) FindText(text string, flags core.Qt__MatchFlag) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QComboBox_FindText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(flags))))
	}
	return 0
}

func (ptr *QComboBox) MaxCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QComboBox_MaxCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QComboBox) MaxVisibleItems() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QComboBox_MaxVisibleItems(ptr.Pointer())))
	}
	return 0
}

func (ptr *QComboBox) MinimumContentsLength() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QComboBox_MinimumContentsLength(ptr.Pointer())))
	}
	return 0
}

func (ptr *QComboBox) ModelColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QComboBox_ModelColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QComboBox) InitStyleOption(option QStyleOptionComboBox_ITF) {
	if ptr.Pointer() != nil {
		C.QComboBox_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionComboBox(option))
	}
}

type QCommandLinkButton struct {
	QPushButton
}

type QCommandLinkButton_ITF interface {
	QPushButton_ITF
	QCommandLinkButton_PTR() *QCommandLinkButton
}

func (ptr *QCommandLinkButton) QCommandLinkButton_PTR() *QCommandLinkButton {
	return ptr
}

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

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

func PointerFromQCommandLinkButton(ptr QCommandLinkButton_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCommandLinkButton_PTR().Pointer()
	}
	return nil
}

func NewQCommandLinkButtonFromPointer(ptr unsafe.Pointer) (n *QCommandLinkButton) {
	n = new(QCommandLinkButton)
	n.SetPointer(ptr)
	return
}
func NewQCommandLinkButton(parent QWidget_ITF) *QCommandLinkButton {
	tmpValue := NewQCommandLinkButtonFromPointer(C.QCommandLinkButton_NewQCommandLinkButton(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQCommandLinkButton2(text string, parent QWidget_ITF) *QCommandLinkButton {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQCommandLinkButtonFromPointer(C.QCommandLinkButton_NewQCommandLinkButton2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQCommandLinkButton3(text string, description string, parent QWidget_ITF) *QCommandLinkButton {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	var descriptionC *C.char
	if description != "" {
		descriptionC = C.CString(description)
		defer C.free(unsafe.Pointer(descriptionC))
	}
	tmpValue := NewQCommandLinkButtonFromPointer(C.QCommandLinkButton_NewQCommandLinkButton3(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.struct_QtWidgets_PackedString{data: descriptionC, len: C.longlong(len(description))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QCommandLinkButton) SetDescription(description string) {
	if ptr.Pointer() != nil {
		var descriptionC *C.char
		if description != "" {
			descriptionC = C.CString(description)
			defer C.free(unsafe.Pointer(descriptionC))
		}
		C.QCommandLinkButton_SetDescription(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: descriptionC, len: C.longlong(len(description))})
	}
}

//export callbackQCommandLinkButton_DestroyQCommandLinkButton
func callbackQCommandLinkButton_DestroyQCommandLinkButton(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QCommandLinkButton"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCommandLinkButtonFromPointer(ptr).DestroyQCommandLinkButtonDefault()
	}
}

func (ptr *QCommandLinkButton) ConnectDestroyQCommandLinkButton(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCommandLinkButton) DisconnectDestroyQCommandLinkButton() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommandLinkButton) DestroyQCommandLinkButton() {
	if ptr.Pointer() != nil {
		C.QCommandLinkButton_DestroyQCommandLinkButton(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCommandLinkButton) DestroyQCommandLinkButtonDefault() {
	if ptr.Pointer() != nil {
		C.QCommandLinkButton_DestroyQCommandLinkButtonDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCommandLinkButton) Description() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCommandLinkButton_Description(ptr.Pointer()))
	}
	return ""
}

type QCommonStyle struct {
	QStyle
}

type QCommonStyle_ITF interface {
	QStyle_ITF
	QCommonStyle_PTR() *QCommonStyle
}

func (ptr *QCommonStyle) QCommonStyle_PTR() *QCommonStyle {
	return ptr
}

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

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

func PointerFromQCommonStyle(ptr QCommonStyle_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCommonStyle_PTR().Pointer()
	}
	return nil
}

func NewQCommonStyleFromPointer(ptr unsafe.Pointer) (n *QCommonStyle) {
	n = new(QCommonStyle)
	n.SetPointer(ptr)
	return
}
func NewQCommonStyle() *QCommonStyle {
	tmpValue := NewQCommonStyleFromPointer(C.QCommonStyle_NewQCommonStyle())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQCommonStyle_DestroyQCommonStyle
func callbackQCommonStyle_DestroyQCommonStyle(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QCommonStyle"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCommonStyleFromPointer(ptr).DestroyQCommonStyleDefault()
	}
}

func (ptr *QCommonStyle) ConnectDestroyQCommonStyle(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) DisconnectDestroyQCommonStyle() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) DestroyQCommonStyle() {
	if ptr.Pointer() != nil {
		C.QCommonStyle_DestroyQCommonStyle(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCommonStyle) DestroyQCommonStyleDefault() {
	if ptr.Pointer() != nil {
		C.QCommonStyle_DestroyQCommonStyleDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQCommonStyle_GeneratedIconPixmap
func callbackQCommonStyle_GeneratedIconPixmap(ptr unsafe.Pointer, iconMode C.longlong, pixmap unsafe.Pointer, opt unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "generatedIconPixmap"); signal != nil {
		return gui.PointerFromQPixmap((*(*func(gui.QIcon__Mode, *gui.QPixmap, *QStyleOption) *gui.QPixmap)(signal))(gui.QIcon__Mode(iconMode), gui.NewQPixmapFromPointer(pixmap), NewQStyleOptionFromPointer(opt)))
	}

	return gui.PointerFromQPixmap(NewQCommonStyleFromPointer(ptr).GeneratedIconPixmapDefault(gui.QIcon__Mode(iconMode), gui.NewQPixmapFromPointer(pixmap), NewQStyleOptionFromPointer(opt)))
}

func (ptr *QCommonStyle) ConnectGeneratedIconPixmap(f func(iconMode gui.QIcon__Mode, pixmap *gui.QPixmap, opt *QStyleOption) *gui.QPixmap) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "generatedIconPixmap"); signal != nil {
			f := func(iconMode gui.QIcon__Mode, pixmap *gui.QPixmap, opt *QStyleOption) *gui.QPixmap {
				(*(*func(gui.QIcon__Mode, *gui.QPixmap, *QStyleOption) *gui.QPixmap)(signal))(iconMode, pixmap, opt)
				return f(iconMode, pixmap, opt)
			}
			qt.ConnectSignal(ptr.Pointer(), "generatedIconPixmap", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "generatedIconPixmap", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectGeneratedIconPixmap() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) GeneratedIconPixmap(iconMode gui.QIcon__Mode, pixmap gui.QPixmap_ITF, opt QStyleOption_ITF) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QCommonStyle_GeneratedIconPixmap(ptr.Pointer(), C.longlong(iconMode), gui.PointerFromQPixmap(pixmap), PointerFromQStyleOption(opt)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func (ptr *QCommonStyle) GeneratedIconPixmapDefault(iconMode gui.QIcon__Mode, pixmap gui.QPixmap_ITF, opt QStyleOption_ITF) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QCommonStyle_GeneratedIconPixmapDefault(ptr.Pointer(), C.longlong(iconMode), gui.PointerFromQPixmap(pixmap), PointerFromQStyleOption(opt)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

//export callbackQCommonStyle_StandardPixmap
func callbackQCommonStyle_StandardPixmap(ptr unsafe.Pointer, sp C.longlong, option unsafe.Pointer, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "standardPixmap"); signal != nil {
		return gui.PointerFromQPixmap((*(*func(QStyle__StandardPixmap, *QStyleOption, *QWidget) *gui.QPixmap)(signal))(QStyle__StandardPixmap(sp), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget)))
	}

	return gui.PointerFromQPixmap(NewQCommonStyleFromPointer(ptr).StandardPixmapDefault(QStyle__StandardPixmap(sp), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget)))
}

func (ptr *QCommonStyle) ConnectStandardPixmap(f func(sp QStyle__StandardPixmap, option *QStyleOption, widget *QWidget) *gui.QPixmap) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "standardPixmap"); signal != nil {
			f := func(sp QStyle__StandardPixmap, option *QStyleOption, widget *QWidget) *gui.QPixmap {
				(*(*func(QStyle__StandardPixmap, *QStyleOption, *QWidget) *gui.QPixmap)(signal))(sp, option, widget)
				return f(sp, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "standardPixmap", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "standardPixmap", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectStandardPixmap() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) StandardPixmap(sp QStyle__StandardPixmap, option QStyleOption_ITF, widget QWidget_ITF) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QCommonStyle_StandardPixmap(ptr.Pointer(), C.longlong(sp), PointerFromQStyleOption(option), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func (ptr *QCommonStyle) StandardPixmapDefault(sp QStyle__StandardPixmap, option QStyleOption_ITF, widget QWidget_ITF) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QCommonStyle_StandardPixmapDefault(ptr.Pointer(), C.longlong(sp), PointerFromQStyleOption(option), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

//export callbackQCommonStyle_SubControlRect
func callbackQCommonStyle_SubControlRect(ptr unsafe.Pointer, cc C.longlong, opt unsafe.Pointer, sc C.longlong, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "subControlRect"); signal != nil {
		return core.PointerFromQRect((*(*func(QStyle__ComplexControl, *QStyleOptionComplex, QStyle__SubControl, *QWidget) *core.QRect)(signal))(QStyle__ComplexControl(cc), NewQStyleOptionComplexFromPointer(opt), QStyle__SubControl(sc), NewQWidgetFromPointer(widget)))
	}

	return core.PointerFromQRect(NewQCommonStyleFromPointer(ptr).SubControlRectDefault(QStyle__ComplexControl(cc), NewQStyleOptionComplexFromPointer(opt), QStyle__SubControl(sc), NewQWidgetFromPointer(widget)))
}

func (ptr *QCommonStyle) ConnectSubControlRect(f func(cc QStyle__ComplexControl, opt *QStyleOptionComplex, sc QStyle__SubControl, widget *QWidget) *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "subControlRect"); signal != nil {
			f := func(cc QStyle__ComplexControl, opt *QStyleOptionComplex, sc QStyle__SubControl, widget *QWidget) *core.QRect {
				(*(*func(QStyle__ComplexControl, *QStyleOptionComplex, QStyle__SubControl, *QWidget) *core.QRect)(signal))(cc, opt, sc, widget)
				return f(cc, opt, sc, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "subControlRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "subControlRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectSubControlRect() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) SubControlRect(cc QStyle__ComplexControl, opt QStyleOptionComplex_ITF, sc QStyle__SubControl, widget QWidget_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QCommonStyle_SubControlRect(ptr.Pointer(), C.longlong(cc), PointerFromQStyleOptionComplex(opt), C.longlong(sc), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QCommonStyle) SubControlRectDefault(cc QStyle__ComplexControl, opt QStyleOptionComplex_ITF, sc QStyle__SubControl, widget QWidget_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QCommonStyle_SubControlRectDefault(ptr.Pointer(), C.longlong(cc), PointerFromQStyleOptionComplex(opt), C.longlong(sc), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQCommonStyle_SubElementRect
func callbackQCommonStyle_SubElementRect(ptr unsafe.Pointer, sr C.longlong, opt unsafe.Pointer, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "subElementRect"); signal != nil {
		return core.PointerFromQRect((*(*func(QStyle__SubElement, *QStyleOption, *QWidget) *core.QRect)(signal))(QStyle__SubElement(sr), NewQStyleOptionFromPointer(opt), NewQWidgetFromPointer(widget)))
	}

	return core.PointerFromQRect(NewQCommonStyleFromPointer(ptr).SubElementRectDefault(QStyle__SubElement(sr), NewQStyleOptionFromPointer(opt), NewQWidgetFromPointer(widget)))
}

func (ptr *QCommonStyle) ConnectSubElementRect(f func(sr QStyle__SubElement, opt *QStyleOption, widget *QWidget) *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "subElementRect"); signal != nil {
			f := func(sr QStyle__SubElement, opt *QStyleOption, widget *QWidget) *core.QRect {
				(*(*func(QStyle__SubElement, *QStyleOption, *QWidget) *core.QRect)(signal))(sr, opt, widget)
				return f(sr, opt, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "subElementRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "subElementRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectSubElementRect() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) SubElementRect(sr QStyle__SubElement, opt QStyleOption_ITF, widget QWidget_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QCommonStyle_SubElementRect(ptr.Pointer(), C.longlong(sr), PointerFromQStyleOption(opt), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QCommonStyle) SubElementRectDefault(sr QStyle__SubElement, opt QStyleOption_ITF, widget QWidget_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QCommonStyle_SubElementRectDefault(ptr.Pointer(), C.longlong(sr), PointerFromQStyleOption(opt), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQCommonStyle_SizeFromContents
func callbackQCommonStyle_SizeFromContents(ptr unsafe.Pointer, ct C.longlong, opt unsafe.Pointer, csz unsafe.Pointer, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeFromContents"); signal != nil {
		return core.PointerFromQSize((*(*func(QStyle__ContentsType, *QStyleOption, *core.QSize, *QWidget) *core.QSize)(signal))(QStyle__ContentsType(ct), NewQStyleOptionFromPointer(opt), core.NewQSizeFromPointer(csz), NewQWidgetFromPointer(widget)))
	}

	return core.PointerFromQSize(NewQCommonStyleFromPointer(ptr).SizeFromContentsDefault(QStyle__ContentsType(ct), NewQStyleOptionFromPointer(opt), core.NewQSizeFromPointer(csz), NewQWidgetFromPointer(widget)))
}

func (ptr *QCommonStyle) ConnectSizeFromContents(f func(ct QStyle__ContentsType, opt *QStyleOption, csz *core.QSize, widget *QWidget) *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeFromContents"); signal != nil {
			f := func(ct QStyle__ContentsType, opt *QStyleOption, csz *core.QSize, widget *QWidget) *core.QSize {
				(*(*func(QStyle__ContentsType, *QStyleOption, *core.QSize, *QWidget) *core.QSize)(signal))(ct, opt, csz, widget)
				return f(ct, opt, csz, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeFromContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeFromContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectSizeFromContents() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) SizeFromContents(ct QStyle__ContentsType, opt QStyleOption_ITF, csz core.QSize_ITF, widget QWidget_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QCommonStyle_SizeFromContents(ptr.Pointer(), C.longlong(ct), PointerFromQStyleOption(opt), core.PointerFromQSize(csz), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QCommonStyle) SizeFromContentsDefault(ct QStyle__ContentsType, opt QStyleOption_ITF, csz core.QSize_ITF, widget QWidget_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QCommonStyle_SizeFromContentsDefault(ptr.Pointer(), C.longlong(ct), PointerFromQStyleOption(opt), core.PointerFromQSize(csz), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQCommonStyle_HitTestComplexControl
func callbackQCommonStyle_HitTestComplexControl(ptr unsafe.Pointer, cc C.longlong, opt unsafe.Pointer, pt unsafe.Pointer, widget unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "hitTestComplexControl"); signal != nil {
		return C.longlong((*(*func(QStyle__ComplexControl, *QStyleOptionComplex, *core.QPoint, *QWidget) QStyle__SubControl)(signal))(QStyle__ComplexControl(cc), NewQStyleOptionComplexFromPointer(opt), core.NewQPointFromPointer(pt), NewQWidgetFromPointer(widget)))
	}

	return C.longlong(NewQCommonStyleFromPointer(ptr).HitTestComplexControlDefault(QStyle__ComplexControl(cc), NewQStyleOptionComplexFromPointer(opt), core.NewQPointFromPointer(pt), NewQWidgetFromPointer(widget)))
}

func (ptr *QCommonStyle) ConnectHitTestComplexControl(f func(cc QStyle__ComplexControl, opt *QStyleOptionComplex, pt *core.QPoint, widget *QWidget) QStyle__SubControl) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hitTestComplexControl"); signal != nil {
			f := func(cc QStyle__ComplexControl, opt *QStyleOptionComplex, pt *core.QPoint, widget *QWidget) QStyle__SubControl {
				(*(*func(QStyle__ComplexControl, *QStyleOptionComplex, *core.QPoint, *QWidget) QStyle__SubControl)(signal))(cc, opt, pt, widget)
				return f(cc, opt, pt, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "hitTestComplexControl", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hitTestComplexControl", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectHitTestComplexControl() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) HitTestComplexControl(cc QStyle__ComplexControl, opt QStyleOptionComplex_ITF, pt core.QPoint_ITF, widget QWidget_ITF) QStyle__SubControl {
	if ptr.Pointer() != nil {
		return QStyle__SubControl(C.QCommonStyle_HitTestComplexControl(ptr.Pointer(), C.longlong(cc), PointerFromQStyleOptionComplex(opt), core.PointerFromQPoint(pt), PointerFromQWidget(widget)))
	}
	return 0
}

func (ptr *QCommonStyle) HitTestComplexControlDefault(cc QStyle__ComplexControl, opt QStyleOptionComplex_ITF, pt core.QPoint_ITF, widget QWidget_ITF) QStyle__SubControl {
	if ptr.Pointer() != nil {
		return QStyle__SubControl(C.QCommonStyle_HitTestComplexControlDefault(ptr.Pointer(), C.longlong(cc), PointerFromQStyleOptionComplex(opt), core.PointerFromQPoint(pt), PointerFromQWidget(widget)))
	}
	return 0
}

//export callbackQCommonStyle_LayoutSpacing
func callbackQCommonStyle_LayoutSpacing(ptr unsafe.Pointer, control1 C.longlong, control2 C.longlong, orientation C.longlong, option unsafe.Pointer, widget unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "layoutSpacing"); signal != nil {
		return C.int(int32((*(*func(QSizePolicy__ControlType, QSizePolicy__ControlType, core.Qt__Orientation, *QStyleOption, *QWidget) int)(signal))(QSizePolicy__ControlType(control1), QSizePolicy__ControlType(control2), core.Qt__Orientation(orientation), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget))))
	}

	return C.int(int32(NewQCommonStyleFromPointer(ptr).LayoutSpacingDefault(QSizePolicy__ControlType(control1), QSizePolicy__ControlType(control2), core.Qt__Orientation(orientation), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget))))
}

func (ptr *QCommonStyle) ConnectLayoutSpacing(f func(control1 QSizePolicy__ControlType, control2 QSizePolicy__ControlType, orientation core.Qt__Orientation, option *QStyleOption, widget *QWidget) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "layoutSpacing"); signal != nil {
			f := func(control1 QSizePolicy__ControlType, control2 QSizePolicy__ControlType, orientation core.Qt__Orientation, option *QStyleOption, widget *QWidget) int {
				(*(*func(QSizePolicy__ControlType, QSizePolicy__ControlType, core.Qt__Orientation, *QStyleOption, *QWidget) int)(signal))(control1, control2, orientation, option, widget)
				return f(control1, control2, orientation, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "layoutSpacing", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "layoutSpacing", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectLayoutSpacing() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) LayoutSpacing(control1 QSizePolicy__ControlType, control2 QSizePolicy__ControlType, orientation core.Qt__Orientation, option QStyleOption_ITF, widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCommonStyle_LayoutSpacing(ptr.Pointer(), C.longlong(control1), C.longlong(control2), C.longlong(orientation), PointerFromQStyleOption(option), PointerFromQWidget(widget))))
	}
	return 0
}

func (ptr *QCommonStyle) LayoutSpacingDefault(control1 QSizePolicy__ControlType, control2 QSizePolicy__ControlType, orientation core.Qt__Orientation, option QStyleOption_ITF, widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCommonStyle_LayoutSpacingDefault(ptr.Pointer(), C.longlong(control1), C.longlong(control2), C.longlong(orientation), PointerFromQStyleOption(option), PointerFromQWidget(widget))))
	}
	return 0
}

//export callbackQCommonStyle_PixelMetric
func callbackQCommonStyle_PixelMetric(ptr unsafe.Pointer, m C.longlong, opt unsafe.Pointer, widget unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "pixelMetric"); signal != nil {
		return C.int(int32((*(*func(QStyle__PixelMetric, *QStyleOption, *QWidget) int)(signal))(QStyle__PixelMetric(m), NewQStyleOptionFromPointer(opt), NewQWidgetFromPointer(widget))))
	}

	return C.int(int32(NewQCommonStyleFromPointer(ptr).PixelMetricDefault(QStyle__PixelMetric(m), NewQStyleOptionFromPointer(opt), NewQWidgetFromPointer(widget))))
}

func (ptr *QCommonStyle) ConnectPixelMetric(f func(m QStyle__PixelMetric, opt *QStyleOption, widget *QWidget) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "pixelMetric"); signal != nil {
			f := func(m QStyle__PixelMetric, opt *QStyleOption, widget *QWidget) int {
				(*(*func(QStyle__PixelMetric, *QStyleOption, *QWidget) int)(signal))(m, opt, widget)
				return f(m, opt, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "pixelMetric", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "pixelMetric", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectPixelMetric() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) PixelMetric(m QStyle__PixelMetric, opt QStyleOption_ITF, widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCommonStyle_PixelMetric(ptr.Pointer(), C.longlong(m), PointerFromQStyleOption(opt), PointerFromQWidget(widget))))
	}
	return 0
}

func (ptr *QCommonStyle) PixelMetricDefault(m QStyle__PixelMetric, opt QStyleOption_ITF, widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCommonStyle_PixelMetricDefault(ptr.Pointer(), C.longlong(m), PointerFromQStyleOption(opt), PointerFromQWidget(widget))))
	}
	return 0
}

//export callbackQCommonStyle_StyleHint
func callbackQCommonStyle_StyleHint(ptr unsafe.Pointer, sh C.longlong, opt unsafe.Pointer, widget unsafe.Pointer, hret unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "styleHint"); signal != nil {
		return C.int(int32((*(*func(QStyle__StyleHint, *QStyleOption, *QWidget, *QStyleHintReturn) int)(signal))(QStyle__StyleHint(sh), NewQStyleOptionFromPointer(opt), NewQWidgetFromPointer(widget), NewQStyleHintReturnFromPointer(hret))))
	}

	return C.int(int32(NewQCommonStyleFromPointer(ptr).StyleHintDefault(QStyle__StyleHint(sh), NewQStyleOptionFromPointer(opt), NewQWidgetFromPointer(widget), NewQStyleHintReturnFromPointer(hret))))
}

func (ptr *QCommonStyle) ConnectStyleHint(f func(sh QStyle__StyleHint, opt *QStyleOption, widget *QWidget, hret *QStyleHintReturn) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "styleHint"); signal != nil {
			f := func(sh QStyle__StyleHint, opt *QStyleOption, widget *QWidget, hret *QStyleHintReturn) int {
				(*(*func(QStyle__StyleHint, *QStyleOption, *QWidget, *QStyleHintReturn) int)(signal))(sh, opt, widget, hret)
				return f(sh, opt, widget, hret)
			}
			qt.ConnectSignal(ptr.Pointer(), "styleHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "styleHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectStyleHint() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) StyleHint(sh QStyle__StyleHint, opt QStyleOption_ITF, widget QWidget_ITF, hret QStyleHintReturn_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCommonStyle_StyleHint(ptr.Pointer(), C.longlong(sh), PointerFromQStyleOption(opt), PointerFromQWidget(widget), PointerFromQStyleHintReturn(hret))))
	}
	return 0
}

func (ptr *QCommonStyle) StyleHintDefault(sh QStyle__StyleHint, opt QStyleOption_ITF, widget QWidget_ITF, hret QStyleHintReturn_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCommonStyle_StyleHintDefault(ptr.Pointer(), C.longlong(sh), PointerFromQStyleOption(opt), PointerFromQWidget(widget), PointerFromQStyleHintReturn(hret))))
	}
	return 0
}

//export callbackQCommonStyle_DrawComplexControl
func callbackQCommonStyle_DrawComplexControl(ptr unsafe.Pointer, cc C.longlong, opt unsafe.Pointer, p unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawComplexControl"); signal != nil {
		(*(*func(QStyle__ComplexControl, *QStyleOptionComplex, *gui.QPainter, *QWidget))(signal))(QStyle__ComplexControl(cc), NewQStyleOptionComplexFromPointer(opt), gui.NewQPainterFromPointer(p), NewQWidgetFromPointer(widget))
	} else {
		NewQCommonStyleFromPointer(ptr).DrawComplexControlDefault(QStyle__ComplexControl(cc), NewQStyleOptionComplexFromPointer(opt), gui.NewQPainterFromPointer(p), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QCommonStyle) ConnectDrawComplexControl(f func(cc QStyle__ComplexControl, opt *QStyleOptionComplex, p *gui.QPainter, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawComplexControl"); signal != nil {
			f := func(cc QStyle__ComplexControl, opt *QStyleOptionComplex, p *gui.QPainter, widget *QWidget) {
				(*(*func(QStyle__ComplexControl, *QStyleOptionComplex, *gui.QPainter, *QWidget))(signal))(cc, opt, p, widget)
				f(cc, opt, p, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawComplexControl", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawComplexControl", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectDrawComplexControl() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) DrawComplexControl(cc QStyle__ComplexControl, opt QStyleOptionComplex_ITF, p gui.QPainter_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QCommonStyle_DrawComplexControl(ptr.Pointer(), C.longlong(cc), PointerFromQStyleOptionComplex(opt), gui.PointerFromQPainter(p), PointerFromQWidget(widget))
	}
}

func (ptr *QCommonStyle) DrawComplexControlDefault(cc QStyle__ComplexControl, opt QStyleOptionComplex_ITF, p gui.QPainter_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QCommonStyle_DrawComplexControlDefault(ptr.Pointer(), C.longlong(cc), PointerFromQStyleOptionComplex(opt), gui.PointerFromQPainter(p), PointerFromQWidget(widget))
	}
}

//export callbackQCommonStyle_DrawControl
func callbackQCommonStyle_DrawControl(ptr unsafe.Pointer, element C.longlong, opt unsafe.Pointer, p unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawControl"); signal != nil {
		(*(*func(QStyle__ControlElement, *QStyleOption, *gui.QPainter, *QWidget))(signal))(QStyle__ControlElement(element), NewQStyleOptionFromPointer(opt), gui.NewQPainterFromPointer(p), NewQWidgetFromPointer(widget))
	} else {
		NewQCommonStyleFromPointer(ptr).DrawControlDefault(QStyle__ControlElement(element), NewQStyleOptionFromPointer(opt), gui.NewQPainterFromPointer(p), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QCommonStyle) ConnectDrawControl(f func(element QStyle__ControlElement, opt *QStyleOption, p *gui.QPainter, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawControl"); signal != nil {
			f := func(element QStyle__ControlElement, opt *QStyleOption, p *gui.QPainter, widget *QWidget) {
				(*(*func(QStyle__ControlElement, *QStyleOption, *gui.QPainter, *QWidget))(signal))(element, opt, p, widget)
				f(element, opt, p, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawControl", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawControl", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectDrawControl() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) DrawControl(element QStyle__ControlElement, opt QStyleOption_ITF, p gui.QPainter_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QCommonStyle_DrawControl(ptr.Pointer(), C.longlong(element), PointerFromQStyleOption(opt), gui.PointerFromQPainter(p), PointerFromQWidget(widget))
	}
}

func (ptr *QCommonStyle) DrawControlDefault(element QStyle__ControlElement, opt QStyleOption_ITF, p gui.QPainter_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QCommonStyle_DrawControlDefault(ptr.Pointer(), C.longlong(element), PointerFromQStyleOption(opt), gui.PointerFromQPainter(p), PointerFromQWidget(widget))
	}
}

//export callbackQCommonStyle_DrawPrimitive
func callbackQCommonStyle_DrawPrimitive(ptr unsafe.Pointer, pe C.longlong, opt unsafe.Pointer, p unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawPrimitive"); signal != nil {
		(*(*func(QStyle__PrimitiveElement, *QStyleOption, *gui.QPainter, *QWidget))(signal))(QStyle__PrimitiveElement(pe), NewQStyleOptionFromPointer(opt), gui.NewQPainterFromPointer(p), NewQWidgetFromPointer(widget))
	} else {
		NewQCommonStyleFromPointer(ptr).DrawPrimitiveDefault(QStyle__PrimitiveElement(pe), NewQStyleOptionFromPointer(opt), gui.NewQPainterFromPointer(p), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QCommonStyle) ConnectDrawPrimitive(f func(pe QStyle__PrimitiveElement, opt *QStyleOption, p *gui.QPainter, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawPrimitive"); signal != nil {
			f := func(pe QStyle__PrimitiveElement, opt *QStyleOption, p *gui.QPainter, widget *QWidget) {
				(*(*func(QStyle__PrimitiveElement, *QStyleOption, *gui.QPainter, *QWidget))(signal))(pe, opt, p, widget)
				f(pe, opt, p, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawPrimitive", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawPrimitive", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QCommonStyle) DisconnectDrawPrimitive() {
	if ptr.Pointer() != nil {

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

func (ptr *QCommonStyle) DrawPrimitive(pe QStyle__PrimitiveElement, opt QStyleOption_ITF, p gui.QPainter_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QCommonStyle_DrawPrimitive(ptr.Pointer(), C.longlong(pe), PointerFromQStyleOption(opt), gui.PointerFromQPainter(p), PointerFromQWidget(widget))
	}
}

func (ptr *QCommonStyle) DrawPrimitiveDefault(pe QStyle__PrimitiveElement, opt QStyleOption_ITF, p gui.QPainter_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QCommonStyle_DrawPrimitiveDefault(ptr.Pointer(), C.longlong(pe), PointerFromQStyleOption(opt), gui.PointerFromQPainter(p), PointerFromQWidget(widget))
	}
}

//export callbackQCommonStyle_StandardIcon
func callbackQCommonStyle_StandardIcon(ptr unsafe.Pointer, standardIcon C.longlong, option unsafe.Pointer, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "standardIcon"); signal != nil {
		return gui.PointerFromQIcon((*(*func(QStyle__StandardPixmap, *QStyleOption, *QWidget) *gui.QIcon)(signal))(QStyle__StandardPixmap(standardIcon), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget)))
	}

	return gui.PointerFromQIcon(NewQCommonStyleFromPointer(ptr).StandardIconDefault(QStyle__StandardPixmap(standardIcon), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget)))
}

func (ptr *QCommonStyle) StandardIcon(standardIcon QStyle__StandardPixmap, option QStyleOption_ITF, widget QWidget_ITF) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QCommonStyle_StandardIcon(ptr.Pointer(), C.longlong(standardIcon), PointerFromQStyleOption(option), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QCommonStyle) StandardIconDefault(standardIcon QStyle__StandardPixmap, option QStyleOption_ITF, widget QWidget_ITF) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QCommonStyle_StandardIconDefault(ptr.Pointer(), C.longlong(standardIcon), PointerFromQStyleOption(option), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

type QCompleter struct {
	core.QObject
}

type QCompleter_ITF interface {
	core.QObject_ITF
	QCompleter_PTR() *QCompleter
}

func (ptr *QCompleter) QCompleter_PTR() *QCompleter {
	return ptr
}

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

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

func PointerFromQCompleter(ptr QCompleter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCompleter_PTR().Pointer()
	}
	return nil
}

func NewQCompleterFromPointer(ptr unsafe.Pointer) (n *QCompleter) {
	n = new(QCompleter)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QCompleter__CompletionMode
//QCompleter::CompletionMode
type QCompleter__CompletionMode int64

const (
	QCompleter__PopupCompletion           QCompleter__CompletionMode = QCompleter__CompletionMode(0)
	QCompleter__UnfilteredPopupCompletion QCompleter__CompletionMode = QCompleter__CompletionMode(1)
	QCompleter__InlineCompletion          QCompleter__CompletionMode = QCompleter__CompletionMode(2)
)

//go:generate stringer -type=QCompleter__ModelSorting
//QCompleter::ModelSorting
type QCompleter__ModelSorting int64

const (
	QCompleter__UnsortedModel                QCompleter__ModelSorting = QCompleter__ModelSorting(0)
	QCompleter__CaseSensitivelySortedModel   QCompleter__ModelSorting = QCompleter__ModelSorting(1)
	QCompleter__CaseInsensitivelySortedModel QCompleter__ModelSorting = QCompleter__ModelSorting(2)
)

func NewQCompleter2(model core.QAbstractItemModel_ITF, parent core.QObject_ITF) *QCompleter {
	tmpValue := NewQCompleterFromPointer(C.QCompleter_NewQCompleter2(core.PointerFromQAbstractItemModel(model), core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQCompleter(parent core.QObject_ITF) *QCompleter {
	tmpValue := NewQCompleterFromPointer(C.QCompleter_NewQCompleter(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQCompleter3(list []string, parent core.QObject_ITF) *QCompleter {
	listC := C.CString(strings.Join(list, "|"))
	defer C.free(unsafe.Pointer(listC))
	tmpValue := NewQCompleterFromPointer(C.QCompleter_NewQCompleter3(C.struct_QtWidgets_PackedString{data: listC, len: C.longlong(len(strings.Join(list, "|")))}, core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QCompleter_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QCompleter_QCompleter_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QCompleter) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QCompleter_QCompleter_Tr(sC, cC, C.int(int32(n))))
}

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

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

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

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

	return C.char(int8(qt.GoBoolToInt(NewQCompleterFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(o), core.NewQEventFromPointer(e)))))
}

func (ptr *QCompleter) EventFilterDefault(o core.QObject_ITF, e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCompleter_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(o), core.PointerFromQEvent(e))) != 0
	}
	return false
}

func (ptr *QCompleter) SetCurrentRow(row int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QCompleter_SetCurrentRow(ptr.Pointer(), C.int(int32(row)))) != 0
	}
	return false
}

//export callbackQCompleter_Activated2
func callbackQCompleter_Activated2(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "activated2"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QCompleter) ConnectActivated2(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activated2") {
			C.QCompleter_ConnectActivated2(ptr.Pointer())
		}

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

func (ptr *QCompleter) DisconnectActivated2() {
	if ptr.Pointer() != nil {
		C.QCompleter_DisconnectActivated2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activated2")
	}
}

func (ptr *QCompleter) Activated2(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QCompleter_Activated2(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQCompleter_Activated
func callbackQCompleter_Activated(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "activated"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QCompleter) ConnectActivated(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activated") {
			C.QCompleter_ConnectActivated(ptr.Pointer())
		}

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

func (ptr *QCompleter) DisconnectActivated() {
	if ptr.Pointer() != nil {
		C.QCompleter_DisconnectActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activated")
	}
}

func (ptr *QCompleter) Activated(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QCompleter_Activated(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQCompleter_Complete
func callbackQCompleter_Complete(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "complete"); signal != nil {
		(*(*func(*core.QRect))(signal))(core.NewQRectFromPointer(rect))
	} else {
		NewQCompleterFromPointer(ptr).CompleteDefault(core.NewQRectFromPointer(rect))
	}
}

func (ptr *QCompleter) ConnectComplete(f func(rect *core.QRect)) {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) DisconnectComplete() {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) Complete(rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QCompleter_Complete(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QCompleter) CompleteDefault(rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QCompleter_CompleteDefault(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

//export callbackQCompleter_Highlighted2
func callbackQCompleter_Highlighted2(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "highlighted2"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QCompleter) ConnectHighlighted2(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "highlighted2") {
			C.QCompleter_ConnectHighlighted2(ptr.Pointer())
		}

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

func (ptr *QCompleter) DisconnectHighlighted2() {
	if ptr.Pointer() != nil {
		C.QCompleter_DisconnectHighlighted2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "highlighted2")
	}
}

func (ptr *QCompleter) Highlighted2(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QCompleter_Highlighted2(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQCompleter_Highlighted
func callbackQCompleter_Highlighted(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "highlighted"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QCompleter) ConnectHighlighted(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "highlighted") {
			C.QCompleter_ConnectHighlighted(ptr.Pointer())
		}

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

func (ptr *QCompleter) DisconnectHighlighted() {
	if ptr.Pointer() != nil {
		C.QCompleter_DisconnectHighlighted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "highlighted")
	}
}

func (ptr *QCompleter) Highlighted(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QCompleter_Highlighted(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QCompleter) SetCaseSensitivity(caseSensitivity core.Qt__CaseSensitivity) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetCaseSensitivity(ptr.Pointer(), C.longlong(caseSensitivity))
	}
}

func (ptr *QCompleter) SetCompletionColumn(column int) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetCompletionColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QCompleter) SetCompletionMode(mode QCompleter__CompletionMode) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetCompletionMode(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQCompleter_SetCompletionPrefix
func callbackQCompleter_SetCompletionPrefix(ptr unsafe.Pointer, prefix C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setCompletionPrefix"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(prefix))
	} else {
		NewQCompleterFromPointer(ptr).SetCompletionPrefixDefault(cGoUnpackString(prefix))
	}
}

func (ptr *QCompleter) ConnectSetCompletionPrefix(f func(prefix string)) {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) DisconnectSetCompletionPrefix() {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) SetCompletionPrefix(prefix string) {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		C.QCompleter_SetCompletionPrefix(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: prefixC, len: C.longlong(len(prefix))})
	}
}

func (ptr *QCompleter) SetCompletionPrefixDefault(prefix string) {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		C.QCompleter_SetCompletionPrefixDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: prefixC, len: C.longlong(len(prefix))})
	}
}

func (ptr *QCompleter) SetCompletionRole(role int) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetCompletionRole(ptr.Pointer(), C.int(int32(role)))
	}
}

func (ptr *QCompleter) SetFilterMode(filterMode core.Qt__MatchFlag) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetFilterMode(ptr.Pointer(), C.longlong(filterMode))
	}
}

func (ptr *QCompleter) SetMaxVisibleItems(maxItems int) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetMaxVisibleItems(ptr.Pointer(), C.int(int32(maxItems)))
	}
}

func (ptr *QCompleter) SetModel(model core.QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetModel(ptr.Pointer(), core.PointerFromQAbstractItemModel(model))
	}
}

func (ptr *QCompleter) SetModelSorting(sorting QCompleter__ModelSorting) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetModelSorting(ptr.Pointer(), C.longlong(sorting))
	}
}

func (ptr *QCompleter) SetPopup(popup QAbstractItemView_ITF) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetPopup(ptr.Pointer(), PointerFromQAbstractItemView(popup))
	}
}

func (ptr *QCompleter) SetWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQCompleter_SetWrapAround
func callbackQCompleter_SetWrapAround(ptr unsafe.Pointer, wrap C.char) {
	if signal := qt.GetSignal(ptr, "setWrapAround"); signal != nil {
		(*(*func(bool))(signal))(int8(wrap) != 0)
	} else {
		NewQCompleterFromPointer(ptr).SetWrapAroundDefault(int8(wrap) != 0)
	}
}

func (ptr *QCompleter) ConnectSetWrapAround(f func(wrap bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) DisconnectSetWrapAround() {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) SetWrapAround(wrap bool) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetWrapAround(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(wrap))))
	}
}

func (ptr *QCompleter) SetWrapAroundDefault(wrap bool) {
	if ptr.Pointer() != nil {
		C.QCompleter_SetWrapAroundDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(wrap))))
	}
}

//export callbackQCompleter_DestroyQCompleter
func callbackQCompleter_DestroyQCompleter(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QCompleter"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCompleterFromPointer(ptr).DestroyQCompleterDefault()
	}
}

func (ptr *QCompleter) ConnectDestroyQCompleter(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) DisconnectDestroyQCompleter() {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) DestroyQCompleter() {
	if ptr.Pointer() != nil {
		C.QCompleter_DestroyQCompleter(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCompleter) DestroyQCompleterDefault() {
	if ptr.Pointer() != nil {
		C.QCompleter_DestroyQCompleterDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QCompleter) CompletionModel() *core.QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractItemModelFromPointer(C.QCompleter_CompletionModel(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QCompleter) Model() *core.QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractItemModelFromPointer(C.QCompleter_Model(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QCompleter) Popup() *QAbstractItemView {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemViewFromPointer(C.QCompleter_Popup(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QCompleter) CompletionMode() QCompleter__CompletionMode {
	if ptr.Pointer() != nil {
		return QCompleter__CompletionMode(C.QCompleter_CompletionMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCompleter) ModelSorting() QCompleter__ModelSorting {
	if ptr.Pointer() != nil {
		return QCompleter__ModelSorting(C.QCompleter_ModelSorting(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCompleter) CurrentIndex() *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QCompleter_CurrentIndex(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QCompleter) CompletionPrefix() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCompleter_CompletionPrefix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QCompleter) CurrentCompletion() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCompleter_CurrentCompletion(ptr.Pointer()))
	}
	return ""
}

//export callbackQCompleter_PathFromIndex
func callbackQCompleter_PathFromIndex(ptr unsafe.Pointer, index unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "pathFromIndex"); signal != nil {
		tempVal := (*(*func(*core.QModelIndex) string)(signal))(core.NewQModelIndexFromPointer(index))
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQCompleterFromPointer(ptr).PathFromIndexDefault(core.NewQModelIndexFromPointer(index))
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QCompleter) ConnectPathFromIndex(f func(index *core.QModelIndex) string) {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) DisconnectPathFromIndex() {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) PathFromIndex(index core.QModelIndex_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCompleter_PathFromIndex(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return ""
}

func (ptr *QCompleter) PathFromIndexDefault(index core.QModelIndex_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QCompleter_PathFromIndexDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return ""
}

//export callbackQCompleter_SplitPath
func callbackQCompleter_SplitPath(ptr unsafe.Pointer, path C.struct_QtWidgets_PackedString) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "splitPath"); signal != nil {
		tempVal := (*(*func(string) []string)(signal))(cGoUnpackString(path))
		return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
	}
	tempVal := NewQCompleterFromPointer(ptr).SplitPathDefault(cGoUnpackString(path))
	return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
}

func (ptr *QCompleter) ConnectSplitPath(f func(path string) []string) {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) DisconnectSplitPath() {
	if ptr.Pointer() != nil {

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

func (ptr *QCompleter) SplitPath(path string) []string {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		return strings.Split(cGoUnpackString(C.QCompleter_SplitPath(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: pathC, len: C.longlong(len(path))})), "|")
	}
	return make([]string, 0)
}

func (ptr *QCompleter) SplitPathDefault(path string) []string {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		return strings.Split(cGoUnpackString(C.QCompleter_SplitPathDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: pathC, len: C.longlong(len(path))})), "|")
	}
	return make([]string, 0)
}

func (ptr *QCompleter) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QCompleter_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QCompleter) CaseSensitivity() core.Qt__CaseSensitivity {
	if ptr.Pointer() != nil {
		return core.Qt__CaseSensitivity(C.QCompleter_CaseSensitivity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCompleter) FilterMode() core.Qt__MatchFlag {
	if ptr.Pointer() != nil {
		return core.Qt__MatchFlag(C.QCompleter_FilterMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCompleter) WrapAround() bool {
	if ptr.Pointer() != nil {
		return int8(C.QCompleter_WrapAround(ptr.Pointer())) != 0
	}
	return false
}

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

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

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

func (ptr *QCompleter) CompletionColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCompleter_CompletionColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QCompleter) CompletionCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCompleter_CompletionCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QCompleter) CompletionRole() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCompleter_CompletionRole(ptr.Pointer())))
	}
	return 0
}

func (ptr *QCompleter) CurrentRow() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCompleter_CurrentRow(ptr.Pointer())))
	}
	return 0
}

func (ptr *QCompleter) MaxVisibleItems() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QCompleter_MaxVisibleItems(ptr.Pointer())))
	}
	return 0
}

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

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

func (ptr *QCompleter) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QCompleter___dynamicPropertyNames_newList(ptr.Pointer())
}

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

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

func (ptr *QCompleter) __findChildren_newList2() unsafe.Pointer {
	return C.QCompleter___findChildren_newList2(ptr.Pointer())
}

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

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

func (ptr *QCompleter) __findChildren_newList3() unsafe.Pointer {
	return C.QCompleter___findChildren_newList3(ptr.Pointer())
}

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

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

func (ptr *QCompleter) __findChildren_newList() unsafe.Pointer {
	return C.QCompleter___findChildren_newList(ptr.Pointer())
}

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

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

func (ptr *QCompleter) __children_newList() unsafe.Pointer {
	return C.QCompleter___children_newList(ptr.Pointer())
}

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

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

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

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

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

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

//export callbackQCompleter_DeleteLater
func callbackQCompleter_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQCompleterFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QCompleter) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QCompleter_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

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

}

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

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

//export callbackQCompleter_ObjectNameChanged
func callbackQCompleter_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

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

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

type QDataWidgetMapper struct {
	core.QObject
}

type QDataWidgetMapper_ITF interface {
	core.QObject_ITF
	QDataWidgetMapper_PTR() *QDataWidgetMapper
}

func (ptr *QDataWidgetMapper) QDataWidgetMapper_PTR() *QDataWidgetMapper {
	return ptr
}

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

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

func PointerFromQDataWidgetMapper(ptr QDataWidgetMapper_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDataWidgetMapper_PTR().Pointer()
	}
	return nil
}

func NewQDataWidgetMapperFromPointer(ptr unsafe.Pointer) (n *QDataWidgetMapper) {
	n = new(QDataWidgetMapper)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDataWidgetMapper__SubmitPolicy
//QDataWidgetMapper::SubmitPolicy
type QDataWidgetMapper__SubmitPolicy int64

const (
	QDataWidgetMapper__AutoSubmit   QDataWidgetMapper__SubmitPolicy = QDataWidgetMapper__SubmitPolicy(0)
	QDataWidgetMapper__ManualSubmit QDataWidgetMapper__SubmitPolicy = QDataWidgetMapper__SubmitPolicy(1)
)

func NewQDataWidgetMapper(parent core.QObject_ITF) *QDataWidgetMapper {
	tmpValue := NewQDataWidgetMapperFromPointer(C.QDataWidgetMapper_NewQDataWidgetMapper(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QDataWidgetMapper_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QDataWidgetMapper_QDataWidgetMapper_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QDataWidgetMapper) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QDataWidgetMapper_QDataWidgetMapper_Tr(sC, cC, C.int(int32(n))))
}

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

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

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

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

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

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

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

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

func (ptr *QDataWidgetMapper) AddMapping(widget QWidget_ITF, section int) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_AddMapping(ptr.Pointer(), PointerFromQWidget(widget), C.int(int32(section)))
	}
}

func (ptr *QDataWidgetMapper) AddMapping2(widget QWidget_ITF, section int, propertyName core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_AddMapping2(ptr.Pointer(), PointerFromQWidget(widget), C.int(int32(section)), core.PointerFromQByteArray(propertyName))
	}
}

func (ptr *QDataWidgetMapper) ClearMapping() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_ClearMapping(ptr.Pointer())
	}
}

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

}

func (ptr *QDataWidgetMapper) ConnectCurrentIndexChanged(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentIndexChanged") {
			C.QDataWidgetMapper_ConnectCurrentIndexChanged(ptr.Pointer())
		}

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

func (ptr *QDataWidgetMapper) DisconnectCurrentIndexChanged() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_DisconnectCurrentIndexChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentIndexChanged")
	}
}

func (ptr *QDataWidgetMapper) CurrentIndexChanged(index int) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_CurrentIndexChanged(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QDataWidgetMapper) RemoveMapping(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_RemoveMapping(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

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

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

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

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

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

func (ptr *QDataWidgetMapper) Revert() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_Revert(ptr.Pointer())
	}
}

func (ptr *QDataWidgetMapper) RevertDefault() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_RevertDefault(ptr.Pointer())
	}
}

//export callbackQDataWidgetMapper_SetCurrentIndex
func callbackQDataWidgetMapper_SetCurrentIndex(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQDataWidgetMapperFromPointer(ptr).SetCurrentIndexDefault(int(int32(index)))
	}
}

func (ptr *QDataWidgetMapper) ConnectSetCurrentIndex(f func(index int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) DisconnectSetCurrentIndex() {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) SetCurrentIndex(index int) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_SetCurrentIndex(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QDataWidgetMapper) SetCurrentIndexDefault(index int) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_SetCurrentIndexDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQDataWidgetMapper_SetCurrentModelIndex
func callbackQDataWidgetMapper_SetCurrentModelIndex(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setCurrentModelIndex"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQDataWidgetMapperFromPointer(ptr).SetCurrentModelIndexDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QDataWidgetMapper) ConnectSetCurrentModelIndex(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) DisconnectSetCurrentModelIndex() {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) SetCurrentModelIndex(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_SetCurrentModelIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QDataWidgetMapper) SetCurrentModelIndexDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_SetCurrentModelIndexDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QDataWidgetMapper) SetItemDelegate(delegate QAbstractItemDelegate_ITF) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_SetItemDelegate(ptr.Pointer(), PointerFromQAbstractItemDelegate(delegate))
	}
}

func (ptr *QDataWidgetMapper) SetModel(model core.QAbstractItemModel_ITF) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_SetModel(ptr.Pointer(), core.PointerFromQAbstractItemModel(model))
	}
}

func (ptr *QDataWidgetMapper) SetOrientation(aOrientation core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_SetOrientation(ptr.Pointer(), C.longlong(aOrientation))
	}
}

func (ptr *QDataWidgetMapper) SetRootIndex(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_SetRootIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QDataWidgetMapper) SetSubmitPolicy(policy QDataWidgetMapper__SubmitPolicy) {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_SetSubmitPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

//export callbackQDataWidgetMapper_ToFirst
func callbackQDataWidgetMapper_ToFirst(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "toFirst"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDataWidgetMapperFromPointer(ptr).ToFirstDefault()
	}
}

func (ptr *QDataWidgetMapper) ConnectToFirst(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) DisconnectToFirst() {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) ToFirst() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_ToFirst(ptr.Pointer())
	}
}

func (ptr *QDataWidgetMapper) ToFirstDefault() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_ToFirstDefault(ptr.Pointer())
	}
}

//export callbackQDataWidgetMapper_ToLast
func callbackQDataWidgetMapper_ToLast(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "toLast"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDataWidgetMapperFromPointer(ptr).ToLastDefault()
	}
}

func (ptr *QDataWidgetMapper) ConnectToLast(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) DisconnectToLast() {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) ToLast() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_ToLast(ptr.Pointer())
	}
}

func (ptr *QDataWidgetMapper) ToLastDefault() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_ToLastDefault(ptr.Pointer())
	}
}

//export callbackQDataWidgetMapper_ToNext
func callbackQDataWidgetMapper_ToNext(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "toNext"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDataWidgetMapperFromPointer(ptr).ToNextDefault()
	}
}

func (ptr *QDataWidgetMapper) ConnectToNext(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) DisconnectToNext() {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) ToNext() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_ToNext(ptr.Pointer())
	}
}

func (ptr *QDataWidgetMapper) ToNextDefault() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_ToNextDefault(ptr.Pointer())
	}
}

//export callbackQDataWidgetMapper_ToPrevious
func callbackQDataWidgetMapper_ToPrevious(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "toPrevious"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDataWidgetMapperFromPointer(ptr).ToPreviousDefault()
	}
}

func (ptr *QDataWidgetMapper) ConnectToPrevious(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) DisconnectToPrevious() {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) ToPrevious() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_ToPrevious(ptr.Pointer())
	}
}

func (ptr *QDataWidgetMapper) ToPreviousDefault() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_ToPreviousDefault(ptr.Pointer())
	}
}

//export callbackQDataWidgetMapper_DestroyQDataWidgetMapper
func callbackQDataWidgetMapper_DestroyQDataWidgetMapper(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QDataWidgetMapper"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDataWidgetMapperFromPointer(ptr).DestroyQDataWidgetMapperDefault()
	}
}

func (ptr *QDataWidgetMapper) ConnectDestroyQDataWidgetMapper(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) DisconnectDestroyQDataWidgetMapper() {
	if ptr.Pointer() != nil {

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

func (ptr *QDataWidgetMapper) DestroyQDataWidgetMapper() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_DestroyQDataWidgetMapper(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDataWidgetMapper) DestroyQDataWidgetMapperDefault() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_DestroyQDataWidgetMapperDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDataWidgetMapper) ItemDelegate() *QAbstractItemDelegate {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemDelegateFromPointer(C.QDataWidgetMapper_ItemDelegate(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDataWidgetMapper) Model() *core.QAbstractItemModel {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractItemModelFromPointer(C.QDataWidgetMapper_Model(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDataWidgetMapper) MappedPropertyName(widget QWidget_ITF) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QDataWidgetMapper_MappedPropertyName(ptr.Pointer(), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QDataWidgetMapper) SubmitPolicy() QDataWidgetMapper__SubmitPolicy {
	if ptr.Pointer() != nil {
		return QDataWidgetMapper__SubmitPolicy(C.QDataWidgetMapper_SubmitPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDataWidgetMapper) RootIndex() *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDataWidgetMapper_RootIndex(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDataWidgetMapper) MappedWidgetAt(section int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QDataWidgetMapper_MappedWidgetAt(ptr.Pointer(), C.int(int32(section))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDataWidgetMapper) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QDataWidgetMapper_Orientation(ptr.Pointer()))
	}
	return 0
}

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

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

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

func (ptr *QDataWidgetMapper) CurrentIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDataWidgetMapper_CurrentIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDataWidgetMapper) MappedSection(widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDataWidgetMapper_MappedSection(ptr.Pointer(), PointerFromQWidget(widget))))
	}
	return 0
}

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

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

func (ptr *QDataWidgetMapper) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QDataWidgetMapper___dynamicPropertyNames_newList(ptr.Pointer())
}

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

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

func (ptr *QDataWidgetMapper) __findChildren_newList2() unsafe.Pointer {
	return C.QDataWidgetMapper___findChildren_newList2(ptr.Pointer())
}

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

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

func (ptr *QDataWidgetMapper) __findChildren_newList3() unsafe.Pointer {
	return C.QDataWidgetMapper___findChildren_newList3(ptr.Pointer())
}

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

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

func (ptr *QDataWidgetMapper) __findChildren_newList() unsafe.Pointer {
	return C.QDataWidgetMapper___findChildren_newList(ptr.Pointer())
}

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

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

func (ptr *QDataWidgetMapper) __children_newList() unsafe.Pointer {
	return C.QDataWidgetMapper___children_newList(ptr.Pointer())
}

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

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

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

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

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

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

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

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

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

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

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

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

//export callbackQDataWidgetMapper_DeleteLater
func callbackQDataWidgetMapper_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDataWidgetMapperFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QDataWidgetMapper) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QDataWidgetMapper_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

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

}

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

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

//export callbackQDataWidgetMapper_ObjectNameChanged
func callbackQDataWidgetMapper_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

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

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

type QDateEdit struct {
	QDateTimeEdit
}

type QDateEdit_ITF interface {
	QDateTimeEdit_ITF
	QDateEdit_PTR() *QDateEdit
}

func (ptr *QDateEdit) QDateEdit_PTR() *QDateEdit {
	return ptr
}

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

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

func PointerFromQDateEdit(ptr QDateEdit_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDateEdit_PTR().Pointer()
	}
	return nil
}

func NewQDateEditFromPointer(ptr unsafe.Pointer) (n *QDateEdit) {
	n = new(QDateEdit)
	n.SetPointer(ptr)
	return
}
func NewQDateEdit(parent QWidget_ITF) *QDateEdit {
	tmpValue := NewQDateEditFromPointer(C.QDateEdit_NewQDateEdit(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQDateEdit2(date core.QDate_ITF, parent QWidget_ITF) *QDateEdit {
	tmpValue := NewQDateEditFromPointer(C.QDateEdit_NewQDateEdit2(core.PointerFromQDate(date), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQDateEdit_DestroyQDateEdit
func callbackQDateEdit_DestroyQDateEdit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QDateEdit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDateEditFromPointer(ptr).DestroyQDateEditDefault()
	}
}

func (ptr *QDateEdit) ConnectDestroyQDateEdit(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDateEdit) DisconnectDestroyQDateEdit() {
	if ptr.Pointer() != nil {

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

func (ptr *QDateEdit) DestroyQDateEdit() {
	if ptr.Pointer() != nil {
		C.QDateEdit_DestroyQDateEdit(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDateEdit) DestroyQDateEditDefault() {
	if ptr.Pointer() != nil {
		C.QDateEdit_DestroyQDateEditDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QDateTimeEdit struct {
	QAbstractSpinBox
}

type QDateTimeEdit_ITF interface {
	QAbstractSpinBox_ITF
	QDateTimeEdit_PTR() *QDateTimeEdit
}

func (ptr *QDateTimeEdit) QDateTimeEdit_PTR() *QDateTimeEdit {
	return ptr
}

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

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

func PointerFromQDateTimeEdit(ptr QDateTimeEdit_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDateTimeEdit_PTR().Pointer()
	}
	return nil
}

func NewQDateTimeEditFromPointer(ptr unsafe.Pointer) (n *QDateTimeEdit) {
	n = new(QDateTimeEdit)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDateTimeEdit__Section
//QDateTimeEdit::Section
type QDateTimeEdit__Section int64

const (
	QDateTimeEdit__NoSection     QDateTimeEdit__Section = QDateTimeEdit__Section(0x0000)
	QDateTimeEdit__AmPmSection   QDateTimeEdit__Section = QDateTimeEdit__Section(0x0001)
	QDateTimeEdit__MSecSection   QDateTimeEdit__Section = QDateTimeEdit__Section(0x0002)
	QDateTimeEdit__SecondSection QDateTimeEdit__Section = QDateTimeEdit__Section(0x0004)
	QDateTimeEdit__MinuteSection QDateTimeEdit__Section = QDateTimeEdit__Section(0x0008)
	QDateTimeEdit__HourSection   QDateTimeEdit__Section = QDateTimeEdit__Section(0x0010)
	QDateTimeEdit__DaySection    QDateTimeEdit__Section = QDateTimeEdit__Section(0x0100)
	QDateTimeEdit__MonthSection  QDateTimeEdit__Section = QDateTimeEdit__Section(0x0200)
	QDateTimeEdit__YearSection   QDateTimeEdit__Section = QDateTimeEdit__Section(0x0400)
)

func NewQDateTimeEdit(parent QWidget_ITF) *QDateTimeEdit {
	tmpValue := NewQDateTimeEditFromPointer(C.QDateTimeEdit_NewQDateTimeEdit(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQDateTimeEdit3(date core.QDate_ITF, parent QWidget_ITF) *QDateTimeEdit {
	tmpValue := NewQDateTimeEditFromPointer(C.QDateTimeEdit_NewQDateTimeEdit3(core.PointerFromQDate(date), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQDateTimeEdit2(datetime core.QDateTime_ITF, parent QWidget_ITF) *QDateTimeEdit {
	tmpValue := NewQDateTimeEditFromPointer(C.QDateTimeEdit_NewQDateTimeEdit2(core.PointerFromQDateTime(datetime), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQDateTimeEdit4(ti core.QTime_ITF, parent QWidget_ITF) *QDateTimeEdit {
	tmpValue := NewQDateTimeEditFromPointer(C.QDateTimeEdit_NewQDateTimeEdit4(core.PointerFromQTime(ti), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQDateTimeEdit_Clear
func callbackQDateTimeEdit_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDateTimeEditFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QDateTimeEdit) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) DisconnectClear() {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) Clear() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_Clear(ptr.Pointer())
	}
}

func (ptr *QDateTimeEdit) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_ClearDefault(ptr.Pointer())
	}
}

func (ptr *QDateTimeEdit) ClearMaximumDate() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_ClearMaximumDate(ptr.Pointer())
	}
}

func (ptr *QDateTimeEdit) ClearMaximumDateTime() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_ClearMaximumDateTime(ptr.Pointer())
	}
}

func (ptr *QDateTimeEdit) ClearMaximumTime() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_ClearMaximumTime(ptr.Pointer())
	}
}

func (ptr *QDateTimeEdit) ClearMinimumDate() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_ClearMinimumDate(ptr.Pointer())
	}
}

func (ptr *QDateTimeEdit) ClearMinimumDateTime() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_ClearMinimumDateTime(ptr.Pointer())
	}
}

func (ptr *QDateTimeEdit) ClearMinimumTime() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_ClearMinimumTime(ptr.Pointer())
	}
}

//export callbackQDateTimeEdit_DateChanged
func callbackQDateTimeEdit_DateChanged(ptr unsafe.Pointer, date unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dateChanged"); signal != nil {
		(*(*func(*core.QDate))(signal))(core.NewQDateFromPointer(date))
	}

}

func (ptr *QDateTimeEdit) ConnectDateChanged(f func(date *core.QDate)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "dateChanged") {
			C.QDateTimeEdit_ConnectDateChanged(ptr.Pointer())
		}

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

func (ptr *QDateTimeEdit) DisconnectDateChanged() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_DisconnectDateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "dateChanged")
	}
}

func (ptr *QDateTimeEdit) DateChanged(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_DateChanged(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

//export callbackQDateTimeEdit_DateTimeChanged
func callbackQDateTimeEdit_DateTimeChanged(ptr unsafe.Pointer, datetime unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dateTimeChanged"); signal != nil {
		(*(*func(*core.QDateTime))(signal))(core.NewQDateTimeFromPointer(datetime))
	}

}

func (ptr *QDateTimeEdit) ConnectDateTimeChanged(f func(datetime *core.QDateTime)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "dateTimeChanged") {
			C.QDateTimeEdit_ConnectDateTimeChanged(ptr.Pointer())
		}

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

func (ptr *QDateTimeEdit) DisconnectDateTimeChanged() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_DisconnectDateTimeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "dateTimeChanged")
	}
}

func (ptr *QDateTimeEdit) DateTimeChanged(datetime core.QDateTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_DateTimeChanged(ptr.Pointer(), core.PointerFromQDateTime(datetime))
	}
}

func (ptr *QDateTimeEdit) SetCalendarPopup(enable bool) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetCalendarPopup(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QDateTimeEdit) SetCalendarWidget(calendarWidget QCalendarWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetCalendarWidget(ptr.Pointer(), PointerFromQCalendarWidget(calendarWidget))
	}
}

func (ptr *QDateTimeEdit) SetCurrentSection(section QDateTimeEdit__Section) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetCurrentSection(ptr.Pointer(), C.longlong(section))
	}
}

func (ptr *QDateTimeEdit) SetCurrentSectionIndex(index int) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetCurrentSectionIndex(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQDateTimeEdit_SetDate
func callbackQDateTimeEdit_SetDate(ptr unsafe.Pointer, date unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setDate"); signal != nil {
		(*(*func(*core.QDate))(signal))(core.NewQDateFromPointer(date))
	} else {
		NewQDateTimeEditFromPointer(ptr).SetDateDefault(core.NewQDateFromPointer(date))
	}
}

func (ptr *QDateTimeEdit) ConnectSetDate(f func(date *core.QDate)) {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) DisconnectSetDate() {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) SetDate(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetDate(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

func (ptr *QDateTimeEdit) SetDateDefault(date core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetDateDefault(ptr.Pointer(), core.PointerFromQDate(date))
	}
}

func (ptr *QDateTimeEdit) SetDateRange(min core.QDate_ITF, max core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetDateRange(ptr.Pointer(), core.PointerFromQDate(min), core.PointerFromQDate(max))
	}
}

//export callbackQDateTimeEdit_SetDateTime
func callbackQDateTimeEdit_SetDateTime(ptr unsafe.Pointer, dateTime unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setDateTime"); signal != nil {
		(*(*func(*core.QDateTime))(signal))(core.NewQDateTimeFromPointer(dateTime))
	} else {
		NewQDateTimeEditFromPointer(ptr).SetDateTimeDefault(core.NewQDateTimeFromPointer(dateTime))
	}
}

func (ptr *QDateTimeEdit) ConnectSetDateTime(f func(dateTime *core.QDateTime)) {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) DisconnectSetDateTime() {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) SetDateTime(dateTime core.QDateTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetDateTime(ptr.Pointer(), core.PointerFromQDateTime(dateTime))
	}
}

func (ptr *QDateTimeEdit) SetDateTimeDefault(dateTime core.QDateTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetDateTimeDefault(ptr.Pointer(), core.PointerFromQDateTime(dateTime))
	}
}

func (ptr *QDateTimeEdit) SetDateTimeRange(min core.QDateTime_ITF, max core.QDateTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetDateTimeRange(ptr.Pointer(), core.PointerFromQDateTime(min), core.PointerFromQDateTime(max))
	}
}

func (ptr *QDateTimeEdit) SetDisplayFormat(format string) {
	if ptr.Pointer() != nil {
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		C.QDateTimeEdit_SetDisplayFormat(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: formatC, len: C.longlong(len(format))})
	}
}

func (ptr *QDateTimeEdit) SetMaximumDate(max core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetMaximumDate(ptr.Pointer(), core.PointerFromQDate(max))
	}
}

func (ptr *QDateTimeEdit) SetMaximumDateTime(dt core.QDateTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetMaximumDateTime(ptr.Pointer(), core.PointerFromQDateTime(dt))
	}
}

func (ptr *QDateTimeEdit) SetMaximumTime(max core.QTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetMaximumTime(ptr.Pointer(), core.PointerFromQTime(max))
	}
}

func (ptr *QDateTimeEdit) SetMinimumDate(min core.QDate_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetMinimumDate(ptr.Pointer(), core.PointerFromQDate(min))
	}
}

func (ptr *QDateTimeEdit) SetMinimumDateTime(dt core.QDateTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetMinimumDateTime(ptr.Pointer(), core.PointerFromQDateTime(dt))
	}
}

func (ptr *QDateTimeEdit) SetMinimumTime(min core.QTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetMinimumTime(ptr.Pointer(), core.PointerFromQTime(min))
	}
}

func (ptr *QDateTimeEdit) SetSelectedSection(section QDateTimeEdit__Section) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetSelectedSection(ptr.Pointer(), C.longlong(section))
	}
}

//export callbackQDateTimeEdit_SetTime
func callbackQDateTimeEdit_SetTime(ptr unsafe.Pointer, ti unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setTime"); signal != nil {
		(*(*func(*core.QTime))(signal))(core.NewQTimeFromPointer(ti))
	} else {
		NewQDateTimeEditFromPointer(ptr).SetTimeDefault(core.NewQTimeFromPointer(ti))
	}
}

func (ptr *QDateTimeEdit) ConnectSetTime(f func(ti *core.QTime)) {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) DisconnectSetTime() {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) SetTime(ti core.QTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetTime(ptr.Pointer(), core.PointerFromQTime(ti))
	}
}

func (ptr *QDateTimeEdit) SetTimeDefault(ti core.QTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetTimeDefault(ptr.Pointer(), core.PointerFromQTime(ti))
	}
}

func (ptr *QDateTimeEdit) SetTimeRange(min core.QTime_ITF, max core.QTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetTimeRange(ptr.Pointer(), core.PointerFromQTime(min), core.PointerFromQTime(max))
	}
}

func (ptr *QDateTimeEdit) SetTimeSpec(spec core.Qt__TimeSpec) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_SetTimeSpec(ptr.Pointer(), C.longlong(spec))
	}
}

//export callbackQDateTimeEdit_TimeChanged
func callbackQDateTimeEdit_TimeChanged(ptr unsafe.Pointer, ti unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timeChanged"); signal != nil {
		(*(*func(*core.QTime))(signal))(core.NewQTimeFromPointer(ti))
	}

}

func (ptr *QDateTimeEdit) ConnectTimeChanged(f func(ti *core.QTime)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "timeChanged") {
			C.QDateTimeEdit_ConnectTimeChanged(ptr.Pointer())
		}

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

func (ptr *QDateTimeEdit) DisconnectTimeChanged() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_DisconnectTimeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "timeChanged")
	}
}

func (ptr *QDateTimeEdit) TimeChanged(ti core.QTime_ITF) {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_TimeChanged(ptr.Pointer(), core.PointerFromQTime(ti))
	}
}

//export callbackQDateTimeEdit_DestroyQDateTimeEdit
func callbackQDateTimeEdit_DestroyQDateTimeEdit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QDateTimeEdit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDateTimeEditFromPointer(ptr).DestroyQDateTimeEditDefault()
	}
}

func (ptr *QDateTimeEdit) ConnectDestroyQDateTimeEdit(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) DisconnectDestroyQDateTimeEdit() {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) DestroyQDateTimeEdit() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_DestroyQDateTimeEdit(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDateTimeEdit) DestroyQDateTimeEditDefault() {
	if ptr.Pointer() != nil {
		C.QDateTimeEdit_DestroyQDateTimeEditDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDateTimeEdit) CalendarWidget() *QCalendarWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQCalendarWidgetFromPointer(C.QDateTimeEdit_CalendarWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) Date() *core.QDate {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateFromPointer(C.QDateTimeEdit_Date(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) MaximumDate() *core.QDate {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateFromPointer(C.QDateTimeEdit_MaximumDate(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) MinimumDate() *core.QDate {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateFromPointer(C.QDateTimeEdit_MinimumDate(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDate).DestroyQDate)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) DateTime() *core.QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateTimeFromPointer(C.QDateTimeEdit_DateTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

//export callbackQDateTimeEdit_DateTimeFromText
func callbackQDateTimeEdit_DateTimeFromText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "dateTimeFromText"); signal != nil {
		return core.PointerFromQDateTime((*(*func(string) *core.QDateTime)(signal))(cGoUnpackString(text)))
	}

	return core.PointerFromQDateTime(NewQDateTimeEditFromPointer(ptr).DateTimeFromTextDefault(cGoUnpackString(text)))
}

func (ptr *QDateTimeEdit) ConnectDateTimeFromText(f func(text string) *core.QDateTime) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dateTimeFromText"); signal != nil {
			f := func(text string) *core.QDateTime {
				(*(*func(string) *core.QDateTime)(signal))(text)
				return f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "dateTimeFromText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dateTimeFromText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDateTimeEdit) DisconnectDateTimeFromText() {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) DateTimeFromText(text string) *core.QDateTime {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := core.NewQDateTimeFromPointer(C.QDateTimeEdit_DateTimeFromText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		runtime.SetFinalizer(tmpValue, (*core.QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) DateTimeFromTextDefault(text string) *core.QDateTime {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := core.NewQDateTimeFromPointer(C.QDateTimeEdit_DateTimeFromTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		runtime.SetFinalizer(tmpValue, (*core.QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) MaximumDateTime() *core.QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateTimeFromPointer(C.QDateTimeEdit_MaximumDateTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) MinimumDateTime() *core.QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateTimeFromPointer(C.QDateTimeEdit_MinimumDateTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) CurrentSection() QDateTimeEdit__Section {
	if ptr.Pointer() != nil {
		return QDateTimeEdit__Section(C.QDateTimeEdit_CurrentSection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDateTimeEdit) SectionAt(index int) QDateTimeEdit__Section {
	if ptr.Pointer() != nil {
		return QDateTimeEdit__Section(C.QDateTimeEdit_SectionAt(ptr.Pointer(), C.int(int32(index))))
	}
	return 0
}

func (ptr *QDateTimeEdit) DisplayedSections() QDateTimeEdit__Section {
	if ptr.Pointer() != nil {
		return QDateTimeEdit__Section(C.QDateTimeEdit_DisplayedSections(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDateTimeEdit) DisplayFormat() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDateTimeEdit_DisplayFormat(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDateTimeEdit) SectionText(section QDateTimeEdit__Section) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDateTimeEdit_SectionText(ptr.Pointer(), C.longlong(section)))
	}
	return ""
}

//export callbackQDateTimeEdit_TextFromDateTime
func callbackQDateTimeEdit_TextFromDateTime(ptr unsafe.Pointer, dateTime unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "textFromDateTime"); signal != nil {
		tempVal := (*(*func(*core.QDateTime) string)(signal))(core.NewQDateTimeFromPointer(dateTime))
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQDateTimeEditFromPointer(ptr).TextFromDateTimeDefault(core.NewQDateTimeFromPointer(dateTime))
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QDateTimeEdit) ConnectTextFromDateTime(f func(dateTime *core.QDateTime) string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "textFromDateTime"); signal != nil {
			f := func(dateTime *core.QDateTime) string {
				(*(*func(*core.QDateTime) string)(signal))(dateTime)
				return f(dateTime)
			}
			qt.ConnectSignal(ptr.Pointer(), "textFromDateTime", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "textFromDateTime", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDateTimeEdit) DisconnectTextFromDateTime() {
	if ptr.Pointer() != nil {

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

func (ptr *QDateTimeEdit) TextFromDateTime(dateTime core.QDateTime_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDateTimeEdit_TextFromDateTime(ptr.Pointer(), core.PointerFromQDateTime(dateTime)))
	}
	return ""
}

func (ptr *QDateTimeEdit) TextFromDateTimeDefault(dateTime core.QDateTime_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDateTimeEdit_TextFromDateTimeDefault(ptr.Pointer(), core.PointerFromQDateTime(dateTime)))
	}
	return ""
}

func (ptr *QDateTimeEdit) MaximumTime() *core.QTime {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQTimeFromPointer(C.QDateTimeEdit_MaximumTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QTime).DestroyQTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) MinimumTime() *core.QTime {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQTimeFromPointer(C.QDateTimeEdit_MinimumTime(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QTime).DestroyQTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) Time() *core.QTime {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQTimeFromPointer(C.QDateTimeEdit_Time(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QTime).DestroyQTime)
		return tmpValue
	}
	return nil
}

func (ptr *QDateTimeEdit) TimeSpec() core.Qt__TimeSpec {
	if ptr.Pointer() != nil {
		return core.Qt__TimeSpec(C.QDateTimeEdit_TimeSpec(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDateTimeEdit) CalendarPopup() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDateTimeEdit_CalendarPopup(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDateTimeEdit) CurrentSectionIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDateTimeEdit_CurrentSectionIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDateTimeEdit) SectionCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDateTimeEdit_SectionCount(ptr.Pointer())))
	}
	return 0
}

type QDesktopWidget struct {
	QWidget
}

type QDesktopWidget_ITF interface {
	QWidget_ITF
	QDesktopWidget_PTR() *QDesktopWidget
}

func (ptr *QDesktopWidget) QDesktopWidget_PTR() *QDesktopWidget {
	return ptr
}

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

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

func PointerFromQDesktopWidget(ptr QDesktopWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDesktopWidget_PTR().Pointer()
	}
	return nil
}

func NewQDesktopWidgetFromPointer(ptr unsafe.Pointer) (n *QDesktopWidget) {
	n = new(QDesktopWidget)
	n.SetPointer(ptr)
	return
}
func (ptr *QDesktopWidget) Screen(screen int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QDesktopWidget_Screen(ptr.Pointer(), C.int(int32(screen))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

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

}

func (ptr *QDesktopWidget) ConnectPrimaryScreenChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "primaryScreenChanged") {
			C.QDesktopWidget_ConnectPrimaryScreenChanged(ptr.Pointer())
		}

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

func (ptr *QDesktopWidget) DisconnectPrimaryScreenChanged() {
	if ptr.Pointer() != nil {
		C.QDesktopWidget_DisconnectPrimaryScreenChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "primaryScreenChanged")
	}
}

func (ptr *QDesktopWidget) PrimaryScreenChanged() {
	if ptr.Pointer() != nil {
		C.QDesktopWidget_PrimaryScreenChanged(ptr.Pointer())
	}
}

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

}

func (ptr *QDesktopWidget) ConnectResized(f func(screen int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "resized") {
			C.QDesktopWidget_ConnectResized(ptr.Pointer())
		}

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

func (ptr *QDesktopWidget) DisconnectResized() {
	if ptr.Pointer() != nil {
		C.QDesktopWidget_DisconnectResized(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "resized")
	}
}

func (ptr *QDesktopWidget) Resized(screen int) {
	if ptr.Pointer() != nil {
		C.QDesktopWidget_Resized(ptr.Pointer(), C.int(int32(screen)))
	}
}

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

}

func (ptr *QDesktopWidget) ConnectScreenCountChanged(f func(newCount int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "screenCountChanged") {
			C.QDesktopWidget_ConnectScreenCountChanged(ptr.Pointer())
		}

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

func (ptr *QDesktopWidget) DisconnectScreenCountChanged() {
	if ptr.Pointer() != nil {
		C.QDesktopWidget_DisconnectScreenCountChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "screenCountChanged")
	}
}

func (ptr *QDesktopWidget) ScreenCountChanged(newCount int) {
	if ptr.Pointer() != nil {
		C.QDesktopWidget_ScreenCountChanged(ptr.Pointer(), C.int(int32(newCount)))
	}
}

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

}

func (ptr *QDesktopWidget) ConnectWorkAreaResized(f func(screen int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "workAreaResized") {
			C.QDesktopWidget_ConnectWorkAreaResized(ptr.Pointer())
		}

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

func (ptr *QDesktopWidget) DisconnectWorkAreaResized() {
	if ptr.Pointer() != nil {
		C.QDesktopWidget_DisconnectWorkAreaResized(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "workAreaResized")
	}
}

func (ptr *QDesktopWidget) WorkAreaResized(screen int) {
	if ptr.Pointer() != nil {
		C.QDesktopWidget_WorkAreaResized(ptr.Pointer(), C.int(int32(screen)))
	}
}

func (ptr *QDesktopWidget) IsVirtualDesktop() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDesktopWidget_IsVirtualDesktop(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDesktopWidget) AvailableGeometry2(p core.QPoint_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QDesktopWidget_AvailableGeometry2(ptr.Pointer(), core.PointerFromQPoint(p)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QDesktopWidget) AvailableGeometry(widget QWidget_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QDesktopWidget_AvailableGeometry(ptr.Pointer(), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QDesktopWidget) ScreenGeometry2(p core.QPoint_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QDesktopWidget_ScreenGeometry2(ptr.Pointer(), core.PointerFromQPoint(p)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QDesktopWidget) ScreenGeometry(widget QWidget_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QDesktopWidget_ScreenGeometry(ptr.Pointer(), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QDesktopWidget) NumScreens() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDesktopWidget_NumScreens(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDesktopWidget) PrimaryScreen() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDesktopWidget_PrimaryScreen(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDesktopWidget) ScreenCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDesktopWidget_ScreenCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDesktopWidget) ScreenNumber2(point core.QPoint_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDesktopWidget_ScreenNumber2(ptr.Pointer(), core.PointerFromQPoint(point))))
	}
	return 0
}

func (ptr *QDesktopWidget) ScreenNumber(widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDesktopWidget_ScreenNumber(ptr.Pointer(), PointerFromQWidget(widget))))
	}
	return 0
}

type QDial struct {
	QAbstractSlider
}

type QDial_ITF interface {
	QAbstractSlider_ITF
	QDial_PTR() *QDial
}

func (ptr *QDial) QDial_PTR() *QDial {
	return ptr
}

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

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

func PointerFromQDial(ptr QDial_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDial_PTR().Pointer()
	}
	return nil
}

func NewQDialFromPointer(ptr unsafe.Pointer) (n *QDial) {
	n = new(QDial)
	n.SetPointer(ptr)
	return
}
func NewQDial(parent QWidget_ITF) *QDial {
	tmpValue := NewQDialFromPointer(C.QDial_NewQDial(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QDial) SetNotchTarget(target float64) {
	if ptr.Pointer() != nil {
		C.QDial_SetNotchTarget(ptr.Pointer(), C.double(target))
	}
}

//export callbackQDial_SetNotchesVisible
func callbackQDial_SetNotchesVisible(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(ptr, "setNotchesVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(visible) != 0)
	} else {
		NewQDialFromPointer(ptr).SetNotchesVisibleDefault(int8(visible) != 0)
	}
}

func (ptr *QDial) ConnectSetNotchesVisible(f func(visible bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QDial) DisconnectSetNotchesVisible() {
	if ptr.Pointer() != nil {

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

func (ptr *QDial) SetNotchesVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QDial_SetNotchesVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QDial) SetNotchesVisibleDefault(visible bool) {
	if ptr.Pointer() != nil {
		C.QDial_SetNotchesVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQDial_SetWrapping
func callbackQDial_SetWrapping(ptr unsafe.Pointer, on C.char) {
	if signal := qt.GetSignal(ptr, "setWrapping"); signal != nil {
		(*(*func(bool))(signal))(int8(on) != 0)
	} else {
		NewQDialFromPointer(ptr).SetWrappingDefault(int8(on) != 0)
	}
}

func (ptr *QDial) ConnectSetWrapping(f func(on bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QDial) DisconnectSetWrapping() {
	if ptr.Pointer() != nil {

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

func (ptr *QDial) SetWrapping(on bool) {
	if ptr.Pointer() != nil {
		C.QDial_SetWrapping(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QDial) SetWrappingDefault(on bool) {
	if ptr.Pointer() != nil {
		C.QDial_SetWrappingDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

//export callbackQDial_DestroyQDial
func callbackQDial_DestroyQDial(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QDial"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDialFromPointer(ptr).DestroyQDialDefault()
	}
}

func (ptr *QDial) ConnectDestroyQDial(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDial) DisconnectDestroyQDial() {
	if ptr.Pointer() != nil {

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

func (ptr *QDial) DestroyQDial() {
	if ptr.Pointer() != nil {
		C.QDial_DestroyQDial(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDial) DestroyQDialDefault() {
	if ptr.Pointer() != nil {
		C.QDial_DestroyQDialDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDial) NotchesVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDial_NotchesVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDial) Wrapping() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDial_Wrapping(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDial) NotchSize() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDial_NotchSize(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDial) NotchTarget() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QDial_NotchTarget(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDial) InitStyleOption(option QStyleOptionSlider_ITF) {
	if ptr.Pointer() != nil {
		C.QDial_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionSlider(option))
	}
}

type QDialog struct {
	QWidget
}

type QDialog_ITF interface {
	QWidget_ITF
	QDialog_PTR() *QDialog
}

func (ptr *QDialog) QDialog_PTR() *QDialog {
	return ptr
}

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

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

func PointerFromQDialog(ptr QDialog_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDialog_PTR().Pointer()
	}
	return nil
}

func NewQDialogFromPointer(ptr unsafe.Pointer) (n *QDialog) {
	n = new(QDialog)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDialog__DialogCode
//QDialog::DialogCode
type QDialog__DialogCode int64

const (
	QDialog__Rejected QDialog__DialogCode = QDialog__DialogCode(0)
	QDialog__Accepted QDialog__DialogCode = QDialog__DialogCode(1)
)

func NewQDialog(parent QWidget_ITF, ff core.Qt__WindowType) *QDialog {
	tmpValue := NewQDialogFromPointer(C.QDialog_NewQDialog(PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

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

	return C.int(int32(NewQDialogFromPointer(ptr).ExecDefault()))
}

func (ptr *QDialog) ConnectExec(f func() int) {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) DisconnectExec() {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) Exec() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDialog_Exec(ptr.Pointer())))
	}
	return 0
}

func (ptr *QDialog) ExecDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDialog_ExecDefault(ptr.Pointer())))
	}
	return 0
}

//export callbackQDialog_Accept
func callbackQDialog_Accept(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "accept"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDialogFromPointer(ptr).AcceptDefault()
	}
}

func (ptr *QDialog) ConnectAccept(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) DisconnectAccept() {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) Accept() {
	if ptr.Pointer() != nil {
		C.QDialog_Accept(ptr.Pointer())
	}
}

func (ptr *QDialog) AcceptDefault() {
	if ptr.Pointer() != nil {
		C.QDialog_AcceptDefault(ptr.Pointer())
	}
}

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

}

func (ptr *QDialog) ConnectAccepted(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "accepted") {
			C.QDialog_ConnectAccepted(ptr.Pointer())
		}

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

func (ptr *QDialog) DisconnectAccepted() {
	if ptr.Pointer() != nil {
		C.QDialog_DisconnectAccepted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "accepted")
	}
}

func (ptr *QDialog) Accepted() {
	if ptr.Pointer() != nil {
		C.QDialog_Accepted(ptr.Pointer())
	}
}

//export callbackQDialog_Done
func callbackQDialog_Done(ptr unsafe.Pointer, r C.int) {
	if signal := qt.GetSignal(ptr, "done"); signal != nil {
		(*(*func(int))(signal))(int(int32(r)))
	} else {
		NewQDialogFromPointer(ptr).DoneDefault(int(int32(r)))
	}
}

func (ptr *QDialog) ConnectDone(f func(r int)) {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) DisconnectDone() {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) Done(r int) {
	if ptr.Pointer() != nil {
		C.QDialog_Done(ptr.Pointer(), C.int(int32(r)))
	}
}

func (ptr *QDialog) DoneDefault(r int) {
	if ptr.Pointer() != nil {
		C.QDialog_DoneDefault(ptr.Pointer(), C.int(int32(r)))
	}
}

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

}

func (ptr *QDialog) ConnectFinished(f func(result int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "finished") {
			C.QDialog_ConnectFinished(ptr.Pointer())
		}

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

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

func (ptr *QDialog) Finished(result int) {
	if ptr.Pointer() != nil {
		C.QDialog_Finished(ptr.Pointer(), C.int(int32(result)))
	}
}

//export callbackQDialog_Open
func callbackQDialog_Open(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "open"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDialogFromPointer(ptr).OpenDefault()
	}
}

func (ptr *QDialog) ConnectOpen(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) DisconnectOpen() {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) Open() {
	if ptr.Pointer() != nil {
		C.QDialog_Open(ptr.Pointer())
	}
}

func (ptr *QDialog) OpenDefault() {
	if ptr.Pointer() != nil {
		C.QDialog_OpenDefault(ptr.Pointer())
	}
}

//export callbackQDialog_Reject
func callbackQDialog_Reject(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "reject"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDialogFromPointer(ptr).RejectDefault()
	}
}

func (ptr *QDialog) ConnectReject(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) DisconnectReject() {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) Reject() {
	if ptr.Pointer() != nil {
		C.QDialog_Reject(ptr.Pointer())
	}
}

func (ptr *QDialog) RejectDefault() {
	if ptr.Pointer() != nil {
		C.QDialog_RejectDefault(ptr.Pointer())
	}
}

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

}

func (ptr *QDialog) ConnectRejected(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rejected") {
			C.QDialog_ConnectRejected(ptr.Pointer())
		}

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

func (ptr *QDialog) DisconnectRejected() {
	if ptr.Pointer() != nil {
		C.QDialog_DisconnectRejected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rejected")
	}
}

func (ptr *QDialog) Rejected() {
	if ptr.Pointer() != nil {
		C.QDialog_Rejected(ptr.Pointer())
	}
}

func (ptr *QDialog) SetModal(modal bool) {
	if ptr.Pointer() != nil {
		C.QDialog_SetModal(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(modal))))
	}
}

func (ptr *QDialog) SetResult(i int) {
	if ptr.Pointer() != nil {
		C.QDialog_SetResult(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QDialog) SetSizeGripEnabled(vbo bool) {
	if ptr.Pointer() != nil {
		C.QDialog_SetSizeGripEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQDialog_SetVisible
func callbackQDialog_SetVisible(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(ptr, "setVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(visible) != 0)
	} else {
		NewQDialogFromPointer(ptr).SetVisibleDefault(int8(visible) != 0)
	}
}

func (ptr *QDialog) ConnectSetVisible(f func(visible bool)) {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) DisconnectSetVisible() {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) SetVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QDialog_SetVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QDialog) SetVisibleDefault(visible bool) {
	if ptr.Pointer() != nil {
		C.QDialog_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQDialog_DestroyQDialog
func callbackQDialog_DestroyQDialog(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QDialog"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDialogFromPointer(ptr).DestroyQDialogDefault()
	}
}

func (ptr *QDialog) ConnectDestroyQDialog(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) DisconnectDestroyQDialog() {
	if ptr.Pointer() != nil {

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

func (ptr *QDialog) DestroyQDialog() {
	if ptr.Pointer() != nil {
		C.QDialog_DestroyQDialog(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDialog) DestroyQDialogDefault() {
	if ptr.Pointer() != nil {
		C.QDialog_DestroyQDialogDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDialog) IsSizeGripEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDialog_IsSizeGripEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDialog) Result() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDialog_Result(ptr.Pointer())))
	}
	return 0
}

type QDialogButtonBox struct {
	QWidget
}

type QDialogButtonBox_ITF interface {
	QWidget_ITF
	QDialogButtonBox_PTR() *QDialogButtonBox
}

func (ptr *QDialogButtonBox) QDialogButtonBox_PTR() *QDialogButtonBox {
	return ptr
}

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

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

func PointerFromQDialogButtonBox(ptr QDialogButtonBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDialogButtonBox_PTR().Pointer()
	}
	return nil
}

func NewQDialogButtonBoxFromPointer(ptr unsafe.Pointer) (n *QDialogButtonBox) {
	n = new(QDialogButtonBox)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDialogButtonBox__ButtonLayout
//QDialogButtonBox::ButtonLayout
type QDialogButtonBox__ButtonLayout int64

var (
	QDialogButtonBox__WinLayout     QDialogButtonBox__ButtonLayout = QDialogButtonBox__ButtonLayout(0)
	QDialogButtonBox__MacLayout     QDialogButtonBox__ButtonLayout = QDialogButtonBox__ButtonLayout(1)
	QDialogButtonBox__KdeLayout     QDialogButtonBox__ButtonLayout = QDialogButtonBox__ButtonLayout(2)
	QDialogButtonBox__GnomeLayout   QDialogButtonBox__ButtonLayout = QDialogButtonBox__ButtonLayout(3)
	QDialogButtonBox__AndroidLayout QDialogButtonBox__ButtonLayout = QDialogButtonBox__ButtonLayout(C.QDialogButtonBox_AndroidLayout_Type())
)

//go:generate stringer -type=QDialogButtonBox__ButtonRole
//QDialogButtonBox::ButtonRole
type QDialogButtonBox__ButtonRole int64

const (
	QDialogButtonBox__InvalidRole     QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(-1)
	QDialogButtonBox__AcceptRole      QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(0)
	QDialogButtonBox__RejectRole      QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(1)
	QDialogButtonBox__DestructiveRole QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(2)
	QDialogButtonBox__ActionRole      QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(3)
	QDialogButtonBox__HelpRole        QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(4)
	QDialogButtonBox__YesRole         QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(5)
	QDialogButtonBox__NoRole          QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(6)
	QDialogButtonBox__ResetRole       QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(7)
	QDialogButtonBox__ApplyRole       QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(8)
	QDialogButtonBox__NRoles          QDialogButtonBox__ButtonRole = QDialogButtonBox__ButtonRole(9)
)

//go:generate stringer -type=QDialogButtonBox__StandardButton
//QDialogButtonBox::StandardButton
type QDialogButtonBox__StandardButton int64

const (
	QDialogButtonBox__NoButton        QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00000000)
	QDialogButtonBox__Ok              QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00000400)
	QDialogButtonBox__Save            QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00000800)
	QDialogButtonBox__SaveAll         QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00001000)
	QDialogButtonBox__Open            QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00002000)
	QDialogButtonBox__Yes             QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00004000)
	QDialogButtonBox__YesToAll        QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00008000)
	QDialogButtonBox__No              QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00010000)
	QDialogButtonBox__NoToAll         QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00020000)
	QDialogButtonBox__Abort           QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00040000)
	QDialogButtonBox__Retry           QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00080000)
	QDialogButtonBox__Ignore          QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00100000)
	QDialogButtonBox__Close           QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00200000)
	QDialogButtonBox__Cancel          QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00400000)
	QDialogButtonBox__Discard         QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x00800000)
	QDialogButtonBox__Help            QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x01000000)
	QDialogButtonBox__Apply           QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x02000000)
	QDialogButtonBox__Reset           QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x04000000)
	QDialogButtonBox__RestoreDefaults QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(0x08000000)
	QDialogButtonBox__FirstButton     QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(QDialogButtonBox__Ok)
	QDialogButtonBox__LastButton      QDialogButtonBox__StandardButton = QDialogButtonBox__StandardButton(QDialogButtonBox__RestoreDefaults)
)

func NewQDialogButtonBox3(buttons QDialogButtonBox__StandardButton, parent QWidget_ITF) *QDialogButtonBox {
	tmpValue := NewQDialogButtonBoxFromPointer(C.QDialogButtonBox_NewQDialogButtonBox3(C.longlong(buttons), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQDialogButtonBox4(buttons QDialogButtonBox__StandardButton, orientation core.Qt__Orientation, parent QWidget_ITF) *QDialogButtonBox {
	tmpValue := NewQDialogButtonBoxFromPointer(C.QDialogButtonBox_NewQDialogButtonBox4(C.longlong(buttons), C.longlong(orientation), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQDialogButtonBox(parent QWidget_ITF) *QDialogButtonBox {
	tmpValue := NewQDialogButtonBoxFromPointer(C.QDialogButtonBox_NewQDialogButtonBox(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQDialogButtonBox2(orientation core.Qt__Orientation, parent QWidget_ITF) *QDialogButtonBox {
	tmpValue := NewQDialogButtonBoxFromPointer(C.QDialogButtonBox_NewQDialogButtonBox2(C.longlong(orientation), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QDialogButtonBox) AddButton3(button QDialogButtonBox__StandardButton) *QPushButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQPushButtonFromPointer(C.QDialogButtonBox_AddButton3(ptr.Pointer(), C.longlong(button)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDialogButtonBox) AddButton2(text string, role QDialogButtonBox__ButtonRole) *QPushButton {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQPushButtonFromPointer(C.QDialogButtonBox_AddButton2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(role)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

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

}

func (ptr *QDialogButtonBox) ConnectAccepted(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "accepted") {
			C.QDialogButtonBox_ConnectAccepted(ptr.Pointer())
		}

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

func (ptr *QDialogButtonBox) DisconnectAccepted() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_DisconnectAccepted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "accepted")
	}
}

func (ptr *QDialogButtonBox) Accepted() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_Accepted(ptr.Pointer())
	}
}

func (ptr *QDialogButtonBox) AddButton(button QAbstractButton_ITF, role QDialogButtonBox__ButtonRole) {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_AddButton(ptr.Pointer(), PointerFromQAbstractButton(button), C.longlong(role))
	}
}

func (ptr *QDialogButtonBox) Clear() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_Clear(ptr.Pointer())
	}
}

//export callbackQDialogButtonBox_Clicked
func callbackQDialogButtonBox_Clicked(ptr unsafe.Pointer, button unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clicked"); signal != nil {
		(*(*func(*QAbstractButton))(signal))(NewQAbstractButtonFromPointer(button))
	}

}

func (ptr *QDialogButtonBox) ConnectClicked(f func(button *QAbstractButton)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "clicked") {
			C.QDialogButtonBox_ConnectClicked(ptr.Pointer())
		}

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

func (ptr *QDialogButtonBox) DisconnectClicked() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_DisconnectClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "clicked")
	}
}

func (ptr *QDialogButtonBox) Clicked(button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_Clicked(ptr.Pointer(), PointerFromQAbstractButton(button))
	}
}

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

}

func (ptr *QDialogButtonBox) ConnectHelpRequested(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "helpRequested") {
			C.QDialogButtonBox_ConnectHelpRequested(ptr.Pointer())
		}

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

func (ptr *QDialogButtonBox) DisconnectHelpRequested() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_DisconnectHelpRequested(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "helpRequested")
	}
}

func (ptr *QDialogButtonBox) HelpRequested() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_HelpRequested(ptr.Pointer())
	}
}

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

}

func (ptr *QDialogButtonBox) ConnectRejected(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rejected") {
			C.QDialogButtonBox_ConnectRejected(ptr.Pointer())
		}

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

func (ptr *QDialogButtonBox) DisconnectRejected() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_DisconnectRejected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rejected")
	}
}

func (ptr *QDialogButtonBox) Rejected() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_Rejected(ptr.Pointer())
	}
}

func (ptr *QDialogButtonBox) RemoveButton(button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_RemoveButton(ptr.Pointer(), PointerFromQAbstractButton(button))
	}
}

func (ptr *QDialogButtonBox) SetCenterButtons(center bool) {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_SetCenterButtons(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(center))))
	}
}

func (ptr *QDialogButtonBox) SetOrientation(orientation core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_SetOrientation(ptr.Pointer(), C.longlong(orientation))
	}
}

func (ptr *QDialogButtonBox) SetStandardButtons(buttons QDialogButtonBox__StandardButton) {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_SetStandardButtons(ptr.Pointer(), C.longlong(buttons))
	}
}

//export callbackQDialogButtonBox_DestroyQDialogButtonBox
func callbackQDialogButtonBox_DestroyQDialogButtonBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QDialogButtonBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDialogButtonBoxFromPointer(ptr).DestroyQDialogButtonBoxDefault()
	}
}

func (ptr *QDialogButtonBox) ConnectDestroyQDialogButtonBox(f func()) {
	if ptr.Pointer() != nil {

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

func (ptr *QDialogButtonBox) DisconnectDestroyQDialogButtonBox() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QDialogButtonBox")
	}
}

func (ptr *QDialogButtonBox) DestroyQDialogButtonBox() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_DestroyQDialogButtonBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDialogButtonBox) DestroyQDialogButtonBoxDefault() {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox_DestroyQDialogButtonBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDialogButtonBox) ButtonRole(button QAbstractButton_ITF) QDialogButtonBox__ButtonRole {
	if ptr.Pointer() != nil {
		return QDialogButtonBox__ButtonRole(C.QDialogButtonBox_ButtonRole(ptr.Pointer(), PointerFromQAbstractButton(button)))
	}
	return 0
}

func (ptr *QDialogButtonBox) StandardButton(button QAbstractButton_ITF) QDialogButtonBox__StandardButton {
	if ptr.Pointer() != nil {
		return QDialogButtonBox__StandardButton(C.QDialogButtonBox_StandardButton(ptr.Pointer(), PointerFromQAbstractButton(button)))
	}
	return 0
}

func (ptr *QDialogButtonBox) StandardButtons() QDialogButtonBox__StandardButton {
	if ptr.Pointer() != nil {
		return QDialogButtonBox__StandardButton(C.QDialogButtonBox_StandardButtons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDialogButtonBox) Buttons() []*QAbstractButton {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QAbstractButton {
			out := make([]*QAbstractButton, int(l.len))
			tmpList := NewQDialogButtonBoxFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__buttons_atList(i)
			}
			return out
		}(C.QDialogButtonBox_Buttons(ptr.Pointer()))
	}
	return make([]*QAbstractButton, 0)
}

func (ptr *QDialogButtonBox) Button(which QDialogButtonBox__StandardButton) *QPushButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQPushButtonFromPointer(C.QDialogButtonBox_Button(ptr.Pointer(), C.longlong(which)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDialogButtonBox) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QDialogButtonBox_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDialogButtonBox) CenterButtons() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDialogButtonBox_CenterButtons(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDialogButtonBox) __buttons_atList(i int) *QAbstractButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractButtonFromPointer(C.QDialogButtonBox___buttons_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDialogButtonBox) __buttons_setList(i QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QDialogButtonBox___buttons_setList(ptr.Pointer(), PointerFromQAbstractButton(i))
	}
}

func (ptr *QDialogButtonBox) __buttons_newList() unsafe.Pointer {
	return C.QDialogButtonBox___buttons_newList(ptr.Pointer())
}

type QDirModel struct {
	core.QAbstractItemModel
}

type QDirModel_ITF interface {
	core.QAbstractItemModel_ITF
	QDirModel_PTR() *QDirModel
}

func (ptr *QDirModel) QDirModel_PTR() *QDirModel {
	return ptr
}

func (ptr *QDirModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemModel_PTR().Pointer()
	}
	return nil
}

func (ptr *QDirModel) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractItemModel_PTR().SetPointer(p)
	}
}

func PointerFromQDirModel(ptr QDirModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDirModel_PTR().Pointer()
	}
	return nil
}

func NewQDirModelFromPointer(ptr unsafe.Pointer) (n *QDirModel) {
	n = new(QDirModel)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDirModel__Roles
//QDirModel::Roles
type QDirModel__Roles int64

var (
	QDirModel__FileIconRole QDirModel__Roles = QDirModel__Roles(core.Qt__DecorationRole)
	QDirModel__FilePathRole QDirModel__Roles = QDirModel__Roles(C.QDirModel_FilePathRole_Type())
	QDirModel__FileNameRole QDirModel__Roles = QDirModel__Roles(258)
)

func NewQDirModel2(parent core.QObject_ITF) *QDirModel {
	tmpValue := NewQDirModelFromPointer(C.QDirModel_NewQDirModel2(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQDirModel(nameFilters []string, filters core.QDir__Filter, sort core.QDir__SortFlag, parent core.QObject_ITF) *QDirModel {
	nameFiltersC := C.CString(strings.Join(nameFilters, "|"))
	defer C.free(unsafe.Pointer(nameFiltersC))
	tmpValue := NewQDirModelFromPointer(C.QDirModel_NewQDirModel(C.struct_QtWidgets_PackedString{data: nameFiltersC, len: C.longlong(len(strings.Join(nameFilters, "|")))}, C.longlong(filters), C.longlong(sort), core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QDirModel) Mkdir(parent core.QModelIndex_ITF, name string) *core.QModelIndex {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel_Mkdir(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))}))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func QDirModel_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QDirModel_QDirModel_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QDirModel) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QDirModel_QDirModel_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQDirModel_DropMimeData
func callbackQDirModel_DropMimeData(ptr unsafe.Pointer, data unsafe.Pointer, action C.longlong, row C.int, column C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "dropMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QMimeData, core.Qt__DropAction, int, int, *core.QModelIndex) bool)(signal))(core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action), int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).DropMimeDataDefault(core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action), int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QDirModel) DropMimeDataDefault(data core.QMimeData_ITF, action core.Qt__DropAction, row int, column int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_DropMimeDataDefault(ptr.Pointer(), core.PointerFromQMimeData(data), C.longlong(action), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QDirModel) Remove(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_Remove(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QDirModel) Rmdir(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_Rmdir(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

//export callbackQDirModel_SetData
func callbackQDirModel_SetData(ptr unsafe.Pointer, index unsafe.Pointer, value unsafe.Pointer, role C.int) C.char {
	if signal := qt.GetSignal(ptr, "setData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex, *core.QVariant, int) bool)(signal))(core.NewQModelIndexFromPointer(index), core.NewQVariantFromPointer(value), int(int32(role))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).SetDataDefault(core.NewQModelIndexFromPointer(index), core.NewQVariantFromPointer(value), int(int32(role))))))
}

func (ptr *QDirModel) SetDataDefault(index core.QModelIndex_ITF, value core.QVariant_ITF, role int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_SetDataDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), core.PointerFromQVariant(value), C.int(int32(role)))) != 0
	}
	return false
}

//export callbackQDirModel_Refresh
func callbackQDirModel_Refresh(ptr unsafe.Pointer, parent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "refresh"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(parent))
	} else {
		NewQDirModelFromPointer(ptr).RefreshDefault(core.NewQModelIndexFromPointer(parent))
	}
}

func (ptr *QDirModel) ConnectRefresh(f func(parent *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "refresh"); signal != nil {
			f := func(parent *core.QModelIndex) {
				(*(*func(*core.QModelIndex))(signal))(parent)
				f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "refresh", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "refresh", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDirModel) DisconnectRefresh() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "refresh")
	}
}

func (ptr *QDirModel) Refresh(parent core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel_Refresh(ptr.Pointer(), core.PointerFromQModelIndex(parent))
	}
}

func (ptr *QDirModel) RefreshDefault(parent core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel_RefreshDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
	}
}

func (ptr *QDirModel) SetFilter(filters core.QDir__Filter) {
	if ptr.Pointer() != nil {
		C.QDirModel_SetFilter(ptr.Pointer(), C.longlong(filters))
	}
}

func (ptr *QDirModel) SetIconProvider(provider QFileIconProvider_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel_SetIconProvider(ptr.Pointer(), PointerFromQFileIconProvider(provider))
	}
}

func (ptr *QDirModel) SetLazyChildCount(enable bool) {
	if ptr.Pointer() != nil {
		C.QDirModel_SetLazyChildCount(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QDirModel) SetNameFilters(filters []string) {
	if ptr.Pointer() != nil {
		filtersC := C.CString(strings.Join(filters, "|"))
		defer C.free(unsafe.Pointer(filtersC))
		C.QDirModel_SetNameFilters(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filtersC, len: C.longlong(len(strings.Join(filters, "|")))})
	}
}

func (ptr *QDirModel) SetReadOnly(enable bool) {
	if ptr.Pointer() != nil {
		C.QDirModel_SetReadOnly(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QDirModel) SetResolveSymlinks(enable bool) {
	if ptr.Pointer() != nil {
		C.QDirModel_SetResolveSymlinks(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QDirModel) SetSorting(sort core.QDir__SortFlag) {
	if ptr.Pointer() != nil {
		C.QDirModel_SetSorting(ptr.Pointer(), C.longlong(sort))
	}
}

//export callbackQDirModel_Sort
func callbackQDirModel_Sort(ptr unsafe.Pointer, column C.int, order C.longlong) {
	if signal := qt.GetSignal(ptr, "sort"); signal != nil {
		(*(*func(int, core.Qt__SortOrder))(signal))(int(int32(column)), core.Qt__SortOrder(order))
	} else {
		NewQDirModelFromPointer(ptr).SortDefault(int(int32(column)), core.Qt__SortOrder(order))
	}
}

func (ptr *QDirModel) SortDefault(column int, order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QDirModel_SortDefault(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
	}
}

//export callbackQDirModel_DestroyQDirModel
func callbackQDirModel_DestroyQDirModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QDirModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDirModelFromPointer(ptr).DestroyQDirModelDefault()
	}
}

func (ptr *QDirModel) ConnectDestroyQDirModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QDirModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QDirModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QDirModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDirModel) DisconnectDestroyQDirModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QDirModel")
	}
}

func (ptr *QDirModel) DestroyQDirModel() {
	if ptr.Pointer() != nil {
		C.QDirModel_DestroyQDirModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDirModel) DestroyQDirModelDefault() {
	if ptr.Pointer() != nil {
		C.QDirModel_DestroyQDirModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDirModel) Filter() core.QDir__Filter {
	if ptr.Pointer() != nil {
		return core.QDir__Filter(C.QDirModel_Filter(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDirModel) Sorting() core.QDir__SortFlag {
	if ptr.Pointer() != nil {
		return core.QDir__SortFlag(C.QDirModel_Sorting(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDirModel) IconProvider() *QFileIconProvider {
	if ptr.Pointer() != nil {
		return NewQFileIconProviderFromPointer(C.QDirModel_IconProvider(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDirModel) FileInfo(index core.QModelIndex_ITF) *core.QFileInfo {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQFileInfoFromPointer(C.QDirModel_FileInfo(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QFileInfo).DestroyQFileInfo)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) FileIcon(index core.QModelIndex_ITF) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QDirModel_FileIcon(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

//export callbackQDirModel_MimeData
func callbackQDirModel_MimeData(ptr unsafe.Pointer, indexes C.struct_QtWidgets_PackedList) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mimeData"); signal != nil {
		return core.PointerFromQMimeData((*(*func([]*core.QModelIndex) *core.QMimeData)(signal))(func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
			out := make([]*core.QModelIndex, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__mimeData_indexes_atList(i)
			}
			return out
		}(indexes)))
	}

	return core.PointerFromQMimeData(NewQDirModelFromPointer(ptr).MimeDataDefault(func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
		out := make([]*core.QModelIndex, int(l.len))
		tmpList := NewQDirModelFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__mimeData_indexes_atList(i)
		}
		return out
	}(indexes)))
}

func (ptr *QDirModel) MimeDataDefault(indexes []*core.QModelIndex) *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QDirModel_MimeDataDefault(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQDirModelFromPointer(NewQDirModelFromPointer(nil).__mimeData_indexes_newList())
			for _, v := range indexes {
				tmpList.__mimeData_indexes_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) Index2(path string, column int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel_Index2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: pathC, len: C.longlong(len(path))}, C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQDirModel_Index
func callbackQDirModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(int, int, *core.QModelIndex) *core.QModelIndex)(signal))(int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))
	}

	return core.PointerFromQModelIndex(NewQDirModelFromPointer(ptr).IndexDefault(int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))
}

func (ptr *QDirModel) ConnectIndex(f func(row int, column int, parent *core.QModelIndex) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "index"); signal != nil {
			f := func(row int, column int, parent *core.QModelIndex) *core.QModelIndex {
				(*(*func(int, int, *core.QModelIndex) *core.QModelIndex)(signal))(row, column, parent)
				return f(row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDirModel) DisconnectIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "index")
	}
}

func (ptr *QDirModel) Index(row int, column int, parent core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) IndexDefault(row int, column int, parent core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel_IndexDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQDirModel_Parent
func callbackQDirModel_Parent(ptr unsafe.Pointer, child unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QModelIndex) *core.QModelIndex)(signal))(core.NewQModelIndexFromPointer(child)))
	}

	return core.PointerFromQModelIndex(NewQDirModelFromPointer(ptr).ParentDefault(core.NewQModelIndexFromPointer(child)))
}

func (ptr *QDirModel) ConnectParent(f func(child *core.QModelIndex) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "parent"); signal != nil {
			f := func(child *core.QModelIndex) *core.QModelIndex {
				(*(*func(*core.QModelIndex) *core.QModelIndex)(signal))(child)
				return f(child)
			}
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDirModel) DisconnectParent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "parent")
	}
}

func (ptr *QDirModel) Parent(child core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel_Parent(ptr.Pointer(), core.PointerFromQModelIndex(child)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) ParentDefault(child core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel_ParentDefault(ptr.Pointer(), core.PointerFromQModelIndex(child)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) FileName(index core.QModelIndex_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDirModel_FileName(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return ""
}

func (ptr *QDirModel) FilePath(index core.QModelIndex_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDirModel_FilePath(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return ""
}

//export callbackQDirModel_MimeTypes
func callbackQDirModel_MimeTypes(ptr unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "mimeTypes"); signal != nil {
		tempVal := (*(*func() []string)(signal))()
		return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
	}
	tempVal := NewQDirModelFromPointer(ptr).MimeTypesDefault()
	return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
}

func (ptr *QDirModel) MimeTypesDefault() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QDirModel_MimeTypesDefault(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QDirModel) NameFilters() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QDirModel_NameFilters(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

//export callbackQDirModel_Data
func callbackQDirModel_Data(ptr unsafe.Pointer, index unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return core.PointerFromQVariant((*(*func(*core.QModelIndex, int) *core.QVariant)(signal))(core.NewQModelIndexFromPointer(index), int(int32(role))))
	}

	return core.PointerFromQVariant(NewQDirModelFromPointer(ptr).DataDefault(core.NewQModelIndexFromPointer(index), int(int32(role))))
}

func (ptr *QDirModel) ConnectData(f func(index *core.QModelIndex, role int) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "data"); signal != nil {
			f := func(index *core.QModelIndex, role int) *core.QVariant {
				(*(*func(*core.QModelIndex, int) *core.QVariant)(signal))(index, role)
				return f(index, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDirModel) DisconnectData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "data")
	}
}

func (ptr *QDirModel) Data(index core.QModelIndex_ITF, role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QDirModel_Data(ptr.Pointer(), core.PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) DataDefault(index core.QModelIndex_ITF, role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QDirModel_DataDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQDirModel_HeaderData
func callbackQDirModel_HeaderData(ptr unsafe.Pointer, section C.int, orientation C.longlong, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "headerData"); signal != nil {
		return core.PointerFromQVariant((*(*func(int, core.Qt__Orientation, int) *core.QVariant)(signal))(int(int32(section)), core.Qt__Orientation(orientation), int(int32(role))))
	}

	return core.PointerFromQVariant(NewQDirModelFromPointer(ptr).HeaderDataDefault(int(int32(section)), core.Qt__Orientation(orientation), int(int32(role))))
}

func (ptr *QDirModel) HeaderDataDefault(section int, orientation core.Qt__Orientation, role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QDirModel_HeaderDataDefault(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQDirModel_SupportedDropActions
func callbackQDirModel_SupportedDropActions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "supportedDropActions"); signal != nil {
		return C.longlong((*(*func() core.Qt__DropAction)(signal))())
	}

	return C.longlong(NewQDirModelFromPointer(ptr).SupportedDropActionsDefault())
}

func (ptr *QDirModel) SupportedDropActionsDefault() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QDirModel_SupportedDropActionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQDirModel_Flags
func callbackQDirModel_Flags(ptr unsafe.Pointer, index unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "flags"); signal != nil {
		return C.longlong((*(*func(*core.QModelIndex) core.Qt__ItemFlag)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return C.longlong(NewQDirModelFromPointer(ptr).FlagsDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QDirModel) FlagsDefault(index core.QModelIndex_ITF) core.Qt__ItemFlag {
	if ptr.Pointer() != nil {
		return core.Qt__ItemFlag(C.QDirModel_FlagsDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return 0
}

//export callbackQDirModel_HasChildren
func callbackQDirModel_HasChildren(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "hasChildren"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex) bool)(signal))(core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).HasChildrenDefault(core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QDirModel) HasChildrenDefault(parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_HasChildrenDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QDirModel) IsDir(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_IsDir(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QDirModel) IsReadOnly() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_IsReadOnly(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDirModel) LazyChildCount() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_LazyChildCount(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDirModel) ResolveSymlinks() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_ResolveSymlinks(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQDirModel_MetaObject
func callbackQDirModel_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQDirModelFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QDirModel) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QDirModel_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQDirModel_ColumnCount
func callbackQDirModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*core.QModelIndex) int)(signal))(core.NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQDirModelFromPointer(ptr).ColumnCountDefault(core.NewQModelIndexFromPointer(parent))))
}

func (ptr *QDirModel) ConnectColumnCount(f func(parent *core.QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnCount"); signal != nil {
			f := func(parent *core.QModelIndex) int {
				(*(*func(*core.QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDirModel) DisconnectColumnCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnCount")
	}
}

func (ptr *QDirModel) ColumnCount(parent core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel_ColumnCount(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QDirModel) ColumnCountDefault(parent core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel_ColumnCountDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQDirModel_RowCount
func callbackQDirModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*core.QModelIndex) int)(signal))(core.NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQDirModelFromPointer(ptr).RowCountDefault(core.NewQModelIndexFromPointer(parent))))
}

func (ptr *QDirModel) ConnectRowCount(f func(parent *core.QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowCount"); signal != nil {
			f := func(parent *core.QModelIndex) int {
				(*(*func(*core.QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDirModel) DisconnectRowCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowCount")
	}
}

func (ptr *QDirModel) RowCount(parent core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel_RowCount(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QDirModel) RowCountDefault(parent core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel_RowCountDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QDirModel) __mimeData_indexes_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel___mimeData_indexes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __mimeData_indexes_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___mimeData_indexes_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QDirModel) __mimeData_indexes_newList() unsafe.Pointer {
	return C.QDirModel___mimeData_indexes_newList(ptr.Pointer())
}

func (ptr *QDirModel) __setItemData_roles_atList(v int, i int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QDirModel___setItemData_roles_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __setItemData_roles_setList(key int, i core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___setItemData_roles_setList(ptr.Pointer(), C.int(int32(key)), core.PointerFromQVariant(i))
	}
}

func (ptr *QDirModel) __setItemData_roles_newList() unsafe.Pointer {
	return C.QDirModel___setItemData_roles_newList(ptr.Pointer())
}

func (ptr *QDirModel) __setItemData_roles_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____setItemData_roles_keyList_atList(i)
			}
			return out
		}(C.QDirModel___setItemData_roles_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QDirModel) __changePersistentIndexList_from_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel___changePersistentIndexList_from_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __changePersistentIndexList_from_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___changePersistentIndexList_from_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QDirModel) __changePersistentIndexList_from_newList() unsafe.Pointer {
	return C.QDirModel___changePersistentIndexList_from_newList(ptr.Pointer())
}

func (ptr *QDirModel) __changePersistentIndexList_to_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel___changePersistentIndexList_to_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __changePersistentIndexList_to_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___changePersistentIndexList_to_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QDirModel) __changePersistentIndexList_to_newList() unsafe.Pointer {
	return C.QDirModel___changePersistentIndexList_to_newList(ptr.Pointer())
}

func (ptr *QDirModel) __dataChanged_roles_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel___dataChanged_roles_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QDirModel) __dataChanged_roles_setList(i int) {
	if ptr.Pointer() != nil {
		C.QDirModel___dataChanged_roles_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QDirModel) __dataChanged_roles_newList() unsafe.Pointer {
	return C.QDirModel___dataChanged_roles_newList(ptr.Pointer())
}

func (ptr *QDirModel) __layoutAboutToBeChanged_parents_atList(i int) *core.QPersistentModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPersistentModelIndexFromPointer(C.QDirModel___layoutAboutToBeChanged_parents_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QPersistentModelIndex).DestroyQPersistentModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __layoutAboutToBeChanged_parents_setList(i core.QPersistentModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___layoutAboutToBeChanged_parents_setList(ptr.Pointer(), core.PointerFromQPersistentModelIndex(i))
	}
}

func (ptr *QDirModel) __layoutAboutToBeChanged_parents_newList() unsafe.Pointer {
	return C.QDirModel___layoutAboutToBeChanged_parents_newList(ptr.Pointer())
}

func (ptr *QDirModel) __layoutChanged_parents_atList(i int) *core.QPersistentModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPersistentModelIndexFromPointer(C.QDirModel___layoutChanged_parents_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QPersistentModelIndex).DestroyQPersistentModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __layoutChanged_parents_setList(i core.QPersistentModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___layoutChanged_parents_setList(ptr.Pointer(), core.PointerFromQPersistentModelIndex(i))
	}
}

func (ptr *QDirModel) __layoutChanged_parents_newList() unsafe.Pointer {
	return C.QDirModel___layoutChanged_parents_newList(ptr.Pointer())
}

func (ptr *QDirModel) __roleNames_atList(v int, i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QDirModel___roleNames_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __roleNames_setList(key int, i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___roleNames_setList(ptr.Pointer(), C.int(int32(key)), core.PointerFromQByteArray(i))
	}
}

func (ptr *QDirModel) __roleNames_newList() unsafe.Pointer {
	return C.QDirModel___roleNames_newList(ptr.Pointer())
}

func (ptr *QDirModel) __roleNames_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____roleNames_keyList_atList(i)
			}
			return out
		}(C.QDirModel___roleNames_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QDirModel) __itemData_atList(v int, i int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QDirModel___itemData_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __itemData_setList(key int, i core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___itemData_setList(ptr.Pointer(), C.int(int32(key)), core.PointerFromQVariant(i))
	}
}

func (ptr *QDirModel) __itemData_newList() unsafe.Pointer {
	return C.QDirModel___itemData_newList(ptr.Pointer())
}

func (ptr *QDirModel) __itemData_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____itemData_keyList_atList(i)
			}
			return out
		}(C.QDirModel___itemData_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QDirModel) __match_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel___match_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __match_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___match_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QDirModel) __match_newList() unsafe.Pointer {
	return C.QDirModel___match_newList(ptr.Pointer())
}

func (ptr *QDirModel) __persistentIndexList_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel___persistentIndexList_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __persistentIndexList_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___persistentIndexList_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QDirModel) __persistentIndexList_newList() unsafe.Pointer {
	return C.QDirModel___persistentIndexList_newList(ptr.Pointer())
}

func (ptr *QDirModel) ____setItemData_roles_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel_____setItemData_roles_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QDirModel) ____setItemData_roles_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QDirModel_____setItemData_roles_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QDirModel) ____setItemData_roles_keyList_newList() unsafe.Pointer {
	return C.QDirModel_____setItemData_roles_keyList_newList(ptr.Pointer())
}

func (ptr *QDirModel) ____doSetRoleNames_roleNames_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel_____doSetRoleNames_roleNames_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QDirModel) ____doSetRoleNames_roleNames_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QDirModel_____doSetRoleNames_roleNames_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QDirModel) ____doSetRoleNames_roleNames_keyList_newList() unsafe.Pointer {
	return C.QDirModel_____doSetRoleNames_roleNames_keyList_newList(ptr.Pointer())
}

func (ptr *QDirModel) ____setRoleNames_roleNames_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel_____setRoleNames_roleNames_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QDirModel) ____setRoleNames_roleNames_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QDirModel_____setRoleNames_roleNames_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QDirModel) ____setRoleNames_roleNames_keyList_newList() unsafe.Pointer {
	return C.QDirModel_____setRoleNames_roleNames_keyList_newList(ptr.Pointer())
}

func (ptr *QDirModel) ____roleNames_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel_____roleNames_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QDirModel) ____roleNames_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QDirModel_____roleNames_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QDirModel) ____roleNames_keyList_newList() unsafe.Pointer {
	return C.QDirModel_____roleNames_keyList_newList(ptr.Pointer())
}

func (ptr *QDirModel) ____itemData_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDirModel_____itemData_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QDirModel) ____itemData_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QDirModel_____itemData_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QDirModel) ____itemData_keyList_newList() unsafe.Pointer {
	return C.QDirModel_____itemData_keyList_newList(ptr.Pointer())
}

func (ptr *QDirModel) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QDirModel___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QDirModel) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QDirModel___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QDirModel) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QDirModel___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QDirModel) __findChildren_newList2() unsafe.Pointer {
	return C.QDirModel___findChildren_newList2(ptr.Pointer())
}

func (ptr *QDirModel) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QDirModel___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QDirModel) __findChildren_newList3() unsafe.Pointer {
	return C.QDirModel___findChildren_newList3(ptr.Pointer())
}

func (ptr *QDirModel) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QDirModel___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QDirModel) __findChildren_newList() unsafe.Pointer {
	return C.QDirModel___findChildren_newList(ptr.Pointer())
}

func (ptr *QDirModel) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QDirModel___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDirModel) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QDirModel) __children_newList() unsafe.Pointer {
	return C.QDirModel___children_newList(ptr.Pointer())
}

//export callbackQDirModel_InsertColumns
func callbackQDirModel_InsertColumns(ptr unsafe.Pointer, column C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "insertColumns"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *core.QModelIndex) bool)(signal))(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).InsertColumnsDefault(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QDirModel) InsertColumnsDefault(column int, count int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_InsertColumnsDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQDirModel_InsertRows
func callbackQDirModel_InsertRows(ptr unsafe.Pointer, row C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "insertRows"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *core.QModelIndex) bool)(signal))(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).InsertRowsDefault(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QDirModel) InsertRowsDefault(row int, count int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_InsertRowsDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQDirModel_MoveColumns
func callbackQDirModel_MoveColumns(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.char {
	if signal := qt.GetSignal(ptr, "moveColumns"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int) bool)(signal))(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceColumn)), int(int32(count)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).MoveColumnsDefault(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceColumn)), int(int32(count)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
}

func (ptr *QDirModel) MoveColumnsDefault(sourceParent core.QModelIndex_ITF, sourceColumn int, count int, destinationParent core.QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_MoveColumnsDefault(ptr.Pointer(), core.PointerFromQModelIndex(sourceParent), C.int(int32(sourceColumn)), C.int(int32(count)), core.PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

//export callbackQDirModel_MoveRows
func callbackQDirModel_MoveRows(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.char {
	if signal := qt.GetSignal(ptr, "moveRows"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int) bool)(signal))(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceRow)), int(int32(count)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).MoveRowsDefault(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceRow)), int(int32(count)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
}

func (ptr *QDirModel) MoveRowsDefault(sourceParent core.QModelIndex_ITF, sourceRow int, count int, destinationParent core.QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_MoveRowsDefault(ptr.Pointer(), core.PointerFromQModelIndex(sourceParent), C.int(int32(sourceRow)), C.int(int32(count)), core.PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

//export callbackQDirModel_RemoveColumns
func callbackQDirModel_RemoveColumns(ptr unsafe.Pointer, column C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "removeColumns"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *core.QModelIndex) bool)(signal))(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).RemoveColumnsDefault(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QDirModel) RemoveColumnsDefault(column int, count int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_RemoveColumnsDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQDirModel_RemoveRows
func callbackQDirModel_RemoveRows(ptr unsafe.Pointer, row C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "removeRows"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *core.QModelIndex) bool)(signal))(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).RemoveRowsDefault(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QDirModel) RemoveRowsDefault(row int, count int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_RemoveRowsDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQDirModel_SetHeaderData
func callbackQDirModel_SetHeaderData(ptr unsafe.Pointer, section C.int, orientation C.longlong, value unsafe.Pointer, role C.int) C.char {
	if signal := qt.GetSignal(ptr, "setHeaderData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, core.Qt__Orientation, *core.QVariant, int) bool)(signal))(int(int32(section)), core.Qt__Orientation(orientation), core.NewQVariantFromPointer(value), int(int32(role))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).SetHeaderDataDefault(int(int32(section)), core.Qt__Orientation(orientation), core.NewQVariantFromPointer(value), int(int32(role))))))
}

func (ptr *QDirModel) SetHeaderDataDefault(section int, orientation core.Qt__Orientation, value core.QVariant_ITF, role int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_SetHeaderDataDefault(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), core.PointerFromQVariant(value), C.int(int32(role)))) != 0
	}
	return false
}

//export callbackQDirModel_SetItemData
func callbackQDirModel_SetItemData(ptr unsafe.Pointer, index unsafe.Pointer, roles C.struct_QtWidgets_PackedList) C.char {
	if signal := qt.GetSignal(ptr, "setItemData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex, map[int]*core.QVariant) bool)(signal))(core.NewQModelIndexFromPointer(index), func(l C.struct_QtWidgets_PackedList) map[int]*core.QVariant {
			out := make(map[int]*core.QVariant, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i, v := range tmpList.__setItemData_roles_keyList() {
				out[v] = tmpList.__setItemData_roles_atList(v, i)
			}
			return out
		}(roles)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).SetItemDataDefault(core.NewQModelIndexFromPointer(index), func(l C.struct_QtWidgets_PackedList) map[int]*core.QVariant {
		out := make(map[int]*core.QVariant, int(l.len))
		tmpList := NewQDirModelFromPointer(l.data)
		for i, v := range tmpList.__setItemData_roles_keyList() {
			out[v] = tmpList.__setItemData_roles_atList(v, i)
		}
		return out
	}(roles)))))
}

func (ptr *QDirModel) SetItemDataDefault(index core.QModelIndex_ITF, roles map[int]*core.QVariant) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_SetItemDataDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), func() unsafe.Pointer {
			tmpList := NewQDirModelFromPointer(NewQDirModelFromPointer(nil).__setItemData_roles_newList())
			for k, v := range roles {
				tmpList.__setItemData_roles_setList(k, v)
			}
			return tmpList.Pointer()
		}())) != 0
	}
	return false
}

//export callbackQDirModel_Submit
func callbackQDirModel_Submit(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "submit"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).SubmitDefault())))
}

func (ptr *QDirModel) SubmitDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_SubmitDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQDirModel_ColumnsAboutToBeInserted
func callbackQDirModel_ColumnsAboutToBeInserted(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsAboutToBeInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQDirModel_ColumnsAboutToBeMoved
func callbackQDirModel_ColumnsAboutToBeMoved(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationColumn C.int) {
	if signal := qt.GetSignal(ptr, "columnsAboutToBeMoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int))(signal))(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceStart)), int(int32(sourceEnd)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationColumn)))
	}

}

//export callbackQDirModel_ColumnsAboutToBeRemoved
func callbackQDirModel_ColumnsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsAboutToBeRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQDirModel_ColumnsInserted
func callbackQDirModel_ColumnsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQDirModel_ColumnsMoved
func callbackQDirModel_ColumnsMoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "columnsMoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)), core.NewQModelIndexFromPointer(destination), int(int32(column)))
	}

}

//export callbackQDirModel_ColumnsRemoved
func callbackQDirModel_ColumnsRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQDirModel_DataChanged
func callbackQDirModel_DataChanged(ptr unsafe.Pointer, topLeft unsafe.Pointer, bottomRight unsafe.Pointer, roles C.struct_QtWidgets_PackedList) {
	if signal := qt.GetSignal(ptr, "dataChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex, []int))(signal))(core.NewQModelIndexFromPointer(topLeft), core.NewQModelIndexFromPointer(bottomRight), func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__dataChanged_roles_atList(i)
			}
			return out
		}(roles))
	}

}

//export callbackQDirModel_FetchMore
func callbackQDirModel_FetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "fetchMore"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(parent))
	} else {
		NewQDirModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
	}
}

func (ptr *QDirModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
	}
}

//export callbackQDirModel_HeaderDataChanged
func callbackQDirModel_HeaderDataChanged(ptr unsafe.Pointer, orientation C.longlong, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "headerDataChanged"); signal != nil {
		(*(*func(core.Qt__Orientation, int, int))(signal))(core.Qt__Orientation(orientation), int(int32(first)), int(int32(last)))
	}

}

//export callbackQDirModel_LayoutAboutToBeChanged
func callbackQDirModel_LayoutAboutToBeChanged(ptr unsafe.Pointer, parents C.struct_QtWidgets_PackedList, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "layoutAboutToBeChanged"); signal != nil {
		(*(*func([]*core.QPersistentModelIndex, core.QAbstractItemModel__LayoutChangeHint))(signal))(func(l C.struct_QtWidgets_PackedList) []*core.QPersistentModelIndex {
			out := make([]*core.QPersistentModelIndex, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__layoutAboutToBeChanged_parents_atList(i)
			}
			return out
		}(parents), core.QAbstractItemModel__LayoutChangeHint(hint))
	}

}

//export callbackQDirModel_LayoutChanged
func callbackQDirModel_LayoutChanged(ptr unsafe.Pointer, parents C.struct_QtWidgets_PackedList, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "layoutChanged"); signal != nil {
		(*(*func([]*core.QPersistentModelIndex, core.QAbstractItemModel__LayoutChangeHint))(signal))(func(l C.struct_QtWidgets_PackedList) []*core.QPersistentModelIndex {
			out := make([]*core.QPersistentModelIndex, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__layoutChanged_parents_atList(i)
			}
			return out
		}(parents), core.QAbstractItemModel__LayoutChangeHint(hint))
	}

}

//export callbackQDirModel_ModelAboutToBeReset
func callbackQDirModel_ModelAboutToBeReset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "modelAboutToBeReset"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQDirModel_ModelReset
func callbackQDirModel_ModelReset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "modelReset"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQDirModel_ResetInternalData
func callbackQDirModel_ResetInternalData(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resetInternalData"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDirModelFromPointer(ptr).ResetInternalDataDefault()
	}
}

func (ptr *QDirModel) ResetInternalDataDefault() {
	if ptr.Pointer() != nil {
		C.QDirModel_ResetInternalDataDefault(ptr.Pointer())
	}
}

//export callbackQDirModel_Revert
func callbackQDirModel_Revert(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "revert"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDirModelFromPointer(ptr).RevertDefault()
	}
}

func (ptr *QDirModel) RevertDefault() {
	if ptr.Pointer() != nil {
		C.QDirModel_RevertDefault(ptr.Pointer())
	}
}

//export callbackQDirModel_RowsAboutToBeInserted
func callbackQDirModel_RowsAboutToBeInserted(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}

}

//export callbackQDirModel_RowsAboutToBeMoved
func callbackQDirModel_RowsAboutToBeMoved(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationRow C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeMoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int))(signal))(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceStart)), int(int32(sourceEnd)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationRow)))
	}

}

//export callbackQDirModel_RowsAboutToBeRemoved
func callbackQDirModel_RowsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQDirModel_RowsInserted
func callbackQDirModel_RowsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "rowsInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQDirModel_RowsMoved
func callbackQDirModel_RowsMoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, row C.int) {
	if signal := qt.GetSignal(ptr, "rowsMoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)), core.NewQModelIndexFromPointer(destination), int(int32(row)))
	}

}

//export callbackQDirModel_RowsRemoved
func callbackQDirModel_RowsRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "rowsRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQDirModel_RoleNames
func callbackQDirModel_RoleNames(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "roleNames"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQDirModelFromPointer(NewQDirModelFromPointer(nil).__roleNames_newList())
			for k, v := range (*(*func() map[int]*core.QByteArray)(signal))() {
				tmpList.__roleNames_setList(k, v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQDirModelFromPointer(NewQDirModelFromPointer(nil).__roleNames_newList())
		for k, v := range NewQDirModelFromPointer(ptr).RoleNamesDefault() {
			tmpList.__roleNames_setList(k, v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QDirModel) RoleNamesDefault() map[int]*core.QByteArray {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) map[int]*core.QByteArray {
			out := make(map[int]*core.QByteArray, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i, v := range tmpList.__roleNames_keyList() {
				out[v] = tmpList.__roleNames_atList(v, i)
			}
			return out
		}(C.QDirModel_RoleNamesDefault(ptr.Pointer()))
	}
	return make(map[int]*core.QByteArray, 0)
}

//export callbackQDirModel_ItemData
func callbackQDirModel_ItemData(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemData"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQDirModelFromPointer(NewQDirModelFromPointer(nil).__itemData_newList())
			for k, v := range (*(*func(*core.QModelIndex) map[int]*core.QVariant)(signal))(core.NewQModelIndexFromPointer(index)) {
				tmpList.__itemData_setList(k, v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQDirModelFromPointer(NewQDirModelFromPointer(nil).__itemData_newList())
		for k, v := range NewQDirModelFromPointer(ptr).ItemDataDefault(core.NewQModelIndexFromPointer(index)) {
			tmpList.__itemData_setList(k, v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QDirModel) ItemDataDefault(index core.QModelIndex_ITF) map[int]*core.QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) map[int]*core.QVariant {
			out := make(map[int]*core.QVariant, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i, v := range tmpList.__itemData_keyList() {
				out[v] = tmpList.__itemData_atList(v, i)
			}
			return out
		}(C.QDirModel_ItemDataDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return make(map[int]*core.QVariant, 0)
}

//export callbackQDirModel_Buddy
func callbackQDirModel_Buddy(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "buddy"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QModelIndex) *core.QModelIndex)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQModelIndex(NewQDirModelFromPointer(ptr).BuddyDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QDirModel) BuddyDefault(index core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel_BuddyDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQDirModel_Sibling
func callbackQDirModel_Sibling(ptr unsafe.Pointer, row C.int, column C.int, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sibling"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(int, int, *core.QModelIndex) *core.QModelIndex)(signal))(int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQModelIndex(NewQDirModelFromPointer(ptr).SiblingDefault(int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(index)))
}

func (ptr *QDirModel) SiblingDefault(row int, column int, index core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QDirModel_SiblingDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQDirModel_Match
func callbackQDirModel_Match(ptr unsafe.Pointer, start unsafe.Pointer, role C.int, value unsafe.Pointer, hits C.int, flags C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "match"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQDirModelFromPointer(NewQDirModelFromPointer(nil).__match_newList())
			for _, v := range (*(*func(*core.QModelIndex, int, *core.QVariant, int, core.Qt__MatchFlag) []*core.QModelIndex)(signal))(core.NewQModelIndexFromPointer(start), int(int32(role)), core.NewQVariantFromPointer(value), int(int32(hits)), core.Qt__MatchFlag(flags)) {
				tmpList.__match_setList(v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQDirModelFromPointer(NewQDirModelFromPointer(nil).__match_newList())
		for _, v := range NewQDirModelFromPointer(ptr).MatchDefault(core.NewQModelIndexFromPointer(start), int(int32(role)), core.NewQVariantFromPointer(value), int(int32(hits)), core.Qt__MatchFlag(flags)) {
			tmpList.__match_setList(v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QDirModel) MatchDefault(start core.QModelIndex_ITF, role int, value core.QVariant_ITF, hits int, flags core.Qt__MatchFlag) []*core.QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
			out := make([]*core.QModelIndex, int(l.len))
			tmpList := NewQDirModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__match_atList(i)
			}
			return out
		}(C.QDirModel_MatchDefault(ptr.Pointer(), core.PointerFromQModelIndex(start), C.int(int32(role)), core.PointerFromQVariant(value), C.int(int32(hits)), C.longlong(flags)))
	}
	return make([]*core.QModelIndex, 0)
}

//export callbackQDirModel_Span
func callbackQDirModel_Span(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "span"); signal != nil {
		return core.PointerFromQSize((*(*func(*core.QModelIndex) *core.QSize)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQSize(NewQDirModelFromPointer(ptr).SpanDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QDirModel) SpanDefault(index core.QModelIndex_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QDirModel_SpanDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQDirModel_SupportedDragActions
func callbackQDirModel_SupportedDragActions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "supportedDragActions"); signal != nil {
		return C.longlong((*(*func() core.Qt__DropAction)(signal))())
	}

	return C.longlong(NewQDirModelFromPointer(ptr).SupportedDragActionsDefault())
}

func (ptr *QDirModel) SupportedDragActionsDefault() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QDirModel_SupportedDragActionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQDirModel_CanDropMimeData
func callbackQDirModel_CanDropMimeData(ptr unsafe.Pointer, data unsafe.Pointer, action C.longlong, row C.int, column C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "canDropMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QMimeData, core.Qt__DropAction, int, int, *core.QModelIndex) bool)(signal))(core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action), int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).CanDropMimeDataDefault(core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action), int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QDirModel) CanDropMimeDataDefault(data core.QMimeData_ITF, action core.Qt__DropAction, row int, column int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_CanDropMimeDataDefault(ptr.Pointer(), core.PointerFromQMimeData(data), C.longlong(action), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQDirModel_CanFetchMore
func callbackQDirModel_CanFetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "canFetchMore"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex) bool)(signal))(core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).CanFetchMoreDefault(core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QDirModel) CanFetchMoreDefault(parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_CanFetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQDirModel_Event
func callbackQDirModel_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QDirModel) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQDirModel_EventFilter
func callbackQDirModel_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQDirModelFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QDirModel) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDirModel_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQDirModel_ChildEvent
func callbackQDirModel_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQDirModelFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QDirModel) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQDirModel_ConnectNotify
func callbackQDirModel_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQDirModelFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QDirModel) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQDirModel_CustomEvent
func callbackQDirModel_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQDirModelFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QDirModel) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQDirModel_DeleteLater
func callbackQDirModel_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDirModelFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QDirModel) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QDirModel_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQDirModel_Destroyed
func callbackQDirModel_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQDirModel_DisconnectNotify
func callbackQDirModel_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQDirModelFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QDirModel) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQDirModel_ObjectNameChanged
func callbackQDirModel_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQDirModel_TimerEvent
func callbackQDirModel_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQDirModelFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QDirModel) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QDirModel_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QDockWidget struct {
	QWidget
}

type QDockWidget_ITF interface {
	QWidget_ITF
	QDockWidget_PTR() *QDockWidget
}

func (ptr *QDockWidget) QDockWidget_PTR() *QDockWidget {
	return ptr
}

func (ptr *QDockWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QDockWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQDockWidget(ptr QDockWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDockWidget_PTR().Pointer()
	}
	return nil
}

func NewQDockWidgetFromPointer(ptr unsafe.Pointer) (n *QDockWidget) {
	n = new(QDockWidget)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QDockWidget__DockWidgetFeature
//QDockWidget::DockWidgetFeature
type QDockWidget__DockWidgetFeature int64

const (
	QDockWidget__DockWidgetClosable         QDockWidget__DockWidgetFeature = QDockWidget__DockWidgetFeature(0x01)
	QDockWidget__DockWidgetMovable          QDockWidget__DockWidgetFeature = QDockWidget__DockWidgetFeature(0x02)
	QDockWidget__DockWidgetFloatable        QDockWidget__DockWidgetFeature = QDockWidget__DockWidgetFeature(0x04)
	QDockWidget__DockWidgetVerticalTitleBar QDockWidget__DockWidgetFeature = QDockWidget__DockWidgetFeature(0x08)
	QDockWidget__DockWidgetFeatureMask      QDockWidget__DockWidgetFeature = QDockWidget__DockWidgetFeature(0x0f)
	QDockWidget__NoDockWidgetFeatures       QDockWidget__DockWidgetFeature = QDockWidget__DockWidgetFeature(0x00)
	QDockWidget__Reserved                   QDockWidget__DockWidgetFeature = QDockWidget__DockWidgetFeature(0xff)
)

func NewQDockWidget2(parent QWidget_ITF, flags core.Qt__WindowType) *QDockWidget {
	tmpValue := NewQDockWidgetFromPointer(C.QDockWidget_NewQDockWidget2(PointerFromQWidget(parent), C.longlong(flags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQDockWidget(title string, parent QWidget_ITF, flags core.Qt__WindowType) *QDockWidget {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	tmpValue := NewQDockWidgetFromPointer(C.QDockWidget_NewQDockWidget(C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, PointerFromQWidget(parent), C.longlong(flags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQDockWidget_AllowedAreasChanged
func callbackQDockWidget_AllowedAreasChanged(ptr unsafe.Pointer, allowedAreas C.longlong) {
	if signal := qt.GetSignal(ptr, "allowedAreasChanged"); signal != nil {
		(*(*func(core.Qt__DockWidgetArea))(signal))(core.Qt__DockWidgetArea(allowedAreas))
	}

}

func (ptr *QDockWidget) ConnectAllowedAreasChanged(f func(allowedAreas core.Qt__DockWidgetArea)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "allowedAreasChanged") {
			C.QDockWidget_ConnectAllowedAreasChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "allowedAreasChanged"); signal != nil {
			f := func(allowedAreas core.Qt__DockWidgetArea) {
				(*(*func(core.Qt__DockWidgetArea))(signal))(allowedAreas)
				f(allowedAreas)
			}
			qt.ConnectSignal(ptr.Pointer(), "allowedAreasChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "allowedAreasChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDockWidget) DisconnectAllowedAreasChanged() {
	if ptr.Pointer() != nil {
		C.QDockWidget_DisconnectAllowedAreasChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "allowedAreasChanged")
	}
}

func (ptr *QDockWidget) AllowedAreasChanged(allowedAreas core.Qt__DockWidgetArea) {
	if ptr.Pointer() != nil {
		C.QDockWidget_AllowedAreasChanged(ptr.Pointer(), C.longlong(allowedAreas))
	}
}

//export callbackQDockWidget_DockLocationChanged
func callbackQDockWidget_DockLocationChanged(ptr unsafe.Pointer, area C.longlong) {
	if signal := qt.GetSignal(ptr, "dockLocationChanged"); signal != nil {
		(*(*func(core.Qt__DockWidgetArea))(signal))(core.Qt__DockWidgetArea(area))
	}

}

func (ptr *QDockWidget) ConnectDockLocationChanged(f func(area core.Qt__DockWidgetArea)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "dockLocationChanged") {
			C.QDockWidget_ConnectDockLocationChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "dockLocationChanged"); signal != nil {
			f := func(area core.Qt__DockWidgetArea) {
				(*(*func(core.Qt__DockWidgetArea))(signal))(area)
				f(area)
			}
			qt.ConnectSignal(ptr.Pointer(), "dockLocationChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dockLocationChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDockWidget) DisconnectDockLocationChanged() {
	if ptr.Pointer() != nil {
		C.QDockWidget_DisconnectDockLocationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "dockLocationChanged")
	}
}

func (ptr *QDockWidget) DockLocationChanged(area core.Qt__DockWidgetArea) {
	if ptr.Pointer() != nil {
		C.QDockWidget_DockLocationChanged(ptr.Pointer(), C.longlong(area))
	}
}

//export callbackQDockWidget_FeaturesChanged
func callbackQDockWidget_FeaturesChanged(ptr unsafe.Pointer, features C.longlong) {
	if signal := qt.GetSignal(ptr, "featuresChanged"); signal != nil {
		(*(*func(QDockWidget__DockWidgetFeature))(signal))(QDockWidget__DockWidgetFeature(features))
	}

}

func (ptr *QDockWidget) ConnectFeaturesChanged(f func(features QDockWidget__DockWidgetFeature)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "featuresChanged") {
			C.QDockWidget_ConnectFeaturesChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "featuresChanged"); signal != nil {
			f := func(features QDockWidget__DockWidgetFeature) {
				(*(*func(QDockWidget__DockWidgetFeature))(signal))(features)
				f(features)
			}
			qt.ConnectSignal(ptr.Pointer(), "featuresChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "featuresChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDockWidget) DisconnectFeaturesChanged() {
	if ptr.Pointer() != nil {
		C.QDockWidget_DisconnectFeaturesChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "featuresChanged")
	}
}

func (ptr *QDockWidget) FeaturesChanged(features QDockWidget__DockWidgetFeature) {
	if ptr.Pointer() != nil {
		C.QDockWidget_FeaturesChanged(ptr.Pointer(), C.longlong(features))
	}
}

func (ptr *QDockWidget) SetAllowedAreas(areas core.Qt__DockWidgetArea) {
	if ptr.Pointer() != nil {
		C.QDockWidget_SetAllowedAreas(ptr.Pointer(), C.longlong(areas))
	}
}

func (ptr *QDockWidget) SetFeatures(features QDockWidget__DockWidgetFeature) {
	if ptr.Pointer() != nil {
		C.QDockWidget_SetFeatures(ptr.Pointer(), C.longlong(features))
	}
}

func (ptr *QDockWidget) SetFloating(floating bool) {
	if ptr.Pointer() != nil {
		C.QDockWidget_SetFloating(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(floating))))
	}
}

func (ptr *QDockWidget) SetTitleBarWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QDockWidget_SetTitleBarWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QDockWidget) SetWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QDockWidget_SetWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQDockWidget_TopLevelChanged
func callbackQDockWidget_TopLevelChanged(ptr unsafe.Pointer, topLevel C.char) {
	if signal := qt.GetSignal(ptr, "topLevelChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(topLevel) != 0)
	}

}

func (ptr *QDockWidget) ConnectTopLevelChanged(f func(topLevel bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "topLevelChanged") {
			C.QDockWidget_ConnectTopLevelChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "topLevelChanged"); signal != nil {
			f := func(topLevel bool) {
				(*(*func(bool))(signal))(topLevel)
				f(topLevel)
			}
			qt.ConnectSignal(ptr.Pointer(), "topLevelChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "topLevelChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDockWidget) DisconnectTopLevelChanged() {
	if ptr.Pointer() != nil {
		C.QDockWidget_DisconnectTopLevelChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "topLevelChanged")
	}
}

func (ptr *QDockWidget) TopLevelChanged(topLevel bool) {
	if ptr.Pointer() != nil {
		C.QDockWidget_TopLevelChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(topLevel))))
	}
}

//export callbackQDockWidget_VisibilityChanged
func callbackQDockWidget_VisibilityChanged(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(ptr, "visibilityChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(visible) != 0)
	}

}

func (ptr *QDockWidget) ConnectVisibilityChanged(f func(visible bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "visibilityChanged") {
			C.QDockWidget_ConnectVisibilityChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "visibilityChanged"); signal != nil {
			f := func(visible bool) {
				(*(*func(bool))(signal))(visible)
				f(visible)
			}
			qt.ConnectSignal(ptr.Pointer(), "visibilityChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "visibilityChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDockWidget) DisconnectVisibilityChanged() {
	if ptr.Pointer() != nil {
		C.QDockWidget_DisconnectVisibilityChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "visibilityChanged")
	}
}

func (ptr *QDockWidget) VisibilityChanged(visible bool) {
	if ptr.Pointer() != nil {
		C.QDockWidget_VisibilityChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQDockWidget_DestroyQDockWidget
func callbackQDockWidget_DestroyQDockWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QDockWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDockWidgetFromPointer(ptr).DestroyQDockWidgetDefault()
	}
}

func (ptr *QDockWidget) ConnectDestroyQDockWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QDockWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QDockWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QDockWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDockWidget) DisconnectDestroyQDockWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QDockWidget")
	}
}

func (ptr *QDockWidget) DestroyQDockWidget() {
	if ptr.Pointer() != nil {
		C.QDockWidget_DestroyQDockWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDockWidget) DestroyQDockWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QDockWidget_DestroyQDockWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDockWidget) ToggleViewAction() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QDockWidget_ToggleViewAction(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDockWidget) Features() QDockWidget__DockWidgetFeature {
	if ptr.Pointer() != nil {
		return QDockWidget__DockWidgetFeature(C.QDockWidget_Features(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDockWidget) TitleBarWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QDockWidget_TitleBarWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDockWidget) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QDockWidget_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QDockWidget) AllowedAreas() core.Qt__DockWidgetArea {
	if ptr.Pointer() != nil {
		return core.Qt__DockWidgetArea(C.QDockWidget_AllowedAreas(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDockWidget) IsAreaAllowed(area core.Qt__DockWidgetArea) bool {
	if ptr.Pointer() != nil {
		return int8(C.QDockWidget_IsAreaAllowed(ptr.Pointer(), C.longlong(area))) != 0
	}
	return false
}

func (ptr *QDockWidget) IsFloating() bool {
	if ptr.Pointer() != nil {
		return int8(C.QDockWidget_IsFloating(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QDockWidget) InitStyleOption(option QStyleOptionDockWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QDockWidget_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionDockWidget(option))
	}
}

type QDoubleSpinBox struct {
	QAbstractSpinBox
}

type QDoubleSpinBox_ITF interface {
	QAbstractSpinBox_ITF
	QDoubleSpinBox_PTR() *QDoubleSpinBox
}

func (ptr *QDoubleSpinBox) QDoubleSpinBox_PTR() *QDoubleSpinBox {
	return ptr
}

func (ptr *QDoubleSpinBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractSpinBox_PTR().Pointer()
	}
	return nil
}

func (ptr *QDoubleSpinBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractSpinBox_PTR().SetPointer(p)
	}
}

func PointerFromQDoubleSpinBox(ptr QDoubleSpinBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDoubleSpinBox_PTR().Pointer()
	}
	return nil
}

func NewQDoubleSpinBoxFromPointer(ptr unsafe.Pointer) (n *QDoubleSpinBox) {
	n = new(QDoubleSpinBox)
	n.SetPointer(ptr)
	return
}
func NewQDoubleSpinBox(parent QWidget_ITF) *QDoubleSpinBox {
	tmpValue := NewQDoubleSpinBoxFromPointer(C.QDoubleSpinBox_NewQDoubleSpinBox(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QDoubleSpinBox) SetDecimals(prec int) {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_SetDecimals(ptr.Pointer(), C.int(int32(prec)))
	}
}

func (ptr *QDoubleSpinBox) SetMaximum(max float64) {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_SetMaximum(ptr.Pointer(), C.double(max))
	}
}

func (ptr *QDoubleSpinBox) SetMinimum(min float64) {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_SetMinimum(ptr.Pointer(), C.double(min))
	}
}

func (ptr *QDoubleSpinBox) SetPrefix(prefix string) {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		C.QDoubleSpinBox_SetPrefix(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: prefixC, len: C.longlong(len(prefix))})
	}
}

func (ptr *QDoubleSpinBox) SetRange(minimum float64, maximum float64) {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_SetRange(ptr.Pointer(), C.double(minimum), C.double(maximum))
	}
}

func (ptr *QDoubleSpinBox) SetSingleStep(val float64) {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_SetSingleStep(ptr.Pointer(), C.double(val))
	}
}

func (ptr *QDoubleSpinBox) SetStepType(stepType QAbstractSpinBox__StepType) {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_SetStepType(ptr.Pointer(), C.longlong(stepType))
	}
}

func (ptr *QDoubleSpinBox) SetSuffix(suffix string) {
	if ptr.Pointer() != nil {
		var suffixC *C.char
		if suffix != "" {
			suffixC = C.CString(suffix)
			defer C.free(unsafe.Pointer(suffixC))
		}
		C.QDoubleSpinBox_SetSuffix(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: suffixC, len: C.longlong(len(suffix))})
	}
}

//export callbackQDoubleSpinBox_SetValue
func callbackQDoubleSpinBox_SetValue(ptr unsafe.Pointer, val C.double) {
	if signal := qt.GetSignal(ptr, "setValue"); signal != nil {
		(*(*func(float64))(signal))(float64(val))
	} else {
		NewQDoubleSpinBoxFromPointer(ptr).SetValueDefault(float64(val))
	}
}

func (ptr *QDoubleSpinBox) ConnectSetValue(f func(val float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setValue"); signal != nil {
			f := func(val float64) {
				(*(*func(float64))(signal))(val)
				f(val)
			}
			qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDoubleSpinBox) DisconnectSetValue() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setValue")
	}
}

func (ptr *QDoubleSpinBox) SetValue(val float64) {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_SetValue(ptr.Pointer(), C.double(val))
	}
}

func (ptr *QDoubleSpinBox) SetValueDefault(val float64) {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_SetValueDefault(ptr.Pointer(), C.double(val))
	}
}

//export callbackQDoubleSpinBox_ValueChanged2
func callbackQDoubleSpinBox_ValueChanged2(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "valueChanged2"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QDoubleSpinBox) ConnectValueChanged2(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "valueChanged2") {
			C.QDoubleSpinBox_ConnectValueChanged2(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "valueChanged2"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueChanged2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueChanged2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDoubleSpinBox) DisconnectValueChanged2() {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_DisconnectValueChanged2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "valueChanged2")
	}
}

func (ptr *QDoubleSpinBox) ValueChanged2(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QDoubleSpinBox_ValueChanged2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQDoubleSpinBox_ValueChanged
func callbackQDoubleSpinBox_ValueChanged(ptr unsafe.Pointer, d C.double) {
	if signal := qt.GetSignal(ptr, "valueChanged"); signal != nil {
		(*(*func(float64))(signal))(float64(d))
	}

}

func (ptr *QDoubleSpinBox) ConnectValueChanged(f func(d float64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "valueChanged") {
			C.QDoubleSpinBox_ConnectValueChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "valueChanged"); signal != nil {
			f := func(d float64) {
				(*(*func(float64))(signal))(d)
				f(d)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDoubleSpinBox) DisconnectValueChanged() {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_DisconnectValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "valueChanged")
	}
}

func (ptr *QDoubleSpinBox) ValueChanged(d float64) {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_ValueChanged(ptr.Pointer(), C.double(d))
	}
}

//export callbackQDoubleSpinBox_DestroyQDoubleSpinBox
func callbackQDoubleSpinBox_DestroyQDoubleSpinBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QDoubleSpinBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQDoubleSpinBoxFromPointer(ptr).DestroyQDoubleSpinBoxDefault()
	}
}

func (ptr *QDoubleSpinBox) ConnectDestroyQDoubleSpinBox(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QDoubleSpinBox"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QDoubleSpinBox", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QDoubleSpinBox", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDoubleSpinBox) DisconnectDestroyQDoubleSpinBox() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QDoubleSpinBox")
	}
}

func (ptr *QDoubleSpinBox) DestroyQDoubleSpinBox() {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_DestroyQDoubleSpinBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDoubleSpinBox) DestroyQDoubleSpinBoxDefault() {
	if ptr.Pointer() != nil {
		C.QDoubleSpinBox_DestroyQDoubleSpinBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QDoubleSpinBox) StepType() QAbstractSpinBox__StepType {
	if ptr.Pointer() != nil {
		return QAbstractSpinBox__StepType(C.QDoubleSpinBox_StepType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDoubleSpinBox) CleanText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDoubleSpinBox_CleanText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDoubleSpinBox) Prefix() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDoubleSpinBox_Prefix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QDoubleSpinBox) Suffix() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDoubleSpinBox_Suffix(ptr.Pointer()))
	}
	return ""
}

//export callbackQDoubleSpinBox_TextFromValue
func callbackQDoubleSpinBox_TextFromValue(ptr unsafe.Pointer, value C.double) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "textFromValue"); signal != nil {
		tempVal := (*(*func(float64) string)(signal))(float64(value))
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQDoubleSpinBoxFromPointer(ptr).TextFromValueDefault(float64(value))
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QDoubleSpinBox) ConnectTextFromValue(f func(value float64) string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "textFromValue"); signal != nil {
			f := func(value float64) string {
				(*(*func(float64) string)(signal))(value)
				return f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "textFromValue", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "textFromValue", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDoubleSpinBox) DisconnectTextFromValue() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "textFromValue")
	}
}

func (ptr *QDoubleSpinBox) TextFromValue(value float64) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDoubleSpinBox_TextFromValue(ptr.Pointer(), C.double(value)))
	}
	return ""
}

func (ptr *QDoubleSpinBox) TextFromValueDefault(value float64) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QDoubleSpinBox_TextFromValueDefault(ptr.Pointer(), C.double(value)))
	}
	return ""
}

func (ptr *QDoubleSpinBox) Maximum() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QDoubleSpinBox_Maximum(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDoubleSpinBox) Minimum() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QDoubleSpinBox_Minimum(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDoubleSpinBox) SingleStep() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QDoubleSpinBox_SingleStep(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDoubleSpinBox) Value() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QDoubleSpinBox_Value(ptr.Pointer()))
	}
	return 0
}

//export callbackQDoubleSpinBox_ValueFromText
func callbackQDoubleSpinBox_ValueFromText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) C.double {
	if signal := qt.GetSignal(ptr, "valueFromText"); signal != nil {
		return C.double((*(*func(string) float64)(signal))(cGoUnpackString(text)))
	}

	return C.double(NewQDoubleSpinBoxFromPointer(ptr).ValueFromTextDefault(cGoUnpackString(text)))
}

func (ptr *QDoubleSpinBox) ConnectValueFromText(f func(text string) float64) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "valueFromText"); signal != nil {
			f := func(text string) float64 {
				(*(*func(string) float64)(signal))(text)
				return f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueFromText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueFromText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QDoubleSpinBox) DisconnectValueFromText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "valueFromText")
	}
}

func (ptr *QDoubleSpinBox) ValueFromText(text string) float64 {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return float64(C.QDoubleSpinBox_ValueFromText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
	}
	return 0
}

func (ptr *QDoubleSpinBox) ValueFromTextDefault(text string) float64 {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return float64(C.QDoubleSpinBox_ValueFromTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
	}
	return 0
}

func (ptr *QDoubleSpinBox) Decimals() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QDoubleSpinBox_Decimals(ptr.Pointer())))
	}
	return 0
}

type QErrorMessage struct {
	QDialog
}

type QErrorMessage_ITF interface {
	QDialog_ITF
	QErrorMessage_PTR() *QErrorMessage
}

func (ptr *QErrorMessage) QErrorMessage_PTR() *QErrorMessage {
	return ptr
}

func (ptr *QErrorMessage) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QDialog_PTR().Pointer()
	}
	return nil
}

func (ptr *QErrorMessage) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QDialog_PTR().SetPointer(p)
	}
}

func PointerFromQErrorMessage(ptr QErrorMessage_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QErrorMessage_PTR().Pointer()
	}
	return nil
}

func NewQErrorMessageFromPointer(ptr unsafe.Pointer) (n *QErrorMessage) {
	n = new(QErrorMessage)
	n.SetPointer(ptr)
	return
}
func QErrorMessage_QtHandler() *QErrorMessage {
	tmpValue := NewQErrorMessageFromPointer(C.QErrorMessage_QErrorMessage_QtHandler())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QErrorMessage) QtHandler() *QErrorMessage {
	tmpValue := NewQErrorMessageFromPointer(C.QErrorMessage_QErrorMessage_QtHandler())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQErrorMessage(parent QWidget_ITF) *QErrorMessage {
	tmpValue := NewQErrorMessageFromPointer(C.QErrorMessage_NewQErrorMessage(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQErrorMessage_Done
func callbackQErrorMessage_Done(ptr unsafe.Pointer, a C.int) {
	if signal := qt.GetSignal(ptr, "done"); signal != nil {
		(*(*func(int))(signal))(int(int32(a)))
	} else {
		NewQErrorMessageFromPointer(ptr).DoneDefault(int(int32(a)))
	}
}

func (ptr *QErrorMessage) ConnectDone(f func(a int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "done"); signal != nil {
			f := func(a int) {
				(*(*func(int))(signal))(a)
				f(a)
			}
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QErrorMessage) DisconnectDone() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "done")
	}
}

func (ptr *QErrorMessage) Done(a int) {
	if ptr.Pointer() != nil {
		C.QErrorMessage_Done(ptr.Pointer(), C.int(int32(a)))
	}
}

func (ptr *QErrorMessage) DoneDefault(a int) {
	if ptr.Pointer() != nil {
		C.QErrorMessage_DoneDefault(ptr.Pointer(), C.int(int32(a)))
	}
}

//export callbackQErrorMessage_ShowMessage
func callbackQErrorMessage_ShowMessage(ptr unsafe.Pointer, message C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "showMessage"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(message))
	} else {
		NewQErrorMessageFromPointer(ptr).ShowMessageDefault(cGoUnpackString(message))
	}
}

func (ptr *QErrorMessage) ConnectShowMessage(f func(message string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMessage"); signal != nil {
			f := func(message string) {
				(*(*func(string))(signal))(message)
				f(message)
			}
			qt.ConnectSignal(ptr.Pointer(), "showMessage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMessage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QErrorMessage) DisconnectShowMessage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMessage")
	}
}

func (ptr *QErrorMessage) ShowMessage(message string) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QErrorMessage_ShowMessage(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))})
	}
}

func (ptr *QErrorMessage) ShowMessageDefault(message string) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QErrorMessage_ShowMessageDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))})
	}
}

//export callbackQErrorMessage_ShowMessage2
func callbackQErrorMessage_ShowMessage2(ptr unsafe.Pointer, message C.struct_QtWidgets_PackedString, ty C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "showMessage2"); signal != nil {
		(*(*func(string, string))(signal))(cGoUnpackString(message), cGoUnpackString(ty))
	} else {
		NewQErrorMessageFromPointer(ptr).ShowMessage2Default(cGoUnpackString(message), cGoUnpackString(ty))
	}
}

func (ptr *QErrorMessage) ConnectShowMessage2(f func(message string, ty string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMessage2"); signal != nil {
			f := func(message string, ty string) {
				(*(*func(string, string))(signal))(message, ty)
				f(message, ty)
			}
			qt.ConnectSignal(ptr.Pointer(), "showMessage2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMessage2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QErrorMessage) DisconnectShowMessage2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMessage2")
	}
}

func (ptr *QErrorMessage) ShowMessage2(message string, ty string) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		var tyC *C.char
		if ty != "" {
			tyC = C.CString(ty)
			defer C.free(unsafe.Pointer(tyC))
		}
		C.QErrorMessage_ShowMessage2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, C.struct_QtWidgets_PackedString{data: tyC, len: C.longlong(len(ty))})
	}
}

func (ptr *QErrorMessage) ShowMessage2Default(message string, ty string) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		var tyC *C.char
		if ty != "" {
			tyC = C.CString(ty)
			defer C.free(unsafe.Pointer(tyC))
		}
		C.QErrorMessage_ShowMessage2Default(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, C.struct_QtWidgets_PackedString{data: tyC, len: C.longlong(len(ty))})
	}
}

//export callbackQErrorMessage_DestroyQErrorMessage
func callbackQErrorMessage_DestroyQErrorMessage(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QErrorMessage"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQErrorMessageFromPointer(ptr).DestroyQErrorMessageDefault()
	}
}

func (ptr *QErrorMessage) ConnectDestroyQErrorMessage(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QErrorMessage"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QErrorMessage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QErrorMessage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QErrorMessage) DisconnectDestroyQErrorMessage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QErrorMessage")
	}
}

func (ptr *QErrorMessage) DestroyQErrorMessage() {
	if ptr.Pointer() != nil {
		C.QErrorMessage_DestroyQErrorMessage(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QErrorMessage) DestroyQErrorMessageDefault() {
	if ptr.Pointer() != nil {
		C.QErrorMessage_DestroyQErrorMessageDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QFileDialog struct {
	QDialog
}

type QFileDialog_ITF interface {
	QDialog_ITF
	QFileDialog_PTR() *QFileDialog
}

func (ptr *QFileDialog) QFileDialog_PTR() *QFileDialog {
	return ptr
}

func (ptr *QFileDialog) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QDialog_PTR().Pointer()
	}
	return nil
}

func (ptr *QFileDialog) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QDialog_PTR().SetPointer(p)
	}
}

func PointerFromQFileDialog(ptr QFileDialog_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileDialog_PTR().Pointer()
	}
	return nil
}

func NewQFileDialogFromPointer(ptr unsafe.Pointer) (n *QFileDialog) {
	n = new(QFileDialog)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QFileDialog__AcceptMode
//QFileDialog::AcceptMode
type QFileDialog__AcceptMode int64

const (
	QFileDialog__AcceptOpen QFileDialog__AcceptMode = QFileDialog__AcceptMode(0)
	QFileDialog__AcceptSave QFileDialog__AcceptMode = QFileDialog__AcceptMode(1)
)

//go:generate stringer -type=QFileDialog__DialogLabel
//QFileDialog::DialogLabel
type QFileDialog__DialogLabel int64

const (
	QFileDialog__LookIn   QFileDialog__DialogLabel = QFileDialog__DialogLabel(0)
	QFileDialog__FileName QFileDialog__DialogLabel = QFileDialog__DialogLabel(1)
	QFileDialog__FileType QFileDialog__DialogLabel = QFileDialog__DialogLabel(2)
	QFileDialog__Accept   QFileDialog__DialogLabel = QFileDialog__DialogLabel(3)
	QFileDialog__Reject   QFileDialog__DialogLabel = QFileDialog__DialogLabel(4)
)

//go:generate stringer -type=QFileDialog__FileMode
//QFileDialog::FileMode
type QFileDialog__FileMode int64

const (
	QFileDialog__AnyFile       QFileDialog__FileMode = QFileDialog__FileMode(0)
	QFileDialog__ExistingFile  QFileDialog__FileMode = QFileDialog__FileMode(1)
	QFileDialog__Directory     QFileDialog__FileMode = QFileDialog__FileMode(2)
	QFileDialog__ExistingFiles QFileDialog__FileMode = QFileDialog__FileMode(3)
	QFileDialog__DirectoryOnly QFileDialog__FileMode = QFileDialog__FileMode(4)
)

//go:generate stringer -type=QFileDialog__Option
//QFileDialog::Option
type QFileDialog__Option int64

const (
	QFileDialog__ShowDirsOnly                QFileDialog__Option = QFileDialog__Option(0x00000001)
	QFileDialog__DontResolveSymlinks         QFileDialog__Option = QFileDialog__Option(0x00000002)
	QFileDialog__DontConfirmOverwrite        QFileDialog__Option = QFileDialog__Option(0x00000004)
	QFileDialog__DontUseSheet                QFileDialog__Option = QFileDialog__Option(0x00000008)
	QFileDialog__DontUseNativeDialog         QFileDialog__Option = QFileDialog__Option(0x00000010)
	QFileDialog__ReadOnly                    QFileDialog__Option = QFileDialog__Option(0x00000020)
	QFileDialog__HideNameFilterDetails       QFileDialog__Option = QFileDialog__Option(0x00000040)
	QFileDialog__DontUseCustomDirectoryIcons QFileDialog__Option = QFileDialog__Option(0x00000080)
)

//go:generate stringer -type=QFileDialog__ViewMode
//QFileDialog::ViewMode
type QFileDialog__ViewMode int64

const (
	QFileDialog__Detail QFileDialog__ViewMode = QFileDialog__ViewMode(0)
	QFileDialog__List   QFileDialog__ViewMode = QFileDialog__ViewMode(1)
)

func NewQFileDialog(parent QWidget_ITF, flags core.Qt__WindowType) *QFileDialog {
	tmpValue := NewQFileDialogFromPointer(C.QFileDialog_NewQFileDialog(PointerFromQWidget(parent), C.longlong(flags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQFileDialog2(parent QWidget_ITF, caption string, directory string, filter string) *QFileDialog {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var directoryC *C.char
	if directory != "" {
		directoryC = C.CString(directory)
		defer C.free(unsafe.Pointer(directoryC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	tmpValue := NewQFileDialogFromPointer(C.QFileDialog_NewQFileDialog2(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, C.struct_QtWidgets_PackedString{data: directoryC, len: C.longlong(len(directory))}, C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QFileDialog_GetOpenFileUrls(parent QWidget_ITF, caption string, dir core.QUrl_ITF, filter string, selectedFilter string, options QFileDialog__Option, supportedSchemes []string) []*core.QUrl {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	supportedSchemesC := C.CString(strings.Join(supportedSchemes, "|"))
	defer C.free(unsafe.Pointer(supportedSchemesC))
	return func(l C.struct_QtWidgets_PackedList) []*core.QUrl {
		out := make([]*core.QUrl, int(l.len))
		tmpList := NewQFileDialogFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__getOpenFileUrls_atList(i)
		}
		return out
	}(C.QFileDialog_QFileDialog_GetOpenFileUrls(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, core.PointerFromQUrl(dir), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options), C.struct_QtWidgets_PackedString{data: supportedSchemesC, len: C.longlong(len(strings.Join(supportedSchemes, "|")))}))
}

func (ptr *QFileDialog) GetOpenFileUrls(parent QWidget_ITF, caption string, dir core.QUrl_ITF, filter string, selectedFilter string, options QFileDialog__Option, supportedSchemes []string) []*core.QUrl {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	supportedSchemesC := C.CString(strings.Join(supportedSchemes, "|"))
	defer C.free(unsafe.Pointer(supportedSchemesC))
	return func(l C.struct_QtWidgets_PackedList) []*core.QUrl {
		out := make([]*core.QUrl, int(l.len))
		tmpList := NewQFileDialogFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__getOpenFileUrls_atList(i)
		}
		return out
	}(C.QFileDialog_QFileDialog_GetOpenFileUrls(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, core.PointerFromQUrl(dir), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options), C.struct_QtWidgets_PackedString{data: supportedSchemesC, len: C.longlong(len(strings.Join(supportedSchemes, "|")))}))
}

func QFileDialog_GetExistingDirectory(parent QWidget_ITF, caption string, dir string, options QFileDialog__Option) string {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var dirC *C.char
	if dir != "" {
		dirC = C.CString(dir)
		defer C.free(unsafe.Pointer(dirC))
	}
	return cGoUnpackString(C.QFileDialog_QFileDialog_GetExistingDirectory(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, C.struct_QtWidgets_PackedString{data: dirC, len: C.longlong(len(dir))}, C.longlong(options)))
}

func (ptr *QFileDialog) GetExistingDirectory(parent QWidget_ITF, caption string, dir string, options QFileDialog__Option) string {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var dirC *C.char
	if dir != "" {
		dirC = C.CString(dir)
		defer C.free(unsafe.Pointer(dirC))
	}
	return cGoUnpackString(C.QFileDialog_QFileDialog_GetExistingDirectory(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, C.struct_QtWidgets_PackedString{data: dirC, len: C.longlong(len(dir))}, C.longlong(options)))
}

func QFileDialog_GetOpenFileName(parent QWidget_ITF, caption string, dir string, filter string, selectedFilter string, options QFileDialog__Option) string {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var dirC *C.char
	if dir != "" {
		dirC = C.CString(dir)
		defer C.free(unsafe.Pointer(dirC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	return cGoUnpackString(C.QFileDialog_QFileDialog_GetOpenFileName(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, C.struct_QtWidgets_PackedString{data: dirC, len: C.longlong(len(dir))}, C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options)))
}

func (ptr *QFileDialog) GetOpenFileName(parent QWidget_ITF, caption string, dir string, filter string, selectedFilter string, options QFileDialog__Option) string {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var dirC *C.char
	if dir != "" {
		dirC = C.CString(dir)
		defer C.free(unsafe.Pointer(dirC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	return cGoUnpackString(C.QFileDialog_QFileDialog_GetOpenFileName(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, C.struct_QtWidgets_PackedString{data: dirC, len: C.longlong(len(dir))}, C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options)))
}

func QFileDialog_GetSaveFileName(parent QWidget_ITF, caption string, dir string, filter string, selectedFilter string, options QFileDialog__Option) string {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var dirC *C.char
	if dir != "" {
		dirC = C.CString(dir)
		defer C.free(unsafe.Pointer(dirC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	return cGoUnpackString(C.QFileDialog_QFileDialog_GetSaveFileName(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, C.struct_QtWidgets_PackedString{data: dirC, len: C.longlong(len(dir))}, C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options)))
}

func (ptr *QFileDialog) GetSaveFileName(parent QWidget_ITF, caption string, dir string, filter string, selectedFilter string, options QFileDialog__Option) string {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var dirC *C.char
	if dir != "" {
		dirC = C.CString(dir)
		defer C.free(unsafe.Pointer(dirC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	return cGoUnpackString(C.QFileDialog_QFileDialog_GetSaveFileName(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, C.struct_QtWidgets_PackedString{data: dirC, len: C.longlong(len(dir))}, C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options)))
}

func QFileDialog_GetOpenFileNames(parent QWidget_ITF, caption string, dir string, filter string, selectedFilter string, options QFileDialog__Option) []string {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var dirC *C.char
	if dir != "" {
		dirC = C.CString(dir)
		defer C.free(unsafe.Pointer(dirC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	return strings.Split(cGoUnpackString(C.QFileDialog_QFileDialog_GetOpenFileNames(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, C.struct_QtWidgets_PackedString{data: dirC, len: C.longlong(len(dir))}, C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options))), "|")
}

func (ptr *QFileDialog) GetOpenFileNames(parent QWidget_ITF, caption string, dir string, filter string, selectedFilter string, options QFileDialog__Option) []string {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var dirC *C.char
	if dir != "" {
		dirC = C.CString(dir)
		defer C.free(unsafe.Pointer(dirC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	return strings.Split(cGoUnpackString(C.QFileDialog_QFileDialog_GetOpenFileNames(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, C.struct_QtWidgets_PackedString{data: dirC, len: C.longlong(len(dir))}, C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options))), "|")
}

func QFileDialog_GetExistingDirectoryUrl(parent QWidget_ITF, caption string, dir core.QUrl_ITF, options QFileDialog__Option, supportedSchemes []string) *core.QUrl {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	supportedSchemesC := C.CString(strings.Join(supportedSchemes, "|"))
	defer C.free(unsafe.Pointer(supportedSchemesC))
	tmpValue := core.NewQUrlFromPointer(C.QFileDialog_QFileDialog_GetExistingDirectoryUrl(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, core.PointerFromQUrl(dir), C.longlong(options), C.struct_QtWidgets_PackedString{data: supportedSchemesC, len: C.longlong(len(strings.Join(supportedSchemes, "|")))}))
	runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QFileDialog) GetExistingDirectoryUrl(parent QWidget_ITF, caption string, dir core.QUrl_ITF, options QFileDialog__Option, supportedSchemes []string) *core.QUrl {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	supportedSchemesC := C.CString(strings.Join(supportedSchemes, "|"))
	defer C.free(unsafe.Pointer(supportedSchemesC))
	tmpValue := core.NewQUrlFromPointer(C.QFileDialog_QFileDialog_GetExistingDirectoryUrl(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, core.PointerFromQUrl(dir), C.longlong(options), C.struct_QtWidgets_PackedString{data: supportedSchemesC, len: C.longlong(len(strings.Join(supportedSchemes, "|")))}))
	runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
	return tmpValue
}

func QFileDialog_GetOpenFileUrl(parent QWidget_ITF, caption string, dir core.QUrl_ITF, filter string, selectedFilter string, options QFileDialog__Option, supportedSchemes []string) *core.QUrl {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	supportedSchemesC := C.CString(strings.Join(supportedSchemes, "|"))
	defer C.free(unsafe.Pointer(supportedSchemesC))
	tmpValue := core.NewQUrlFromPointer(C.QFileDialog_QFileDialog_GetOpenFileUrl(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, core.PointerFromQUrl(dir), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options), C.struct_QtWidgets_PackedString{data: supportedSchemesC, len: C.longlong(len(strings.Join(supportedSchemes, "|")))}))
	runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QFileDialog) GetOpenFileUrl(parent QWidget_ITF, caption string, dir core.QUrl_ITF, filter string, selectedFilter string, options QFileDialog__Option, supportedSchemes []string) *core.QUrl {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	supportedSchemesC := C.CString(strings.Join(supportedSchemes, "|"))
	defer C.free(unsafe.Pointer(supportedSchemesC))
	tmpValue := core.NewQUrlFromPointer(C.QFileDialog_QFileDialog_GetOpenFileUrl(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, core.PointerFromQUrl(dir), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options), C.struct_QtWidgets_PackedString{data: supportedSchemesC, len: C.longlong(len(strings.Join(supportedSchemes, "|")))}))
	runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
	return tmpValue
}

func QFileDialog_GetSaveFileUrl(parent QWidget_ITF, caption string, dir core.QUrl_ITF, filter string, selectedFilter string, options QFileDialog__Option, supportedSchemes []string) *core.QUrl {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	supportedSchemesC := C.CString(strings.Join(supportedSchemes, "|"))
	defer C.free(unsafe.Pointer(supportedSchemesC))
	tmpValue := core.NewQUrlFromPointer(C.QFileDialog_QFileDialog_GetSaveFileUrl(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, core.PointerFromQUrl(dir), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options), C.struct_QtWidgets_PackedString{data: supportedSchemesC, len: C.longlong(len(strings.Join(supportedSchemes, "|")))}))
	runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QFileDialog) GetSaveFileUrl(parent QWidget_ITF, caption string, dir core.QUrl_ITF, filter string, selectedFilter string, options QFileDialog__Option, supportedSchemes []string) *core.QUrl {
	var captionC *C.char
	if caption != "" {
		captionC = C.CString(caption)
		defer C.free(unsafe.Pointer(captionC))
	}
	var filterC *C.char
	if filter != "" {
		filterC = C.CString(filter)
		defer C.free(unsafe.Pointer(filterC))
	}
	var selectedFilterC *C.char
	if selectedFilter != "" {
		selectedFilterC = C.CString(selectedFilter)
		defer C.free(unsafe.Pointer(selectedFilterC))
	}
	supportedSchemesC := C.CString(strings.Join(supportedSchemes, "|"))
	defer C.free(unsafe.Pointer(supportedSchemesC))
	tmpValue := core.NewQUrlFromPointer(C.QFileDialog_QFileDialog_GetSaveFileUrl(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: captionC, len: C.longlong(len(caption))}, core.PointerFromQUrl(dir), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))}, C.struct_QtWidgets_PackedString{data: selectedFilterC, len: C.longlong(len(selectedFilter))}, C.longlong(options), C.struct_QtWidgets_PackedString{data: supportedSchemesC, len: C.longlong(len(strings.Join(supportedSchemes, "|")))}))
	runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
	return tmpValue
}

func (ptr *QFileDialog) RestoreState(state core.QByteArray_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDialog_RestoreState(ptr.Pointer(), core.PointerFromQByteArray(state))) != 0
	}
	return false
}

//export callbackQFileDialog_Accept
func callbackQFileDialog_Accept(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "accept"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileDialogFromPointer(ptr).AcceptDefault()
	}
}

func (ptr *QFileDialog) ConnectAccept(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "accept"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "accept", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "accept", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectAccept() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "accept")
	}
}

func (ptr *QFileDialog) Accept() {
	if ptr.Pointer() != nil {
		C.QFileDialog_Accept(ptr.Pointer())
	}
}

func (ptr *QFileDialog) AcceptDefault() {
	if ptr.Pointer() != nil {
		C.QFileDialog_AcceptDefault(ptr.Pointer())
	}
}

//export callbackQFileDialog_CurrentChanged
func callbackQFileDialog_CurrentChanged(ptr unsafe.Pointer, path C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(path))
	}

}

func (ptr *QFileDialog) ConnectCurrentChanged(f func(path string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentChanged") {
			C.QFileDialog_ConnectCurrentChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(path string) {
				(*(*func(string))(signal))(path)
				f(path)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DisconnectCurrentChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QFileDialog) CurrentChanged(path string) {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		C.QFileDialog_CurrentChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: pathC, len: C.longlong(len(path))})
	}
}

//export callbackQFileDialog_CurrentUrlChanged
func callbackQFileDialog_CurrentUrlChanged(ptr unsafe.Pointer, url unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentUrlChanged"); signal != nil {
		(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(url))
	}

}

func (ptr *QFileDialog) ConnectCurrentUrlChanged(f func(url *core.QUrl)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentUrlChanged") {
			C.QFileDialog_ConnectCurrentUrlChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentUrlChanged"); signal != nil {
			f := func(url *core.QUrl) {
				(*(*func(*core.QUrl))(signal))(url)
				f(url)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentUrlChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentUrlChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectCurrentUrlChanged() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DisconnectCurrentUrlChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentUrlChanged")
	}
}

func (ptr *QFileDialog) CurrentUrlChanged(url core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog_CurrentUrlChanged(ptr.Pointer(), core.PointerFromQUrl(url))
	}
}

//export callbackQFileDialog_DirectoryEntered
func callbackQFileDialog_DirectoryEntered(ptr unsafe.Pointer, directory C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "directoryEntered"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(directory))
	}

}

func (ptr *QFileDialog) ConnectDirectoryEntered(f func(directory string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "directoryEntered") {
			C.QFileDialog_ConnectDirectoryEntered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "directoryEntered"); signal != nil {
			f := func(directory string) {
				(*(*func(string))(signal))(directory)
				f(directory)
			}
			qt.ConnectSignal(ptr.Pointer(), "directoryEntered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "directoryEntered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectDirectoryEntered() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DisconnectDirectoryEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "directoryEntered")
	}
}

func (ptr *QFileDialog) DirectoryEntered(directory string) {
	if ptr.Pointer() != nil {
		var directoryC *C.char
		if directory != "" {
			directoryC = C.CString(directory)
			defer C.free(unsafe.Pointer(directoryC))
		}
		C.QFileDialog_DirectoryEntered(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: directoryC, len: C.longlong(len(directory))})
	}
}

//export callbackQFileDialog_DirectoryUrlEntered
func callbackQFileDialog_DirectoryUrlEntered(ptr unsafe.Pointer, directory unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "directoryUrlEntered"); signal != nil {
		(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(directory))
	}

}

func (ptr *QFileDialog) ConnectDirectoryUrlEntered(f func(directory *core.QUrl)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "directoryUrlEntered") {
			C.QFileDialog_ConnectDirectoryUrlEntered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "directoryUrlEntered"); signal != nil {
			f := func(directory *core.QUrl) {
				(*(*func(*core.QUrl))(signal))(directory)
				f(directory)
			}
			qt.ConnectSignal(ptr.Pointer(), "directoryUrlEntered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "directoryUrlEntered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectDirectoryUrlEntered() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DisconnectDirectoryUrlEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "directoryUrlEntered")
	}
}

func (ptr *QFileDialog) DirectoryUrlEntered(directory core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog_DirectoryUrlEntered(ptr.Pointer(), core.PointerFromQUrl(directory))
	}
}

//export callbackQFileDialog_Done
func callbackQFileDialog_Done(ptr unsafe.Pointer, result C.int) {
	if signal := qt.GetSignal(ptr, "done"); signal != nil {
		(*(*func(int))(signal))(int(int32(result)))
	} else {
		NewQFileDialogFromPointer(ptr).DoneDefault(int(int32(result)))
	}
}

func (ptr *QFileDialog) ConnectDone(f func(result int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "done"); signal != nil {
			f := func(result int) {
				(*(*func(int))(signal))(result)
				f(result)
			}
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectDone() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "done")
	}
}

func (ptr *QFileDialog) Done(result int) {
	if ptr.Pointer() != nil {
		C.QFileDialog_Done(ptr.Pointer(), C.int(int32(result)))
	}
}

func (ptr *QFileDialog) DoneDefault(result int) {
	if ptr.Pointer() != nil {
		C.QFileDialog_DoneDefault(ptr.Pointer(), C.int(int32(result)))
	}
}

//export callbackQFileDialog_FileSelected
func callbackQFileDialog_FileSelected(ptr unsafe.Pointer, file C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "fileSelected"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(file))
	}

}

func (ptr *QFileDialog) ConnectFileSelected(f func(file string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "fileSelected") {
			C.QFileDialog_ConnectFileSelected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "fileSelected"); signal != nil {
			f := func(file string) {
				(*(*func(string))(signal))(file)
				f(file)
			}
			qt.ConnectSignal(ptr.Pointer(), "fileSelected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "fileSelected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectFileSelected() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DisconnectFileSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "fileSelected")
	}
}

func (ptr *QFileDialog) FileSelected(file string) {
	if ptr.Pointer() != nil {
		var fileC *C.char
		if file != "" {
			fileC = C.CString(file)
			defer C.free(unsafe.Pointer(fileC))
		}
		C.QFileDialog_FileSelected(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: fileC, len: C.longlong(len(file))})
	}
}

//export callbackQFileDialog_FilesSelected
func callbackQFileDialog_FilesSelected(ptr unsafe.Pointer, selected C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "filesSelected"); signal != nil {
		(*(*func([]string))(signal))(strings.Split(cGoUnpackString(selected), "|"))
	}

}

func (ptr *QFileDialog) ConnectFilesSelected(f func(selected []string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "filesSelected") {
			C.QFileDialog_ConnectFilesSelected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "filesSelected"); signal != nil {
			f := func(selected []string) {
				(*(*func([]string))(signal))(selected)
				f(selected)
			}
			qt.ConnectSignal(ptr.Pointer(), "filesSelected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "filesSelected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectFilesSelected() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DisconnectFilesSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "filesSelected")
	}
}

func (ptr *QFileDialog) FilesSelected(selected []string) {
	if ptr.Pointer() != nil {
		selectedC := C.CString(strings.Join(selected, "|"))
		defer C.free(unsafe.Pointer(selectedC))
		C.QFileDialog_FilesSelected(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: selectedC, len: C.longlong(len(strings.Join(selected, "|")))})
	}
}

//export callbackQFileDialog_FilterSelected
func callbackQFileDialog_FilterSelected(ptr unsafe.Pointer, filter C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "filterSelected"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(filter))
	}

}

func (ptr *QFileDialog) ConnectFilterSelected(f func(filter string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "filterSelected") {
			C.QFileDialog_ConnectFilterSelected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "filterSelected"); signal != nil {
			f := func(filter string) {
				(*(*func(string))(signal))(filter)
				f(filter)
			}
			qt.ConnectSignal(ptr.Pointer(), "filterSelected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "filterSelected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectFilterSelected() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DisconnectFilterSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "filterSelected")
	}
}

func (ptr *QFileDialog) FilterSelected(filter string) {
	if ptr.Pointer() != nil {
		var filterC *C.char
		if filter != "" {
			filterC = C.CString(filter)
			defer C.free(unsafe.Pointer(filterC))
		}
		C.QFileDialog_FilterSelected(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))})
	}
}

func (ptr *QFileDialog) Open(receiver core.QObject_ITF, member string) {
	if ptr.Pointer() != nil {
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		C.QFileDialog_Open(ptr.Pointer(), core.PointerFromQObject(receiver), memberC)
	}
}

func (ptr *QFileDialog) SelectFile(filename string) {
	if ptr.Pointer() != nil {
		var filenameC *C.char
		if filename != "" {
			filenameC = C.CString(filename)
			defer C.free(unsafe.Pointer(filenameC))
		}
		C.QFileDialog_SelectFile(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filenameC, len: C.longlong(len(filename))})
	}
}

func (ptr *QFileDialog) SelectMimeTypeFilter(filter string) {
	if ptr.Pointer() != nil {
		var filterC *C.char
		if filter != "" {
			filterC = C.CString(filter)
			defer C.free(unsafe.Pointer(filterC))
		}
		C.QFileDialog_SelectMimeTypeFilter(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))})
	}
}

func (ptr *QFileDialog) SelectNameFilter(filter string) {
	if ptr.Pointer() != nil {
		var filterC *C.char
		if filter != "" {
			filterC = C.CString(filter)
			defer C.free(unsafe.Pointer(filterC))
		}
		C.QFileDialog_SelectNameFilter(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))})
	}
}

func (ptr *QFileDialog) SelectUrl(url core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SelectUrl(ptr.Pointer(), core.PointerFromQUrl(url))
	}
}

func (ptr *QFileDialog) SetAcceptMode(mode QFileDialog__AcceptMode) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetAcceptMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QFileDialog) SetConfirmOverwrite(enabled bool) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetConfirmOverwrite(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QFileDialog) SetDefaultSuffix(suffix string) {
	if ptr.Pointer() != nil {
		var suffixC *C.char
		if suffix != "" {
			suffixC = C.CString(suffix)
			defer C.free(unsafe.Pointer(suffixC))
		}
		C.QFileDialog_SetDefaultSuffix(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: suffixC, len: C.longlong(len(suffix))})
	}
}

func (ptr *QFileDialog) SetDirectory2(directory core.QDir_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetDirectory2(ptr.Pointer(), core.PointerFromQDir(directory))
	}
}

func (ptr *QFileDialog) SetDirectory(directory string) {
	if ptr.Pointer() != nil {
		var directoryC *C.char
		if directory != "" {
			directoryC = C.CString(directory)
			defer C.free(unsafe.Pointer(directoryC))
		}
		C.QFileDialog_SetDirectory(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: directoryC, len: C.longlong(len(directory))})
	}
}

func (ptr *QFileDialog) SetDirectoryUrl(directory core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetDirectoryUrl(ptr.Pointer(), core.PointerFromQUrl(directory))
	}
}

func (ptr *QFileDialog) SetFileMode(mode QFileDialog__FileMode) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetFileMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QFileDialog) SetFilter(filters core.QDir__Filter) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetFilter(ptr.Pointer(), C.longlong(filters))
	}
}

func (ptr *QFileDialog) SetHistory(paths []string) {
	if ptr.Pointer() != nil {
		pathsC := C.CString(strings.Join(paths, "|"))
		defer C.free(unsafe.Pointer(pathsC))
		C.QFileDialog_SetHistory(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "|")))})
	}
}

func (ptr *QFileDialog) SetIconProvider(provider QFileIconProvider_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetIconProvider(ptr.Pointer(), PointerFromQFileIconProvider(provider))
	}
}

func (ptr *QFileDialog) SetItemDelegate(delegate QAbstractItemDelegate_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetItemDelegate(ptr.Pointer(), PointerFromQAbstractItemDelegate(delegate))
	}
}

func (ptr *QFileDialog) SetLabelText(label QFileDialog__DialogLabel, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QFileDialog_SetLabelText(ptr.Pointer(), C.longlong(label), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QFileDialog) SetMimeTypeFilters(filters []string) {
	if ptr.Pointer() != nil {
		filtersC := C.CString(strings.Join(filters, "|"))
		defer C.free(unsafe.Pointer(filtersC))
		C.QFileDialog_SetMimeTypeFilters(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filtersC, len: C.longlong(len(strings.Join(filters, "|")))})
	}
}

func (ptr *QFileDialog) SetNameFilter(filter string) {
	if ptr.Pointer() != nil {
		var filterC *C.char
		if filter != "" {
			filterC = C.CString(filter)
			defer C.free(unsafe.Pointer(filterC))
		}
		C.QFileDialog_SetNameFilter(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filterC, len: C.longlong(len(filter))})
	}
}

func (ptr *QFileDialog) SetNameFilterDetailsVisible(enabled bool) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetNameFilterDetailsVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QFileDialog) SetNameFilters(filters []string) {
	if ptr.Pointer() != nil {
		filtersC := C.CString(strings.Join(filters, "|"))
		defer C.free(unsafe.Pointer(filtersC))
		C.QFileDialog_SetNameFilters(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filtersC, len: C.longlong(len(strings.Join(filters, "|")))})
	}
}

func (ptr *QFileDialog) SetOption(option QFileDialog__Option, on bool) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetOption(ptr.Pointer(), C.longlong(option), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QFileDialog) SetOptions(options QFileDialog__Option) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetOptions(ptr.Pointer(), C.longlong(options))
	}
}

func (ptr *QFileDialog) SetProxyModel(proxyModel core.QAbstractProxyModel_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetProxyModel(ptr.Pointer(), core.PointerFromQAbstractProxyModel(proxyModel))
	}
}

func (ptr *QFileDialog) SetReadOnly(enabled bool) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetReadOnly(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QFileDialog) SetResolveSymlinks(enabled bool) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetResolveSymlinks(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QFileDialog) SetSidebarUrls(urls []*core.QUrl) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetSidebarUrls(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQFileDialogFromPointer(NewQFileDialogFromPointer(nil).__setSidebarUrls_urls_newList())
			for _, v := range urls {
				tmpList.__setSidebarUrls_urls_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QFileDialog) SetSupportedSchemes(schemes []string) {
	if ptr.Pointer() != nil {
		schemesC := C.CString(strings.Join(schemes, "|"))
		defer C.free(unsafe.Pointer(schemesC))
		C.QFileDialog_SetSupportedSchemes(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: schemesC, len: C.longlong(len(strings.Join(schemes, "|")))})
	}
}

func (ptr *QFileDialog) SetViewMode(mode QFileDialog__ViewMode) {
	if ptr.Pointer() != nil {
		C.QFileDialog_SetViewMode(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQFileDialog_UrlSelected
func callbackQFileDialog_UrlSelected(ptr unsafe.Pointer, url unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "urlSelected"); signal != nil {
		(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(url))
	}

}

func (ptr *QFileDialog) ConnectUrlSelected(f func(url *core.QUrl)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "urlSelected") {
			C.QFileDialog_ConnectUrlSelected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "urlSelected"); signal != nil {
			f := func(url *core.QUrl) {
				(*(*func(*core.QUrl))(signal))(url)
				f(url)
			}
			qt.ConnectSignal(ptr.Pointer(), "urlSelected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "urlSelected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectUrlSelected() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DisconnectUrlSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "urlSelected")
	}
}

func (ptr *QFileDialog) UrlSelected(url core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog_UrlSelected(ptr.Pointer(), core.PointerFromQUrl(url))
	}
}

//export callbackQFileDialog_UrlsSelected
func callbackQFileDialog_UrlsSelected(ptr unsafe.Pointer, urls C.struct_QtWidgets_PackedList) {
	if signal := qt.GetSignal(ptr, "urlsSelected"); signal != nil {
		(*(*func([]*core.QUrl))(signal))(func(l C.struct_QtWidgets_PackedList) []*core.QUrl {
			out := make([]*core.QUrl, int(l.len))
			tmpList := NewQFileDialogFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__urlsSelected_urls_atList(i)
			}
			return out
		}(urls))
	}

}

func (ptr *QFileDialog) ConnectUrlsSelected(f func(urls []*core.QUrl)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "urlsSelected") {
			C.QFileDialog_ConnectUrlsSelected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "urlsSelected"); signal != nil {
			f := func(urls []*core.QUrl) {
				(*(*func([]*core.QUrl))(signal))(urls)
				f(urls)
			}
			qt.ConnectSignal(ptr.Pointer(), "urlsSelected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "urlsSelected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectUrlsSelected() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DisconnectUrlsSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "urlsSelected")
	}
}

func (ptr *QFileDialog) UrlsSelected(urls []*core.QUrl) {
	if ptr.Pointer() != nil {
		C.QFileDialog_UrlsSelected(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQFileDialogFromPointer(NewQFileDialogFromPointer(nil).__urlsSelected_urls_newList())
			for _, v := range urls {
				tmpList.__urlsSelected_urls_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQFileDialog_DestroyQFileDialog
func callbackQFileDialog_DestroyQFileDialog(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFileDialog"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileDialogFromPointer(ptr).DestroyQFileDialogDefault()
	}
}

func (ptr *QFileDialog) ConnectDestroyQFileDialog(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFileDialog"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFileDialog", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFileDialog", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileDialog) DisconnectDestroyQFileDialog() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFileDialog")
	}
}

func (ptr *QFileDialog) DestroyQFileDialog() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DestroyQFileDialog(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFileDialog) DestroyQFileDialogDefault() {
	if ptr.Pointer() != nil {
		C.QFileDialog_DestroyQFileDialogDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFileDialog) ItemDelegate() *QAbstractItemDelegate {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractItemDelegateFromPointer(C.QFileDialog_ItemDelegate(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) ProxyModel() *core.QAbstractProxyModel {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractProxyModelFromPointer(C.QFileDialog_ProxyModel(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) SaveState() *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QFileDialog_SaveState(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) Directory() *core.QDir {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDirFromPointer(C.QFileDialog_Directory(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDir).DestroyQDir)
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) Filter() core.QDir__Filter {
	if ptr.Pointer() != nil {
		return core.QDir__Filter(C.QFileDialog_Filter(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDialog) AcceptMode() QFileDialog__AcceptMode {
	if ptr.Pointer() != nil {
		return QFileDialog__AcceptMode(C.QFileDialog_AcceptMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDialog) FileMode() QFileDialog__FileMode {
	if ptr.Pointer() != nil {
		return QFileDialog__FileMode(C.QFileDialog_FileMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDialog) Options() QFileDialog__Option {
	if ptr.Pointer() != nil {
		return QFileDialog__Option(C.QFileDialog_Options(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDialog) ViewMode() QFileDialog__ViewMode {
	if ptr.Pointer() != nil {
		return QFileDialog__ViewMode(C.QFileDialog_ViewMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileDialog) IconProvider() *QFileIconProvider {
	if ptr.Pointer() != nil {
		return NewQFileIconProviderFromPointer(C.QFileDialog_IconProvider(ptr.Pointer()))
	}
	return nil
}

func (ptr *QFileDialog) SelectedUrls() []*core.QUrl {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*core.QUrl {
			out := make([]*core.QUrl, int(l.len))
			tmpList := NewQFileDialogFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedUrls_atList(i)
			}
			return out
		}(C.QFileDialog_SelectedUrls(ptr.Pointer()))
	}
	return make([]*core.QUrl, 0)
}

func (ptr *QFileDialog) SidebarUrls() []*core.QUrl {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*core.QUrl {
			out := make([]*core.QUrl, int(l.len))
			tmpList := NewQFileDialogFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__sidebarUrls_atList(i)
			}
			return out
		}(C.QFileDialog_SidebarUrls(ptr.Pointer()))
	}
	return make([]*core.QUrl, 0)
}

func (ptr *QFileDialog) DefaultSuffix() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileDialog_DefaultSuffix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileDialog) LabelText(label QFileDialog__DialogLabel) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileDialog_LabelText(ptr.Pointer(), C.longlong(label)))
	}
	return ""
}

func (ptr *QFileDialog) SelectedMimeTypeFilter() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileDialog_SelectedMimeTypeFilter(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileDialog) SelectedNameFilter() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileDialog_SelectedNameFilter(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileDialog) History() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QFileDialog_History(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileDialog) MimeTypeFilters() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QFileDialog_MimeTypeFilters(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileDialog) NameFilters() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QFileDialog_NameFilters(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileDialog) SelectedFiles() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QFileDialog_SelectedFiles(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileDialog) SupportedSchemes() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QFileDialog_SupportedSchemes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileDialog) DirectoryUrl() *core.QUrl {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQUrlFromPointer(C.QFileDialog_DirectoryUrl(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) ConfirmOverwrite() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDialog_ConfirmOverwrite(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileDialog) IsNameFilterDetailsVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDialog_IsNameFilterDetailsVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileDialog) IsReadOnly() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDialog_IsReadOnly(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileDialog) ResolveSymlinks() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDialog_ResolveSymlinks(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileDialog) TestOption(option QFileDialog__Option) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileDialog_TestOption(ptr.Pointer(), C.longlong(option))) != 0
	}
	return false
}

func (ptr *QFileDialog) __getOpenFileUrls_atList(i int) *core.QUrl {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQUrlFromPointer(C.QFileDialog___getOpenFileUrls_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) __getOpenFileUrls_setList(i core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog___getOpenFileUrls_setList(ptr.Pointer(), core.PointerFromQUrl(i))
	}
}

func (ptr *QFileDialog) __getOpenFileUrls_newList() unsafe.Pointer {
	return C.QFileDialog___getOpenFileUrls_newList(ptr.Pointer())
}

func (ptr *QFileDialog) __setSidebarUrls_urls_atList(i int) *core.QUrl {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQUrlFromPointer(C.QFileDialog___setSidebarUrls_urls_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) __setSidebarUrls_urls_setList(i core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog___setSidebarUrls_urls_setList(ptr.Pointer(), core.PointerFromQUrl(i))
	}
}

func (ptr *QFileDialog) __setSidebarUrls_urls_newList() unsafe.Pointer {
	return C.QFileDialog___setSidebarUrls_urls_newList(ptr.Pointer())
}

func (ptr *QFileDialog) __urlsSelected_urls_atList(i int) *core.QUrl {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQUrlFromPointer(C.QFileDialog___urlsSelected_urls_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) __urlsSelected_urls_setList(i core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog___urlsSelected_urls_setList(ptr.Pointer(), core.PointerFromQUrl(i))
	}
}

func (ptr *QFileDialog) __urlsSelected_urls_newList() unsafe.Pointer {
	return C.QFileDialog___urlsSelected_urls_newList(ptr.Pointer())
}

func (ptr *QFileDialog) __selectedUrls_atList(i int) *core.QUrl {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQUrlFromPointer(C.QFileDialog___selectedUrls_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) __selectedUrls_setList(i core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog___selectedUrls_setList(ptr.Pointer(), core.PointerFromQUrl(i))
	}
}

func (ptr *QFileDialog) __selectedUrls_newList() unsafe.Pointer {
	return C.QFileDialog___selectedUrls_newList(ptr.Pointer())
}

func (ptr *QFileDialog) __sidebarUrls_atList(i int) *core.QUrl {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQUrlFromPointer(C.QFileDialog___sidebarUrls_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QFileDialog) __sidebarUrls_setList(i core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QFileDialog___sidebarUrls_setList(ptr.Pointer(), core.PointerFromQUrl(i))
	}
}

func (ptr *QFileDialog) __sidebarUrls_newList() unsafe.Pointer {
	return C.QFileDialog___sidebarUrls_newList(ptr.Pointer())
}

type QFileIconProvider struct {
	ptr unsafe.Pointer
}

type QFileIconProvider_ITF interface {
	QFileIconProvider_PTR() *QFileIconProvider
}

func (ptr *QFileIconProvider) QFileIconProvider_PTR() *QFileIconProvider {
	return ptr
}

func (ptr *QFileIconProvider) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QFileIconProvider) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQFileIconProvider(ptr QFileIconProvider_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileIconProvider_PTR().Pointer()
	}
	return nil
}

func NewQFileIconProviderFromPointer(ptr unsafe.Pointer) (n *QFileIconProvider) {
	n = new(QFileIconProvider)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QFileIconProvider__IconType
//QFileIconProvider::IconType
type QFileIconProvider__IconType int64

const (
	QFileIconProvider__Computer QFileIconProvider__IconType = QFileIconProvider__IconType(0)
	QFileIconProvider__Desktop  QFileIconProvider__IconType = QFileIconProvider__IconType(1)
	QFileIconProvider__Trashcan QFileIconProvider__IconType = QFileIconProvider__IconType(2)
	QFileIconProvider__Network  QFileIconProvider__IconType = QFileIconProvider__IconType(3)
	QFileIconProvider__Drive    QFileIconProvider__IconType = QFileIconProvider__IconType(4)
	QFileIconProvider__Folder   QFileIconProvider__IconType = QFileIconProvider__IconType(5)
	QFileIconProvider__File     QFileIconProvider__IconType = QFileIconProvider__IconType(6)
)

//go:generate stringer -type=QFileIconProvider__Option
//QFileIconProvider::Option
type QFileIconProvider__Option int64

const (
	QFileIconProvider__DontUseCustomDirectoryIcons QFileIconProvider__Option = QFileIconProvider__Option(0x00000001)
)

func NewQFileIconProvider() *QFileIconProvider {
	return NewQFileIconProviderFromPointer(C.QFileIconProvider_NewQFileIconProvider())
}

func (ptr *QFileIconProvider) SetOptions(options QFileIconProvider__Option) {
	if ptr.Pointer() != nil {
		C.QFileIconProvider_SetOptions(ptr.Pointer(), C.longlong(options))
	}
}

//export callbackQFileIconProvider_DestroyQFileIconProvider
func callbackQFileIconProvider_DestroyQFileIconProvider(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFileIconProvider"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileIconProviderFromPointer(ptr).DestroyQFileIconProviderDefault()
	}
}

func (ptr *QFileIconProvider) ConnectDestroyQFileIconProvider(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFileIconProvider"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFileIconProvider", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFileIconProvider", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileIconProvider) DisconnectDestroyQFileIconProvider() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFileIconProvider")
	}
}

func (ptr *QFileIconProvider) DestroyQFileIconProvider() {
	if ptr.Pointer() != nil {
		C.QFileIconProvider_DestroyQFileIconProvider(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFileIconProvider) DestroyQFileIconProviderDefault() {
	if ptr.Pointer() != nil {
		C.QFileIconProvider_DestroyQFileIconProviderDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFileIconProvider) Options() QFileIconProvider__Option {
	if ptr.Pointer() != nil {
		return QFileIconProvider__Option(C.QFileIconProvider_Options(ptr.Pointer()))
	}
	return 0
}

//export callbackQFileIconProvider_Icon
func callbackQFileIconProvider_Icon(ptr unsafe.Pointer, ty C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "icon"); signal != nil {
		return gui.PointerFromQIcon((*(*func(QFileIconProvider__IconType) *gui.QIcon)(signal))(QFileIconProvider__IconType(ty)))
	}

	return gui.PointerFromQIcon(NewQFileIconProviderFromPointer(ptr).IconDefault(QFileIconProvider__IconType(ty)))
}

func (ptr *QFileIconProvider) ConnectIcon(f func(ty QFileIconProvider__IconType) *gui.QIcon) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "icon"); signal != nil {
			f := func(ty QFileIconProvider__IconType) *gui.QIcon {
				(*(*func(QFileIconProvider__IconType) *gui.QIcon)(signal))(ty)
				return f(ty)
			}
			qt.ConnectSignal(ptr.Pointer(), "icon", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "icon", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileIconProvider) DisconnectIcon() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "icon")
	}
}

func (ptr *QFileIconProvider) Icon(ty QFileIconProvider__IconType) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QFileIconProvider_Icon(ptr.Pointer(), C.longlong(ty)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QFileIconProvider) IconDefault(ty QFileIconProvider__IconType) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QFileIconProvider_IconDefault(ptr.Pointer(), C.longlong(ty)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

//export callbackQFileIconProvider_Icon2
func callbackQFileIconProvider_Icon2(ptr unsafe.Pointer, info unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "icon2"); signal != nil {
		return gui.PointerFromQIcon((*(*func(*core.QFileInfo) *gui.QIcon)(signal))(core.NewQFileInfoFromPointer(info)))
	}

	return gui.PointerFromQIcon(NewQFileIconProviderFromPointer(ptr).Icon2Default(core.NewQFileInfoFromPointer(info)))
}

func (ptr *QFileIconProvider) ConnectIcon2(f func(info *core.QFileInfo) *gui.QIcon) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "icon2"); signal != nil {
			f := func(info *core.QFileInfo) *gui.QIcon {
				(*(*func(*core.QFileInfo) *gui.QIcon)(signal))(info)
				return f(info)
			}
			qt.ConnectSignal(ptr.Pointer(), "icon2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "icon2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileIconProvider) DisconnectIcon2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "icon2")
	}
}

func (ptr *QFileIconProvider) Icon2(info core.QFileInfo_ITF) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QFileIconProvider_Icon2(ptr.Pointer(), core.PointerFromQFileInfo(info)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QFileIconProvider) Icon2Default(info core.QFileInfo_ITF) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QFileIconProvider_Icon2Default(ptr.Pointer(), core.PointerFromQFileInfo(info)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

//export callbackQFileIconProvider_Type
func callbackQFileIconProvider_Type(ptr unsafe.Pointer, info unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "type"); signal != nil {
		tempVal := (*(*func(*core.QFileInfo) string)(signal))(core.NewQFileInfoFromPointer(info))
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQFileIconProviderFromPointer(ptr).TypeDefault(core.NewQFileInfoFromPointer(info))
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QFileIconProvider) ConnectType(f func(info *core.QFileInfo) string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "type"); signal != nil {
			f := func(info *core.QFileInfo) string {
				(*(*func(*core.QFileInfo) string)(signal))(info)
				return f(info)
			}
			qt.ConnectSignal(ptr.Pointer(), "type", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "type", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileIconProvider) DisconnectType() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "type")
	}
}

func (ptr *QFileIconProvider) Type(info core.QFileInfo_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileIconProvider_Type(ptr.Pointer(), core.PointerFromQFileInfo(info)))
	}
	return ""
}

func (ptr *QFileIconProvider) TypeDefault(info core.QFileInfo_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileIconProvider_TypeDefault(ptr.Pointer(), core.PointerFromQFileInfo(info)))
	}
	return ""
}

type QFileSystemModel struct {
	core.QAbstractItemModel
}

type QFileSystemModel_ITF interface {
	core.QAbstractItemModel_ITF
	QFileSystemModel_PTR() *QFileSystemModel
}

func (ptr *QFileSystemModel) QFileSystemModel_PTR() *QFileSystemModel {
	return ptr
}

func (ptr *QFileSystemModel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemModel_PTR().Pointer()
	}
	return nil
}

func (ptr *QFileSystemModel) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractItemModel_PTR().SetPointer(p)
	}
}

func PointerFromQFileSystemModel(ptr QFileSystemModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileSystemModel_PTR().Pointer()
	}
	return nil
}

func NewQFileSystemModelFromPointer(ptr unsafe.Pointer) (n *QFileSystemModel) {
	n = new(QFileSystemModel)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QFileSystemModel__Roles
//QFileSystemModel::Roles
type QFileSystemModel__Roles int64

var (
	QFileSystemModel__FileIconRole    QFileSystemModel__Roles = QFileSystemModel__Roles(core.Qt__DecorationRole)
	QFileSystemModel__FilePathRole    QFileSystemModel__Roles = QFileSystemModel__Roles(C.QFileSystemModel_FilePathRole_Type())
	QFileSystemModel__FileNameRole    QFileSystemModel__Roles = QFileSystemModel__Roles(C.QFileSystemModel_FileNameRole_Type())
	QFileSystemModel__FilePermissions QFileSystemModel__Roles = QFileSystemModel__Roles(C.QFileSystemModel_FilePermissions_Type())
)

func NewQFileSystemModel(parent core.QObject_ITF) *QFileSystemModel {
	tmpValue := NewQFileSystemModelFromPointer(C.QFileSystemModel_NewQFileSystemModel(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QFileSystemModel) Mkdir(parent core.QModelIndex_ITF, name string) *core.QModelIndex {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel_Mkdir(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))}))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) SetRootPath(newPath string) *core.QModelIndex {
	if ptr.Pointer() != nil {
		var newPathC *C.char
		if newPath != "" {
			newPathC = C.CString(newPath)
			defer C.free(unsafe.Pointer(newPathC))
		}
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel_SetRootPath(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: newPathC, len: C.longlong(len(newPath))}))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func QFileSystemModel_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QFileSystemModel_QFileSystemModel_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QFileSystemModel) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QFileSystemModel_QFileSystemModel_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQFileSystemModel_DropMimeData
func callbackQFileSystemModel_DropMimeData(ptr unsafe.Pointer, data unsafe.Pointer, action C.longlong, row C.int, column C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "dropMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QMimeData, core.Qt__DropAction, int, int, *core.QModelIndex) bool)(signal))(core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action), int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).DropMimeDataDefault(core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action), int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QFileSystemModel) DropMimeDataDefault(data core.QMimeData_ITF, action core.Qt__DropAction, row int, column int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_DropMimeDataDefault(ptr.Pointer(), core.PointerFromQMimeData(data), C.longlong(action), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQFileSystemModel_Event
func callbackQFileSystemModel_Event(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).EventDefault(core.NewQEventFromPointer(event)))))
}

func (ptr *QFileSystemModel) EventDefault(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_EventDefault(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QFileSystemModel) Remove(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_Remove(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QFileSystemModel) Rmdir(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_Rmdir(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

//export callbackQFileSystemModel_SetData
func callbackQFileSystemModel_SetData(ptr unsafe.Pointer, idx unsafe.Pointer, value unsafe.Pointer, role C.int) C.char {
	if signal := qt.GetSignal(ptr, "setData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex, *core.QVariant, int) bool)(signal))(core.NewQModelIndexFromPointer(idx), core.NewQVariantFromPointer(value), int(int32(role))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).SetDataDefault(core.NewQModelIndexFromPointer(idx), core.NewQVariantFromPointer(value), int(int32(role))))))
}

func (ptr *QFileSystemModel) SetDataDefault(idx core.QModelIndex_ITF, value core.QVariant_ITF, role int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_SetDataDefault(ptr.Pointer(), core.PointerFromQModelIndex(idx), core.PointerFromQVariant(value), C.int(int32(role)))) != 0
	}
	return false
}

//export callbackQFileSystemModel_DirectoryLoaded
func callbackQFileSystemModel_DirectoryLoaded(ptr unsafe.Pointer, path C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "directoryLoaded"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(path))
	}

}

func (ptr *QFileSystemModel) ConnectDirectoryLoaded(f func(path string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "directoryLoaded") {
			C.QFileSystemModel_ConnectDirectoryLoaded(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "directoryLoaded"); signal != nil {
			f := func(path string) {
				(*(*func(string))(signal))(path)
				f(path)
			}
			qt.ConnectSignal(ptr.Pointer(), "directoryLoaded", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "directoryLoaded", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemModel) DisconnectDirectoryLoaded() {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_DisconnectDirectoryLoaded(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "directoryLoaded")
	}
}

func (ptr *QFileSystemModel) DirectoryLoaded(path string) {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		C.QFileSystemModel_DirectoryLoaded(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: pathC, len: C.longlong(len(path))})
	}
}

//export callbackQFileSystemModel_FetchMore
func callbackQFileSystemModel_FetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "fetchMore"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(parent))
	} else {
		NewQFileSystemModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
	}
}

func (ptr *QFileSystemModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
	}
}

//export callbackQFileSystemModel_FileRenamed
func callbackQFileSystemModel_FileRenamed(ptr unsafe.Pointer, path C.struct_QtWidgets_PackedString, oldName C.struct_QtWidgets_PackedString, newName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "fileRenamed"); signal != nil {
		(*(*func(string, string, string))(signal))(cGoUnpackString(path), cGoUnpackString(oldName), cGoUnpackString(newName))
	}

}

func (ptr *QFileSystemModel) ConnectFileRenamed(f func(path string, oldName string, newName string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "fileRenamed") {
			C.QFileSystemModel_ConnectFileRenamed(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "fileRenamed"); signal != nil {
			f := func(path string, oldName string, newName string) {
				(*(*func(string, string, string))(signal))(path, oldName, newName)
				f(path, oldName, newName)
			}
			qt.ConnectSignal(ptr.Pointer(), "fileRenamed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "fileRenamed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemModel) DisconnectFileRenamed() {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_DisconnectFileRenamed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "fileRenamed")
	}
}

func (ptr *QFileSystemModel) FileRenamed(path string, oldName string, newName string) {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		var oldNameC *C.char
		if oldName != "" {
			oldNameC = C.CString(oldName)
			defer C.free(unsafe.Pointer(oldNameC))
		}
		var newNameC *C.char
		if newName != "" {
			newNameC = C.CString(newName)
			defer C.free(unsafe.Pointer(newNameC))
		}
		C.QFileSystemModel_FileRenamed(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: pathC, len: C.longlong(len(path))}, C.struct_QtWidgets_PackedString{data: oldNameC, len: C.longlong(len(oldName))}, C.struct_QtWidgets_PackedString{data: newNameC, len: C.longlong(len(newName))})
	}
}

//export callbackQFileSystemModel_RootPathChanged
func callbackQFileSystemModel_RootPathChanged(ptr unsafe.Pointer, newPath C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "rootPathChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(newPath))
	}

}

func (ptr *QFileSystemModel) ConnectRootPathChanged(f func(newPath string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rootPathChanged") {
			C.QFileSystemModel_ConnectRootPathChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "rootPathChanged"); signal != nil {
			f := func(newPath string) {
				(*(*func(string))(signal))(newPath)
				f(newPath)
			}
			qt.ConnectSignal(ptr.Pointer(), "rootPathChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rootPathChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemModel) DisconnectRootPathChanged() {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_DisconnectRootPathChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rootPathChanged")
	}
}

func (ptr *QFileSystemModel) RootPathChanged(newPath string) {
	if ptr.Pointer() != nil {
		var newPathC *C.char
		if newPath != "" {
			newPathC = C.CString(newPath)
			defer C.free(unsafe.Pointer(newPathC))
		}
		C.QFileSystemModel_RootPathChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: newPathC, len: C.longlong(len(newPath))})
	}
}

func (ptr *QFileSystemModel) SetFilter(filters core.QDir__Filter) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_SetFilter(ptr.Pointer(), C.longlong(filters))
	}
}

func (ptr *QFileSystemModel) SetIconProvider(provider QFileIconProvider_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_SetIconProvider(ptr.Pointer(), PointerFromQFileIconProvider(provider))
	}
}

func (ptr *QFileSystemModel) SetNameFilterDisables(enable bool) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_SetNameFilterDisables(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QFileSystemModel) SetNameFilters(filters []string) {
	if ptr.Pointer() != nil {
		filtersC := C.CString(strings.Join(filters, "|"))
		defer C.free(unsafe.Pointer(filtersC))
		C.QFileSystemModel_SetNameFilters(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filtersC, len: C.longlong(len(strings.Join(filters, "|")))})
	}
}

func (ptr *QFileSystemModel) SetReadOnly(enable bool) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_SetReadOnly(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QFileSystemModel) SetResolveSymlinks(enable bool) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_SetResolveSymlinks(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQFileSystemModel_Sort
func callbackQFileSystemModel_Sort(ptr unsafe.Pointer, column C.int, order C.longlong) {
	if signal := qt.GetSignal(ptr, "sort"); signal != nil {
		(*(*func(int, core.Qt__SortOrder))(signal))(int(int32(column)), core.Qt__SortOrder(order))
	} else {
		NewQFileSystemModelFromPointer(ptr).SortDefault(int(int32(column)), core.Qt__SortOrder(order))
	}
}

func (ptr *QFileSystemModel) SortDefault(column int, order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_SortDefault(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
	}
}

//export callbackQFileSystemModel_TimerEvent
func callbackQFileSystemModel_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQFileSystemModelFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QFileSystemModel) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQFileSystemModel_DestroyQFileSystemModel
func callbackQFileSystemModel_DestroyQFileSystemModel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFileSystemModel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileSystemModelFromPointer(ptr).DestroyQFileSystemModelDefault()
	}
}

func (ptr *QFileSystemModel) ConnectDestroyQFileSystemModel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFileSystemModel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFileSystemModel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFileSystemModel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemModel) DisconnectDestroyQFileSystemModel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFileSystemModel")
	}
}

func (ptr *QFileSystemModel) DestroyQFileSystemModel() {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_DestroyQFileSystemModel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFileSystemModel) DestroyQFileSystemModelDefault() {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_DestroyQFileSystemModelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFileSystemModel) LastModified(index core.QModelIndex_ITF) *core.QDateTime {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDateTimeFromPointer(C.QFileSystemModel_LastModified(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QDateTime).DestroyQDateTime)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) RootDirectory() *core.QDir {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQDirFromPointer(C.QFileSystemModel_RootDirectory(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QDir).DestroyQDir)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) Filter() core.QDir__Filter {
	if ptr.Pointer() != nil {
		return core.QDir__Filter(C.QFileSystemModel_Filter(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFileSystemModel) IconProvider() *QFileIconProvider {
	if ptr.Pointer() != nil {
		return NewQFileIconProviderFromPointer(C.QFileSystemModel_IconProvider(ptr.Pointer()))
	}
	return nil
}

func (ptr *QFileSystemModel) FileInfo(index core.QModelIndex_ITF) *core.QFileInfo {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQFileInfoFromPointer(C.QFileSystemModel_FileInfo(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QFileInfo).DestroyQFileInfo)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) FileIcon(index core.QModelIndex_ITF) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QFileSystemModel_FileIcon(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

//export callbackQFileSystemModel_MimeData
func callbackQFileSystemModel_MimeData(ptr unsafe.Pointer, indexes C.struct_QtWidgets_PackedList) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mimeData"); signal != nil {
		return core.PointerFromQMimeData((*(*func([]*core.QModelIndex) *core.QMimeData)(signal))(func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
			out := make([]*core.QModelIndex, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__mimeData_indexes_atList(i)
			}
			return out
		}(indexes)))
	}

	return core.PointerFromQMimeData(NewQFileSystemModelFromPointer(ptr).MimeDataDefault(func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
		out := make([]*core.QModelIndex, int(l.len))
		tmpList := NewQFileSystemModelFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__mimeData_indexes_atList(i)
		}
		return out
	}(indexes)))
}

func (ptr *QFileSystemModel) MimeDataDefault(indexes []*core.QModelIndex) *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QFileSystemModel_MimeDataDefault(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQFileSystemModelFromPointer(NewQFileSystemModelFromPointer(nil).__mimeData_indexes_newList())
			for _, v := range indexes {
				tmpList.__mimeData_indexes_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) Index2(path string, column int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		var pathC *C.char
		if path != "" {
			pathC = C.CString(path)
			defer C.free(unsafe.Pointer(pathC))
		}
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel_Index2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: pathC, len: C.longlong(len(path))}, C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQFileSystemModel_Index
func callbackQFileSystemModel_Index(ptr unsafe.Pointer, row C.int, column C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "index"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(int, int, *core.QModelIndex) *core.QModelIndex)(signal))(int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))
	}

	return core.PointerFromQModelIndex(NewQFileSystemModelFromPointer(ptr).IndexDefault(int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))
}

func (ptr *QFileSystemModel) ConnectIndex(f func(row int, column int, parent *core.QModelIndex) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "index"); signal != nil {
			f := func(row int, column int, parent *core.QModelIndex) *core.QModelIndex {
				(*(*func(int, int, *core.QModelIndex) *core.QModelIndex)(signal))(row, column, parent)
				return f(row, column, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "index", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemModel) DisconnectIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "index")
	}
}

func (ptr *QFileSystemModel) Index(row int, column int, parent core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel_Index(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) IndexDefault(row int, column int, parent core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel_IndexDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(parent)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQFileSystemModel_Parent
func callbackQFileSystemModel_Parent(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "parent"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QModelIndex) *core.QModelIndex)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQModelIndex(NewQFileSystemModelFromPointer(ptr).ParentDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QFileSystemModel) ConnectParent(f func(index *core.QModelIndex) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "parent"); signal != nil {
			f := func(index *core.QModelIndex) *core.QModelIndex {
				(*(*func(*core.QModelIndex) *core.QModelIndex)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "parent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemModel) DisconnectParent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "parent")
	}
}

func (ptr *QFileSystemModel) Parent(index core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel_Parent(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) ParentDefault(index core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel_ParentDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQFileSystemModel_Sibling
func callbackQFileSystemModel_Sibling(ptr unsafe.Pointer, row C.int, column C.int, idx unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sibling"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(int, int, *core.QModelIndex) *core.QModelIndex)(signal))(int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(idx)))
	}

	return core.PointerFromQModelIndex(NewQFileSystemModelFromPointer(ptr).SiblingDefault(int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(idx)))
}

func (ptr *QFileSystemModel) SiblingDefault(row int, column int, idx core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel_SiblingDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(idx)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) FileName(index core.QModelIndex_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileSystemModel_FileName(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return ""
}

func (ptr *QFileSystemModel) FilePath(index core.QModelIndex_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileSystemModel_FilePath(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return ""
}

func (ptr *QFileSystemModel) RootPath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileSystemModel_RootPath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QFileSystemModel) Type(index core.QModelIndex_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QFileSystemModel_Type(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return ""
}

//export callbackQFileSystemModel_MimeTypes
func callbackQFileSystemModel_MimeTypes(ptr unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "mimeTypes"); signal != nil {
		tempVal := (*(*func() []string)(signal))()
		return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
	}
	tempVal := NewQFileSystemModelFromPointer(ptr).MimeTypesDefault()
	return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
}

func (ptr *QFileSystemModel) MimeTypesDefault() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QFileSystemModel_MimeTypesDefault(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QFileSystemModel) NameFilters() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QFileSystemModel_NameFilters(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

//export callbackQFileSystemModel_Data
func callbackQFileSystemModel_Data(ptr unsafe.Pointer, index unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return core.PointerFromQVariant((*(*func(*core.QModelIndex, int) *core.QVariant)(signal))(core.NewQModelIndexFromPointer(index), int(int32(role))))
	}

	return core.PointerFromQVariant(NewQFileSystemModelFromPointer(ptr).DataDefault(core.NewQModelIndexFromPointer(index), int(int32(role))))
}

func (ptr *QFileSystemModel) ConnectData(f func(index *core.QModelIndex, role int) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "data"); signal != nil {
			f := func(index *core.QModelIndex, role int) *core.QVariant {
				(*(*func(*core.QModelIndex, int) *core.QVariant)(signal))(index, role)
				return f(index, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemModel) DisconnectData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "data")
	}
}

func (ptr *QFileSystemModel) Data(index core.QModelIndex_ITF, role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QFileSystemModel_Data(ptr.Pointer(), core.PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) DataDefault(index core.QModelIndex_ITF, role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QFileSystemModel_DataDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQFileSystemModel_HeaderData
func callbackQFileSystemModel_HeaderData(ptr unsafe.Pointer, section C.int, orientation C.longlong, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "headerData"); signal != nil {
		return core.PointerFromQVariant((*(*func(int, core.Qt__Orientation, int) *core.QVariant)(signal))(int(int32(section)), core.Qt__Orientation(orientation), int(int32(role))))
	}

	return core.PointerFromQVariant(NewQFileSystemModelFromPointer(ptr).HeaderDataDefault(int(int32(section)), core.Qt__Orientation(orientation), int(int32(role))))
}

func (ptr *QFileSystemModel) HeaderDataDefault(section int, orientation core.Qt__Orientation, role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QFileSystemModel_HeaderDataDefault(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) MyComputer(role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QFileSystemModel_MyComputer(ptr.Pointer(), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQFileSystemModel_SupportedDropActions
func callbackQFileSystemModel_SupportedDropActions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "supportedDropActions"); signal != nil {
		return C.longlong((*(*func() core.Qt__DropAction)(signal))())
	}

	return C.longlong(NewQFileSystemModelFromPointer(ptr).SupportedDropActionsDefault())
}

func (ptr *QFileSystemModel) SupportedDropActionsDefault() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QFileSystemModel_SupportedDropActionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQFileSystemModel_Flags
func callbackQFileSystemModel_Flags(ptr unsafe.Pointer, index unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "flags"); signal != nil {
		return C.longlong((*(*func(*core.QModelIndex) core.Qt__ItemFlag)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return C.longlong(NewQFileSystemModelFromPointer(ptr).FlagsDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QFileSystemModel) FlagsDefault(index core.QModelIndex_ITF) core.Qt__ItemFlag {
	if ptr.Pointer() != nil {
		return core.Qt__ItemFlag(C.QFileSystemModel_FlagsDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return 0
}

//export callbackQFileSystemModel_CanFetchMore
func callbackQFileSystemModel_CanFetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "canFetchMore"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex) bool)(signal))(core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).CanFetchMoreDefault(core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QFileSystemModel) CanFetchMoreDefault(parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_CanFetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQFileSystemModel_HasChildren
func callbackQFileSystemModel_HasChildren(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "hasChildren"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex) bool)(signal))(core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).HasChildrenDefault(core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QFileSystemModel) HasChildrenDefault(parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_HasChildrenDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QFileSystemModel) IsDir(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_IsDir(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QFileSystemModel) IsReadOnly() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_IsReadOnly(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileSystemModel) NameFilterDisables() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_NameFilterDisables(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QFileSystemModel) ResolveSymlinks() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_ResolveSymlinks(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQFileSystemModel_MetaObject
func callbackQFileSystemModel_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQFileSystemModelFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QFileSystemModel) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QFileSystemModel_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQFileSystemModel_ColumnCount
func callbackQFileSystemModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "columnCount"); signal != nil {
		return C.int(int32((*(*func(*core.QModelIndex) int)(signal))(core.NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQFileSystemModelFromPointer(ptr).ColumnCountDefault(core.NewQModelIndexFromPointer(parent))))
}

func (ptr *QFileSystemModel) ConnectColumnCount(f func(parent *core.QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnCount"); signal != nil {
			f := func(parent *core.QModelIndex) int {
				(*(*func(*core.QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemModel) DisconnectColumnCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnCount")
	}
}

func (ptr *QFileSystemModel) ColumnCount(parent core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel_ColumnCount(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QFileSystemModel) ColumnCountDefault(parent core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel_ColumnCountDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
	}
	return 0
}

//export callbackQFileSystemModel_RowCount
func callbackQFileSystemModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "rowCount"); signal != nil {
		return C.int(int32((*(*func(*core.QModelIndex) int)(signal))(core.NewQModelIndexFromPointer(parent))))
	}

	return C.int(int32(NewQFileSystemModelFromPointer(ptr).RowCountDefault(core.NewQModelIndexFromPointer(parent))))
}

func (ptr *QFileSystemModel) ConnectRowCount(f func(parent *core.QModelIndex) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowCount"); signal != nil {
			f := func(parent *core.QModelIndex) int {
				(*(*func(*core.QModelIndex) int)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFileSystemModel) DisconnectRowCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowCount")
	}
}

func (ptr *QFileSystemModel) RowCount(parent core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel_RowCount(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QFileSystemModel) RowCountDefault(parent core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel_RowCountDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
	}
	return 0
}

func (ptr *QFileSystemModel) Size(index core.QModelIndex_ITF) int64 {
	if ptr.Pointer() != nil {
		return int64(C.QFileSystemModel_Size(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return 0
}

func (ptr *QFileSystemModel) __mimeData_indexes_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel___mimeData_indexes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __mimeData_indexes_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___mimeData_indexes_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QFileSystemModel) __mimeData_indexes_newList() unsafe.Pointer {
	return C.QFileSystemModel___mimeData_indexes_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __setItemData_roles_atList(v int, i int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QFileSystemModel___setItemData_roles_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __setItemData_roles_setList(key int, i core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___setItemData_roles_setList(ptr.Pointer(), C.int(int32(key)), core.PointerFromQVariant(i))
	}
}

func (ptr *QFileSystemModel) __setItemData_roles_newList() unsafe.Pointer {
	return C.QFileSystemModel___setItemData_roles_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __setItemData_roles_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____setItemData_roles_keyList_atList(i)
			}
			return out
		}(C.QFileSystemModel___setItemData_roles_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QFileSystemModel) __changePersistentIndexList_from_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel___changePersistentIndexList_from_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __changePersistentIndexList_from_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___changePersistentIndexList_from_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QFileSystemModel) __changePersistentIndexList_from_newList() unsafe.Pointer {
	return C.QFileSystemModel___changePersistentIndexList_from_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __changePersistentIndexList_to_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel___changePersistentIndexList_to_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __changePersistentIndexList_to_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___changePersistentIndexList_to_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QFileSystemModel) __changePersistentIndexList_to_newList() unsafe.Pointer {
	return C.QFileSystemModel___changePersistentIndexList_to_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __dataChanged_roles_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel___dataChanged_roles_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QFileSystemModel) __dataChanged_roles_setList(i int) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___dataChanged_roles_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QFileSystemModel) __dataChanged_roles_newList() unsafe.Pointer {
	return C.QFileSystemModel___dataChanged_roles_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __layoutAboutToBeChanged_parents_atList(i int) *core.QPersistentModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPersistentModelIndexFromPointer(C.QFileSystemModel___layoutAboutToBeChanged_parents_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QPersistentModelIndex).DestroyQPersistentModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __layoutAboutToBeChanged_parents_setList(i core.QPersistentModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___layoutAboutToBeChanged_parents_setList(ptr.Pointer(), core.PointerFromQPersistentModelIndex(i))
	}
}

func (ptr *QFileSystemModel) __layoutAboutToBeChanged_parents_newList() unsafe.Pointer {
	return C.QFileSystemModel___layoutAboutToBeChanged_parents_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __layoutChanged_parents_atList(i int) *core.QPersistentModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPersistentModelIndexFromPointer(C.QFileSystemModel___layoutChanged_parents_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QPersistentModelIndex).DestroyQPersistentModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __layoutChanged_parents_setList(i core.QPersistentModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___layoutChanged_parents_setList(ptr.Pointer(), core.PointerFromQPersistentModelIndex(i))
	}
}

func (ptr *QFileSystemModel) __layoutChanged_parents_newList() unsafe.Pointer {
	return C.QFileSystemModel___layoutChanged_parents_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __roleNames_atList(v int, i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QFileSystemModel___roleNames_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __roleNames_setList(key int, i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___roleNames_setList(ptr.Pointer(), C.int(int32(key)), core.PointerFromQByteArray(i))
	}
}

func (ptr *QFileSystemModel) __roleNames_newList() unsafe.Pointer {
	return C.QFileSystemModel___roleNames_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __roleNames_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____roleNames_keyList_atList(i)
			}
			return out
		}(C.QFileSystemModel___roleNames_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QFileSystemModel) __itemData_atList(v int, i int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QFileSystemModel___itemData_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __itemData_setList(key int, i core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___itemData_setList(ptr.Pointer(), C.int(int32(key)), core.PointerFromQVariant(i))
	}
}

func (ptr *QFileSystemModel) __itemData_newList() unsafe.Pointer {
	return C.QFileSystemModel___itemData_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __itemData_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____itemData_keyList_atList(i)
			}
			return out
		}(C.QFileSystemModel___itemData_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QFileSystemModel) __match_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel___match_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __match_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___match_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QFileSystemModel) __match_newList() unsafe.Pointer {
	return C.QFileSystemModel___match_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __persistentIndexList_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel___persistentIndexList_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __persistentIndexList_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___persistentIndexList_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QFileSystemModel) __persistentIndexList_newList() unsafe.Pointer {
	return C.QFileSystemModel___persistentIndexList_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) ____setItemData_roles_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel_____setItemData_roles_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QFileSystemModel) ____setItemData_roles_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_____setItemData_roles_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QFileSystemModel) ____setItemData_roles_keyList_newList() unsafe.Pointer {
	return C.QFileSystemModel_____setItemData_roles_keyList_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) ____doSetRoleNames_roleNames_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel_____doSetRoleNames_roleNames_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QFileSystemModel) ____doSetRoleNames_roleNames_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_____doSetRoleNames_roleNames_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QFileSystemModel) ____doSetRoleNames_roleNames_keyList_newList() unsafe.Pointer {
	return C.QFileSystemModel_____doSetRoleNames_roleNames_keyList_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) ____setRoleNames_roleNames_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel_____setRoleNames_roleNames_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QFileSystemModel) ____setRoleNames_roleNames_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_____setRoleNames_roleNames_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QFileSystemModel) ____setRoleNames_roleNames_keyList_newList() unsafe.Pointer {
	return C.QFileSystemModel_____setRoleNames_roleNames_keyList_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) ____roleNames_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel_____roleNames_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QFileSystemModel) ____roleNames_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_____roleNames_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QFileSystemModel) ____roleNames_keyList_newList() unsafe.Pointer {
	return C.QFileSystemModel_____roleNames_keyList_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) ____itemData_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFileSystemModel_____itemData_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QFileSystemModel) ____itemData_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_____itemData_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QFileSystemModel) ____itemData_keyList_newList() unsafe.Pointer {
	return C.QFileSystemModel_____itemData_keyList_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QFileSystemModel___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QFileSystemModel) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QFileSystemModel___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QFileSystemModel___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QFileSystemModel) __findChildren_newList2() unsafe.Pointer {
	return C.QFileSystemModel___findChildren_newList2(ptr.Pointer())
}

func (ptr *QFileSystemModel) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QFileSystemModel___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QFileSystemModel) __findChildren_newList3() unsafe.Pointer {
	return C.QFileSystemModel___findChildren_newList3(ptr.Pointer())
}

func (ptr *QFileSystemModel) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QFileSystemModel___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QFileSystemModel) __findChildren_newList() unsafe.Pointer {
	return C.QFileSystemModel___findChildren_newList(ptr.Pointer())
}

func (ptr *QFileSystemModel) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QFileSystemModel___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFileSystemModel) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QFileSystemModel) __children_newList() unsafe.Pointer {
	return C.QFileSystemModel___children_newList(ptr.Pointer())
}

//export callbackQFileSystemModel_InsertColumns
func callbackQFileSystemModel_InsertColumns(ptr unsafe.Pointer, column C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "insertColumns"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *core.QModelIndex) bool)(signal))(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).InsertColumnsDefault(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QFileSystemModel) InsertColumnsDefault(column int, count int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_InsertColumnsDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQFileSystemModel_InsertRows
func callbackQFileSystemModel_InsertRows(ptr unsafe.Pointer, row C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "insertRows"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *core.QModelIndex) bool)(signal))(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).InsertRowsDefault(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QFileSystemModel) InsertRowsDefault(row int, count int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_InsertRowsDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQFileSystemModel_MoveColumns
func callbackQFileSystemModel_MoveColumns(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceColumn C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.char {
	if signal := qt.GetSignal(ptr, "moveColumns"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int) bool)(signal))(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceColumn)), int(int32(count)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).MoveColumnsDefault(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceColumn)), int(int32(count)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
}

func (ptr *QFileSystemModel) MoveColumnsDefault(sourceParent core.QModelIndex_ITF, sourceColumn int, count int, destinationParent core.QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_MoveColumnsDefault(ptr.Pointer(), core.PointerFromQModelIndex(sourceParent), C.int(int32(sourceColumn)), C.int(int32(count)), core.PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

//export callbackQFileSystemModel_MoveRows
func callbackQFileSystemModel_MoveRows(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceRow C.int, count C.int, destinationParent unsafe.Pointer, destinationChild C.int) C.char {
	if signal := qt.GetSignal(ptr, "moveRows"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int) bool)(signal))(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceRow)), int(int32(count)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).MoveRowsDefault(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceRow)), int(int32(count)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationChild))))))
}

func (ptr *QFileSystemModel) MoveRowsDefault(sourceParent core.QModelIndex_ITF, sourceRow int, count int, destinationParent core.QModelIndex_ITF, destinationChild int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_MoveRowsDefault(ptr.Pointer(), core.PointerFromQModelIndex(sourceParent), C.int(int32(sourceRow)), C.int(int32(count)), core.PointerFromQModelIndex(destinationParent), C.int(int32(destinationChild)))) != 0
	}
	return false
}

//export callbackQFileSystemModel_RemoveColumns
func callbackQFileSystemModel_RemoveColumns(ptr unsafe.Pointer, column C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "removeColumns"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *core.QModelIndex) bool)(signal))(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).RemoveColumnsDefault(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QFileSystemModel) RemoveColumnsDefault(column int, count int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_RemoveColumnsDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQFileSystemModel_RemoveRows
func callbackQFileSystemModel_RemoveRows(ptr unsafe.Pointer, row C.int, count C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "removeRows"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *core.QModelIndex) bool)(signal))(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).RemoveRowsDefault(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QFileSystemModel) RemoveRowsDefault(row int, count int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_RemoveRowsDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQFileSystemModel_SetHeaderData
func callbackQFileSystemModel_SetHeaderData(ptr unsafe.Pointer, section C.int, orientation C.longlong, value unsafe.Pointer, role C.int) C.char {
	if signal := qt.GetSignal(ptr, "setHeaderData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, core.Qt__Orientation, *core.QVariant, int) bool)(signal))(int(int32(section)), core.Qt__Orientation(orientation), core.NewQVariantFromPointer(value), int(int32(role))))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).SetHeaderDataDefault(int(int32(section)), core.Qt__Orientation(orientation), core.NewQVariantFromPointer(value), int(int32(role))))))
}

func (ptr *QFileSystemModel) SetHeaderDataDefault(section int, orientation core.Qt__Orientation, value core.QVariant_ITF, role int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_SetHeaderDataDefault(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), core.PointerFromQVariant(value), C.int(int32(role)))) != 0
	}
	return false
}

//export callbackQFileSystemModel_SetItemData
func callbackQFileSystemModel_SetItemData(ptr unsafe.Pointer, index unsafe.Pointer, roles C.struct_QtWidgets_PackedList) C.char {
	if signal := qt.GetSignal(ptr, "setItemData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex, map[int]*core.QVariant) bool)(signal))(core.NewQModelIndexFromPointer(index), func(l C.struct_QtWidgets_PackedList) map[int]*core.QVariant {
			out := make(map[int]*core.QVariant, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i, v := range tmpList.__setItemData_roles_keyList() {
				out[v] = tmpList.__setItemData_roles_atList(v, i)
			}
			return out
		}(roles)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).SetItemDataDefault(core.NewQModelIndexFromPointer(index), func(l C.struct_QtWidgets_PackedList) map[int]*core.QVariant {
		out := make(map[int]*core.QVariant, int(l.len))
		tmpList := NewQFileSystemModelFromPointer(l.data)
		for i, v := range tmpList.__setItemData_roles_keyList() {
			out[v] = tmpList.__setItemData_roles_atList(v, i)
		}
		return out
	}(roles)))))
}

func (ptr *QFileSystemModel) SetItemDataDefault(index core.QModelIndex_ITF, roles map[int]*core.QVariant) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_SetItemDataDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), func() unsafe.Pointer {
			tmpList := NewQFileSystemModelFromPointer(NewQFileSystemModelFromPointer(nil).__setItemData_roles_newList())
			for k, v := range roles {
				tmpList.__setItemData_roles_setList(k, v)
			}
			return tmpList.Pointer()
		}())) != 0
	}
	return false
}

//export callbackQFileSystemModel_Submit
func callbackQFileSystemModel_Submit(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "submit"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).SubmitDefault())))
}

func (ptr *QFileSystemModel) SubmitDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_SubmitDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQFileSystemModel_ColumnsAboutToBeInserted
func callbackQFileSystemModel_ColumnsAboutToBeInserted(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsAboutToBeInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQFileSystemModel_ColumnsAboutToBeMoved
func callbackQFileSystemModel_ColumnsAboutToBeMoved(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationColumn C.int) {
	if signal := qt.GetSignal(ptr, "columnsAboutToBeMoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int))(signal))(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceStart)), int(int32(sourceEnd)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationColumn)))
	}

}

//export callbackQFileSystemModel_ColumnsAboutToBeRemoved
func callbackQFileSystemModel_ColumnsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsAboutToBeRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQFileSystemModel_ColumnsInserted
func callbackQFileSystemModel_ColumnsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQFileSystemModel_ColumnsMoved
func callbackQFileSystemModel_ColumnsMoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "columnsMoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)), core.NewQModelIndexFromPointer(destination), int(int32(column)))
	}

}

//export callbackQFileSystemModel_ColumnsRemoved
func callbackQFileSystemModel_ColumnsRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "columnsRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQFileSystemModel_DataChanged
func callbackQFileSystemModel_DataChanged(ptr unsafe.Pointer, topLeft unsafe.Pointer, bottomRight unsafe.Pointer, roles C.struct_QtWidgets_PackedList) {
	if signal := qt.GetSignal(ptr, "dataChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex, []int))(signal))(core.NewQModelIndexFromPointer(topLeft), core.NewQModelIndexFromPointer(bottomRight), func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__dataChanged_roles_atList(i)
			}
			return out
		}(roles))
	}

}

//export callbackQFileSystemModel_HeaderDataChanged
func callbackQFileSystemModel_HeaderDataChanged(ptr unsafe.Pointer, orientation C.longlong, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "headerDataChanged"); signal != nil {
		(*(*func(core.Qt__Orientation, int, int))(signal))(core.Qt__Orientation(orientation), int(int32(first)), int(int32(last)))
	}

}

//export callbackQFileSystemModel_LayoutAboutToBeChanged
func callbackQFileSystemModel_LayoutAboutToBeChanged(ptr unsafe.Pointer, parents C.struct_QtWidgets_PackedList, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "layoutAboutToBeChanged"); signal != nil {
		(*(*func([]*core.QPersistentModelIndex, core.QAbstractItemModel__LayoutChangeHint))(signal))(func(l C.struct_QtWidgets_PackedList) []*core.QPersistentModelIndex {
			out := make([]*core.QPersistentModelIndex, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__layoutAboutToBeChanged_parents_atList(i)
			}
			return out
		}(parents), core.QAbstractItemModel__LayoutChangeHint(hint))
	}

}

//export callbackQFileSystemModel_LayoutChanged
func callbackQFileSystemModel_LayoutChanged(ptr unsafe.Pointer, parents C.struct_QtWidgets_PackedList, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "layoutChanged"); signal != nil {
		(*(*func([]*core.QPersistentModelIndex, core.QAbstractItemModel__LayoutChangeHint))(signal))(func(l C.struct_QtWidgets_PackedList) []*core.QPersistentModelIndex {
			out := make([]*core.QPersistentModelIndex, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__layoutChanged_parents_atList(i)
			}
			return out
		}(parents), core.QAbstractItemModel__LayoutChangeHint(hint))
	}

}

//export callbackQFileSystemModel_ModelAboutToBeReset
func callbackQFileSystemModel_ModelAboutToBeReset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "modelAboutToBeReset"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQFileSystemModel_ModelReset
func callbackQFileSystemModel_ModelReset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "modelReset"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQFileSystemModel_ResetInternalData
func callbackQFileSystemModel_ResetInternalData(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resetInternalData"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileSystemModelFromPointer(ptr).ResetInternalDataDefault()
	}
}

func (ptr *QFileSystemModel) ResetInternalDataDefault() {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_ResetInternalDataDefault(ptr.Pointer())
	}
}

//export callbackQFileSystemModel_Revert
func callbackQFileSystemModel_Revert(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "revert"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileSystemModelFromPointer(ptr).RevertDefault()
	}
}

func (ptr *QFileSystemModel) RevertDefault() {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_RevertDefault(ptr.Pointer())
	}
}

//export callbackQFileSystemModel_RowsAboutToBeInserted
func callbackQFileSystemModel_RowsAboutToBeInserted(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}

}

//export callbackQFileSystemModel_RowsAboutToBeMoved
func callbackQFileSystemModel_RowsAboutToBeMoved(ptr unsafe.Pointer, sourceParent unsafe.Pointer, sourceStart C.int, sourceEnd C.int, destinationParent unsafe.Pointer, destinationRow C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeMoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int))(signal))(core.NewQModelIndexFromPointer(sourceParent), int(int32(sourceStart)), int(int32(sourceEnd)), core.NewQModelIndexFromPointer(destinationParent), int(int32(destinationRow)))
	}

}

//export callbackQFileSystemModel_RowsAboutToBeRemoved
func callbackQFileSystemModel_RowsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQFileSystemModel_RowsInserted
func callbackQFileSystemModel_RowsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "rowsInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQFileSystemModel_RowsMoved
func callbackQFileSystemModel_RowsMoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int, destination unsafe.Pointer, row C.int) {
	if signal := qt.GetSignal(ptr, "rowsMoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int, *core.QModelIndex, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)), core.NewQModelIndexFromPointer(destination), int(int32(row)))
	}

}

//export callbackQFileSystemModel_RowsRemoved
func callbackQFileSystemModel_RowsRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, first C.int, last C.int) {
	if signal := qt.GetSignal(ptr, "rowsRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(first)), int(int32(last)))
	}

}

//export callbackQFileSystemModel_RoleNames
func callbackQFileSystemModel_RoleNames(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "roleNames"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQFileSystemModelFromPointer(NewQFileSystemModelFromPointer(nil).__roleNames_newList())
			for k, v := range (*(*func() map[int]*core.QByteArray)(signal))() {
				tmpList.__roleNames_setList(k, v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQFileSystemModelFromPointer(NewQFileSystemModelFromPointer(nil).__roleNames_newList())
		for k, v := range NewQFileSystemModelFromPointer(ptr).RoleNamesDefault() {
			tmpList.__roleNames_setList(k, v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QFileSystemModel) RoleNamesDefault() map[int]*core.QByteArray {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) map[int]*core.QByteArray {
			out := make(map[int]*core.QByteArray, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i, v := range tmpList.__roleNames_keyList() {
				out[v] = tmpList.__roleNames_atList(v, i)
			}
			return out
		}(C.QFileSystemModel_RoleNamesDefault(ptr.Pointer()))
	}
	return make(map[int]*core.QByteArray, 0)
}

//export callbackQFileSystemModel_ItemData
func callbackQFileSystemModel_ItemData(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemData"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQFileSystemModelFromPointer(NewQFileSystemModelFromPointer(nil).__itemData_newList())
			for k, v := range (*(*func(*core.QModelIndex) map[int]*core.QVariant)(signal))(core.NewQModelIndexFromPointer(index)) {
				tmpList.__itemData_setList(k, v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQFileSystemModelFromPointer(NewQFileSystemModelFromPointer(nil).__itemData_newList())
		for k, v := range NewQFileSystemModelFromPointer(ptr).ItemDataDefault(core.NewQModelIndexFromPointer(index)) {
			tmpList.__itemData_setList(k, v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QFileSystemModel) ItemDataDefault(index core.QModelIndex_ITF) map[int]*core.QVariant {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) map[int]*core.QVariant {
			out := make(map[int]*core.QVariant, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i, v := range tmpList.__itemData_keyList() {
				out[v] = tmpList.__itemData_atList(v, i)
			}
			return out
		}(C.QFileSystemModel_ItemDataDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return make(map[int]*core.QVariant, 0)
}

//export callbackQFileSystemModel_Buddy
func callbackQFileSystemModel_Buddy(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "buddy"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QModelIndex) *core.QModelIndex)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQModelIndex(NewQFileSystemModelFromPointer(ptr).BuddyDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QFileSystemModel) BuddyDefault(index core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QFileSystemModel_BuddyDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQFileSystemModel_Match
func callbackQFileSystemModel_Match(ptr unsafe.Pointer, start unsafe.Pointer, role C.int, value unsafe.Pointer, hits C.int, flags C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "match"); signal != nil {
		return func() unsafe.Pointer {
			tmpList := NewQFileSystemModelFromPointer(NewQFileSystemModelFromPointer(nil).__match_newList())
			for _, v := range (*(*func(*core.QModelIndex, int, *core.QVariant, int, core.Qt__MatchFlag) []*core.QModelIndex)(signal))(core.NewQModelIndexFromPointer(start), int(int32(role)), core.NewQVariantFromPointer(value), int(int32(hits)), core.Qt__MatchFlag(flags)) {
				tmpList.__match_setList(v)
			}
			return tmpList.Pointer()
		}()
	}

	return func() unsafe.Pointer {
		tmpList := NewQFileSystemModelFromPointer(NewQFileSystemModelFromPointer(nil).__match_newList())
		for _, v := range NewQFileSystemModelFromPointer(ptr).MatchDefault(core.NewQModelIndexFromPointer(start), int(int32(role)), core.NewQVariantFromPointer(value), int(int32(hits)), core.Qt__MatchFlag(flags)) {
			tmpList.__match_setList(v)
		}
		return tmpList.Pointer()
	}()
}

func (ptr *QFileSystemModel) MatchDefault(start core.QModelIndex_ITF, role int, value core.QVariant_ITF, hits int, flags core.Qt__MatchFlag) []*core.QModelIndex {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
			out := make([]*core.QModelIndex, int(l.len))
			tmpList := NewQFileSystemModelFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__match_atList(i)
			}
			return out
		}(C.QFileSystemModel_MatchDefault(ptr.Pointer(), core.PointerFromQModelIndex(start), C.int(int32(role)), core.PointerFromQVariant(value), C.int(int32(hits)), C.longlong(flags)))
	}
	return make([]*core.QModelIndex, 0)
}

//export callbackQFileSystemModel_Span
func callbackQFileSystemModel_Span(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "span"); signal != nil {
		return core.PointerFromQSize((*(*func(*core.QModelIndex) *core.QSize)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQSize(NewQFileSystemModelFromPointer(ptr).SpanDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QFileSystemModel) SpanDefault(index core.QModelIndex_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QFileSystemModel_SpanDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQFileSystemModel_SupportedDragActions
func callbackQFileSystemModel_SupportedDragActions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "supportedDragActions"); signal != nil {
		return C.longlong((*(*func() core.Qt__DropAction)(signal))())
	}

	return C.longlong(NewQFileSystemModelFromPointer(ptr).SupportedDragActionsDefault())
}

func (ptr *QFileSystemModel) SupportedDragActionsDefault() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QFileSystemModel_SupportedDragActionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQFileSystemModel_CanDropMimeData
func callbackQFileSystemModel_CanDropMimeData(ptr unsafe.Pointer, data unsafe.Pointer, action C.longlong, row C.int, column C.int, parent unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "canDropMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QMimeData, core.Qt__DropAction, int, int, *core.QModelIndex) bool)(signal))(core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action), int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).CanDropMimeDataDefault(core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action), int(int32(row)), int(int32(column)), core.NewQModelIndexFromPointer(parent)))))
}

func (ptr *QFileSystemModel) CanDropMimeDataDefault(data core.QMimeData_ITF, action core.Qt__DropAction, row int, column int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_CanDropMimeDataDefault(ptr.Pointer(), core.PointerFromQMimeData(data), C.longlong(action), C.int(int32(row)), C.int(int32(column)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

//export callbackQFileSystemModel_EventFilter
func callbackQFileSystemModel_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQFileSystemModelFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QFileSystemModel) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFileSystemModel_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQFileSystemModel_ChildEvent
func callbackQFileSystemModel_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQFileSystemModelFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QFileSystemModel) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQFileSystemModel_ConnectNotify
func callbackQFileSystemModel_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQFileSystemModelFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QFileSystemModel) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQFileSystemModel_CustomEvent
func callbackQFileSystemModel_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQFileSystemModelFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QFileSystemModel) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQFileSystemModel_DeleteLater
func callbackQFileSystemModel_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFileSystemModelFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QFileSystemModel) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQFileSystemModel_Destroyed
func callbackQFileSystemModel_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQFileSystemModel_DisconnectNotify
func callbackQFileSystemModel_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQFileSystemModelFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QFileSystemModel) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QFileSystemModel_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQFileSystemModel_ObjectNameChanged
func callbackQFileSystemModel_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

type QFocusFrame struct {
	QWidget
}

type QFocusFrame_ITF interface {
	QWidget_ITF
	QFocusFrame_PTR() *QFocusFrame
}

func (ptr *QFocusFrame) QFocusFrame_PTR() *QFocusFrame {
	return ptr
}

func (ptr *QFocusFrame) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QFocusFrame) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQFocusFrame(ptr QFocusFrame_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFocusFrame_PTR().Pointer()
	}
	return nil
}

func NewQFocusFrameFromPointer(ptr unsafe.Pointer) (n *QFocusFrame) {
	n = new(QFocusFrame)
	n.SetPointer(ptr)
	return
}
func NewQFocusFrame(parent QWidget_ITF) *QFocusFrame {
	tmpValue := NewQFocusFrameFromPointer(C.QFocusFrame_NewQFocusFrame(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QFocusFrame) SetWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QFocusFrame_SetWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQFocusFrame_DestroyQFocusFrame
func callbackQFocusFrame_DestroyQFocusFrame(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFocusFrame"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFocusFrameFromPointer(ptr).DestroyQFocusFrameDefault()
	}
}

func (ptr *QFocusFrame) ConnectDestroyQFocusFrame(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFocusFrame"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFocusFrame", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFocusFrame", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFocusFrame) DisconnectDestroyQFocusFrame() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFocusFrame")
	}
}

func (ptr *QFocusFrame) DestroyQFocusFrame() {
	if ptr.Pointer() != nil {
		C.QFocusFrame_DestroyQFocusFrame(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFocusFrame) DestroyQFocusFrameDefault() {
	if ptr.Pointer() != nil {
		C.QFocusFrame_DestroyQFocusFrameDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFocusFrame) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QFocusFrame_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFocusFrame) InitStyleOption(option QStyleOption_ITF) {
	if ptr.Pointer() != nil {
		C.QFocusFrame_InitStyleOption(ptr.Pointer(), PointerFromQStyleOption(option))
	}
}

type QFontComboBox struct {
	QComboBox
}

type QFontComboBox_ITF interface {
	QComboBox_ITF
	QFontComboBox_PTR() *QFontComboBox
}

func (ptr *QFontComboBox) QFontComboBox_PTR() *QFontComboBox {
	return ptr
}

func (ptr *QFontComboBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QComboBox_PTR().Pointer()
	}
	return nil
}

func (ptr *QFontComboBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QComboBox_PTR().SetPointer(p)
	}
}

func PointerFromQFontComboBox(ptr QFontComboBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFontComboBox_PTR().Pointer()
	}
	return nil
}

func NewQFontComboBoxFromPointer(ptr unsafe.Pointer) (n *QFontComboBox) {
	n = new(QFontComboBox)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QFontComboBox__FontFilter
//QFontComboBox::FontFilter
type QFontComboBox__FontFilter int64

const (
	QFontComboBox__AllFonts          QFontComboBox__FontFilter = QFontComboBox__FontFilter(0)
	QFontComboBox__ScalableFonts     QFontComboBox__FontFilter = QFontComboBox__FontFilter(0x1)
	QFontComboBox__NonScalableFonts  QFontComboBox__FontFilter = QFontComboBox__FontFilter(0x2)
	QFontComboBox__MonospacedFonts   QFontComboBox__FontFilter = QFontComboBox__FontFilter(0x4)
	QFontComboBox__ProportionalFonts QFontComboBox__FontFilter = QFontComboBox__FontFilter(0x8)
)

func NewQFontComboBox(parent QWidget_ITF) *QFontComboBox {
	tmpValue := NewQFontComboBoxFromPointer(C.QFontComboBox_NewQFontComboBox(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQFontComboBox_CurrentFontChanged
func callbackQFontComboBox_CurrentFontChanged(ptr unsafe.Pointer, font unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentFontChanged"); signal != nil {
		(*(*func(*gui.QFont))(signal))(gui.NewQFontFromPointer(font))
	}

}

func (ptr *QFontComboBox) ConnectCurrentFontChanged(f func(font *gui.QFont)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentFontChanged") {
			C.QFontComboBox_ConnectCurrentFontChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentFontChanged"); signal != nil {
			f := func(font *gui.QFont) {
				(*(*func(*gui.QFont))(signal))(font)
				f(font)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentFontChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentFontChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFontComboBox) DisconnectCurrentFontChanged() {
	if ptr.Pointer() != nil {
		C.QFontComboBox_DisconnectCurrentFontChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentFontChanged")
	}
}

func (ptr *QFontComboBox) CurrentFontChanged(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QFontComboBox_CurrentFontChanged(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

//export callbackQFontComboBox_SetCurrentFont
func callbackQFontComboBox_SetCurrentFont(ptr unsafe.Pointer, ff unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setCurrentFont"); signal != nil {
		(*(*func(*gui.QFont))(signal))(gui.NewQFontFromPointer(ff))
	} else {
		NewQFontComboBoxFromPointer(ptr).SetCurrentFontDefault(gui.NewQFontFromPointer(ff))
	}
}

func (ptr *QFontComboBox) ConnectSetCurrentFont(f func(ff *gui.QFont)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentFont"); signal != nil {
			f := func(ff *gui.QFont) {
				(*(*func(*gui.QFont))(signal))(ff)
				f(ff)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFontComboBox) DisconnectSetCurrentFont() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentFont")
	}
}

func (ptr *QFontComboBox) SetCurrentFont(ff gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QFontComboBox_SetCurrentFont(ptr.Pointer(), gui.PointerFromQFont(ff))
	}
}

func (ptr *QFontComboBox) SetCurrentFontDefault(ff gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QFontComboBox_SetCurrentFontDefault(ptr.Pointer(), gui.PointerFromQFont(ff))
	}
}

func (ptr *QFontComboBox) SetFontFilters(filters QFontComboBox__FontFilter) {
	if ptr.Pointer() != nil {
		C.QFontComboBox_SetFontFilters(ptr.Pointer(), C.longlong(filters))
	}
}

func (ptr *QFontComboBox) SetWritingSystem(vqf gui.QFontDatabase__WritingSystem) {
	if ptr.Pointer() != nil {
		C.QFontComboBox_SetWritingSystem(ptr.Pointer(), C.longlong(vqf))
	}
}

//export callbackQFontComboBox_DestroyQFontComboBox
func callbackQFontComboBox_DestroyQFontComboBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFontComboBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFontComboBoxFromPointer(ptr).DestroyQFontComboBoxDefault()
	}
}

func (ptr *QFontComboBox) ConnectDestroyQFontComboBox(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFontComboBox"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFontComboBox", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFontComboBox", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFontComboBox) DisconnectDestroyQFontComboBox() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFontComboBox")
	}
}

func (ptr *QFontComboBox) DestroyQFontComboBox() {
	if ptr.Pointer() != nil {
		C.QFontComboBox_DestroyQFontComboBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFontComboBox) DestroyQFontComboBoxDefault() {
	if ptr.Pointer() != nil {
		C.QFontComboBox_DestroyQFontComboBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFontComboBox) CurrentFont() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QFontComboBox_CurrentFont(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QFontComboBox) FontFilters() QFontComboBox__FontFilter {
	if ptr.Pointer() != nil {
		return QFontComboBox__FontFilter(C.QFontComboBox_FontFilters(ptr.Pointer()))
	}
	return 0
}

type QFontDialog struct {
	QDialog
}

type QFontDialog_ITF interface {
	QDialog_ITF
	QFontDialog_PTR() *QFontDialog
}

func (ptr *QFontDialog) QFontDialog_PTR() *QFontDialog {
	return ptr
}

func (ptr *QFontDialog) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QDialog_PTR().Pointer()
	}
	return nil
}

func (ptr *QFontDialog) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QDialog_PTR().SetPointer(p)
	}
}

func PointerFromQFontDialog(ptr QFontDialog_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFontDialog_PTR().Pointer()
	}
	return nil
}

func NewQFontDialogFromPointer(ptr unsafe.Pointer) (n *QFontDialog) {
	n = new(QFontDialog)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QFontDialog__FontDialogOption
//QFontDialog::FontDialogOption
type QFontDialog__FontDialogOption int64

const (
	QFontDialog__NoButtons           QFontDialog__FontDialogOption = QFontDialog__FontDialogOption(0x00000001)
	QFontDialog__DontUseNativeDialog QFontDialog__FontDialogOption = QFontDialog__FontDialogOption(0x00000002)
	QFontDialog__ScalableFonts       QFontDialog__FontDialogOption = QFontDialog__FontDialogOption(0x00000004)
	QFontDialog__NonScalableFonts    QFontDialog__FontDialogOption = QFontDialog__FontDialogOption(0x00000008)
	QFontDialog__MonospacedFonts     QFontDialog__FontDialogOption = QFontDialog__FontDialogOption(0x00000010)
	QFontDialog__ProportionalFonts   QFontDialog__FontDialogOption = QFontDialog__FontDialogOption(0x00000020)
)

func QFontDialog_GetFont2(ok *bool, parent QWidget_ITF) *gui.QFont {
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	tmpValue := gui.NewQFontFromPointer(C.QFontDialog_QFontDialog_GetFont2(&okC, PointerFromQWidget(parent)))
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func (ptr *QFontDialog) GetFont2(ok *bool, parent QWidget_ITF) *gui.QFont {
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	tmpValue := gui.NewQFontFromPointer(C.QFontDialog_QFontDialog_GetFont2(&okC, PointerFromQWidget(parent)))
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func QFontDialog_GetFont(ok *bool, initial gui.QFont_ITF, parent QWidget_ITF, title string, options QFontDialog__FontDialogOption) *gui.QFont {
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	tmpValue := gui.NewQFontFromPointer(C.QFontDialog_QFontDialog_GetFont(&okC, gui.PointerFromQFont(initial), PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.longlong(options)))
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func (ptr *QFontDialog) GetFont(ok *bool, initial gui.QFont_ITF, parent QWidget_ITF, title string, options QFontDialog__FontDialogOption) *gui.QFont {
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	tmpValue := gui.NewQFontFromPointer(C.QFontDialog_QFontDialog_GetFont(&okC, gui.PointerFromQFont(initial), PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.longlong(options)))
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func NewQFontDialog(parent QWidget_ITF) *QFontDialog {
	tmpValue := NewQFontDialogFromPointer(C.QFontDialog_NewQFontDialog(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQFontDialog2(initial gui.QFont_ITF, parent QWidget_ITF) *QFontDialog {
	tmpValue := NewQFontDialogFromPointer(C.QFontDialog_NewQFontDialog2(gui.PointerFromQFont(initial), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQFontDialog_CurrentFontChanged
func callbackQFontDialog_CurrentFontChanged(ptr unsafe.Pointer, font unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentFontChanged"); signal != nil {
		(*(*func(*gui.QFont))(signal))(gui.NewQFontFromPointer(font))
	}

}

func (ptr *QFontDialog) ConnectCurrentFontChanged(f func(font *gui.QFont)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentFontChanged") {
			C.QFontDialog_ConnectCurrentFontChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentFontChanged"); signal != nil {
			f := func(font *gui.QFont) {
				(*(*func(*gui.QFont))(signal))(font)
				f(font)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentFontChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentFontChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFontDialog) DisconnectCurrentFontChanged() {
	if ptr.Pointer() != nil {
		C.QFontDialog_DisconnectCurrentFontChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentFontChanged")
	}
}

func (ptr *QFontDialog) CurrentFontChanged(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QFontDialog_CurrentFontChanged(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

//export callbackQFontDialog_Done
func callbackQFontDialog_Done(ptr unsafe.Pointer, result C.int) {
	if signal := qt.GetSignal(ptr, "done"); signal != nil {
		(*(*func(int))(signal))(int(int32(result)))
	} else {
		NewQFontDialogFromPointer(ptr).DoneDefault(int(int32(result)))
	}
}

func (ptr *QFontDialog) ConnectDone(f func(result int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "done"); signal != nil {
			f := func(result int) {
				(*(*func(int))(signal))(result)
				f(result)
			}
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFontDialog) DisconnectDone() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "done")
	}
}

func (ptr *QFontDialog) Done(result int) {
	if ptr.Pointer() != nil {
		C.QFontDialog_Done(ptr.Pointer(), C.int(int32(result)))
	}
}

func (ptr *QFontDialog) DoneDefault(result int) {
	if ptr.Pointer() != nil {
		C.QFontDialog_DoneDefault(ptr.Pointer(), C.int(int32(result)))
	}
}

//export callbackQFontDialog_FontSelected
func callbackQFontDialog_FontSelected(ptr unsafe.Pointer, font unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "fontSelected"); signal != nil {
		(*(*func(*gui.QFont))(signal))(gui.NewQFontFromPointer(font))
	}

}

func (ptr *QFontDialog) ConnectFontSelected(f func(font *gui.QFont)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "fontSelected") {
			C.QFontDialog_ConnectFontSelected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "fontSelected"); signal != nil {
			f := func(font *gui.QFont) {
				(*(*func(*gui.QFont))(signal))(font)
				f(font)
			}
			qt.ConnectSignal(ptr.Pointer(), "fontSelected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "fontSelected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFontDialog) DisconnectFontSelected() {
	if ptr.Pointer() != nil {
		C.QFontDialog_DisconnectFontSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "fontSelected")
	}
}

func (ptr *QFontDialog) FontSelected(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QFontDialog_FontSelected(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

func (ptr *QFontDialog) Open(receiver core.QObject_ITF, member string) {
	if ptr.Pointer() != nil {
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		C.QFontDialog_Open(ptr.Pointer(), core.PointerFromQObject(receiver), memberC)
	}
}

func (ptr *QFontDialog) SetCurrentFont(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QFontDialog_SetCurrentFont(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

func (ptr *QFontDialog) SetOption(option QFontDialog__FontDialogOption, on bool) {
	if ptr.Pointer() != nil {
		C.QFontDialog_SetOption(ptr.Pointer(), C.longlong(option), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QFontDialog) SetOptions(options QFontDialog__FontDialogOption) {
	if ptr.Pointer() != nil {
		C.QFontDialog_SetOptions(ptr.Pointer(), C.longlong(options))
	}
}

func (ptr *QFontDialog) CurrentFont() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QFontDialog_CurrentFont(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QFontDialog) SelectedFont() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QFontDialog_SelectedFont(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QFontDialog) Options() QFontDialog__FontDialogOption {
	if ptr.Pointer() != nil {
		return QFontDialog__FontDialogOption(C.QFontDialog_Options(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontDialog) TestOption(option QFontDialog__FontDialogOption) bool {
	if ptr.Pointer() != nil {
		return int8(C.QFontDialog_TestOption(ptr.Pointer(), C.longlong(option))) != 0
	}
	return false
}

type QFormLayout struct {
	QLayout
}

type QFormLayout_ITF interface {
	QLayout_ITF
	QFormLayout_PTR() *QFormLayout
}

func (ptr *QFormLayout) QFormLayout_PTR() *QFormLayout {
	return ptr
}

func (ptr *QFormLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QLayout_PTR().Pointer()
	}
	return nil
}

func (ptr *QFormLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QLayout_PTR().SetPointer(p)
	}
}

func PointerFromQFormLayout(ptr QFormLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFormLayout_PTR().Pointer()
	}
	return nil
}

func NewQFormLayoutFromPointer(ptr unsafe.Pointer) (n *QFormLayout) {
	n = new(QFormLayout)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QFormLayout__FieldGrowthPolicy
//QFormLayout::FieldGrowthPolicy
type QFormLayout__FieldGrowthPolicy int64

const (
	QFormLayout__FieldsStayAtSizeHint  QFormLayout__FieldGrowthPolicy = QFormLayout__FieldGrowthPolicy(0)
	QFormLayout__ExpandingFieldsGrow   QFormLayout__FieldGrowthPolicy = QFormLayout__FieldGrowthPolicy(1)
	QFormLayout__AllNonFixedFieldsGrow QFormLayout__FieldGrowthPolicy = QFormLayout__FieldGrowthPolicy(2)
)

//go:generate stringer -type=QFormLayout__ItemRole
//QFormLayout::ItemRole
type QFormLayout__ItemRole int64

const (
	QFormLayout__LabelRole    QFormLayout__ItemRole = QFormLayout__ItemRole(0)
	QFormLayout__FieldRole    QFormLayout__ItemRole = QFormLayout__ItemRole(1)
	QFormLayout__SpanningRole QFormLayout__ItemRole = QFormLayout__ItemRole(2)
)

//go:generate stringer -type=QFormLayout__RowWrapPolicy
//QFormLayout::RowWrapPolicy
type QFormLayout__RowWrapPolicy int64

const (
	QFormLayout__DontWrapRows QFormLayout__RowWrapPolicy = QFormLayout__RowWrapPolicy(0)
	QFormLayout__WrapLongRows QFormLayout__RowWrapPolicy = QFormLayout__RowWrapPolicy(1)
	QFormLayout__WrapAllRows  QFormLayout__RowWrapPolicy = QFormLayout__RowWrapPolicy(2)
)

func NewQFormLayout(parent QWidget_ITF) *QFormLayout {
	tmpValue := NewQFormLayoutFromPointer(C.QFormLayout_NewQFormLayout(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQFormLayout_TakeAt
func callbackQFormLayout_TakeAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "takeAt"); signal != nil {
		return PointerFromQLayoutItem((*(*func(int) *QLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQLayoutItem(NewQFormLayoutFromPointer(ptr).TakeAtDefault(int(int32(index))))
}

func (ptr *QFormLayout) ConnectTakeAt(f func(index int) *QLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "takeAt"); signal != nil {
			f := func(index int) *QLayoutItem {
				(*(*func(int) *QLayoutItem)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "takeAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "takeAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFormLayout) DisconnectTakeAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "takeAt")
	}
}

func (ptr *QFormLayout) TakeAt(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QFormLayout_TakeAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QFormLayout) TakeAtDefault(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QFormLayout_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

//export callbackQFormLayout_AddItem
func callbackQFormLayout_AddItem(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "addItem"); signal != nil {
		(*(*func(*QLayoutItem))(signal))(NewQLayoutItemFromPointer(item))
	} else {
		NewQFormLayoutFromPointer(ptr).AddItemDefault(NewQLayoutItemFromPointer(item))
	}
}

func (ptr *QFormLayout) ConnectAddItem(f func(item *QLayoutItem)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "addItem"); signal != nil {
			f := func(item *QLayoutItem) {
				(*(*func(*QLayoutItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "addItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "addItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFormLayout) DisconnectAddItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "addItem")
	}
}

func (ptr *QFormLayout) AddItem(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_AddItem(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

func (ptr *QFormLayout) AddItemDefault(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_AddItemDefault(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

func (ptr *QFormLayout) AddRow6(layout QLayout_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_AddRow6(ptr.Pointer(), PointerFromQLayout(layout))
	}
}

func (ptr *QFormLayout) AddRow2(label QWidget_ITF, field QLayout_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_AddRow2(ptr.Pointer(), PointerFromQWidget(label), PointerFromQLayout(field))
	}
}

func (ptr *QFormLayout) AddRow(label QWidget_ITF, field QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_AddRow(ptr.Pointer(), PointerFromQWidget(label), PointerFromQWidget(field))
	}
}

func (ptr *QFormLayout) AddRow5(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_AddRow5(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QFormLayout) AddRow4(labelText string, field QLayout_ITF) {
	if ptr.Pointer() != nil {
		var labelTextC *C.char
		if labelText != "" {
			labelTextC = C.CString(labelText)
			defer C.free(unsafe.Pointer(labelTextC))
		}
		C.QFormLayout_AddRow4(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: labelTextC, len: C.longlong(len(labelText))}, PointerFromQLayout(field))
	}
}

func (ptr *QFormLayout) AddRow3(labelText string, field QWidget_ITF) {
	if ptr.Pointer() != nil {
		var labelTextC *C.char
		if labelText != "" {
			labelTextC = C.CString(labelText)
			defer C.free(unsafe.Pointer(labelTextC))
		}
		C.QFormLayout_AddRow3(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: labelTextC, len: C.longlong(len(labelText))}, PointerFromQWidget(field))
	}
}

func (ptr *QFormLayout) InsertRow6(row int, layout QLayout_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_InsertRow6(ptr.Pointer(), C.int(int32(row)), PointerFromQLayout(layout))
	}
}

func (ptr *QFormLayout) InsertRow2(row int, label QWidget_ITF, field QLayout_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_InsertRow2(ptr.Pointer(), C.int(int32(row)), PointerFromQWidget(label), PointerFromQLayout(field))
	}
}

func (ptr *QFormLayout) InsertRow(row int, label QWidget_ITF, field QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_InsertRow(ptr.Pointer(), C.int(int32(row)), PointerFromQWidget(label), PointerFromQWidget(field))
	}
}

func (ptr *QFormLayout) InsertRow5(row int, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_InsertRow5(ptr.Pointer(), C.int(int32(row)), PointerFromQWidget(widget))
	}
}

func (ptr *QFormLayout) InsertRow4(row int, labelText string, field QLayout_ITF) {
	if ptr.Pointer() != nil {
		var labelTextC *C.char
		if labelText != "" {
			labelTextC = C.CString(labelText)
			defer C.free(unsafe.Pointer(labelTextC))
		}
		C.QFormLayout_InsertRow4(ptr.Pointer(), C.int(int32(row)), C.struct_QtWidgets_PackedString{data: labelTextC, len: C.longlong(len(labelText))}, PointerFromQLayout(field))
	}
}

func (ptr *QFormLayout) InsertRow3(row int, labelText string, field QWidget_ITF) {
	if ptr.Pointer() != nil {
		var labelTextC *C.char
		if labelText != "" {
			labelTextC = C.CString(labelText)
			defer C.free(unsafe.Pointer(labelTextC))
		}
		C.QFormLayout_InsertRow3(ptr.Pointer(), C.int(int32(row)), C.struct_QtWidgets_PackedString{data: labelTextC, len: C.longlong(len(labelText))}, PointerFromQWidget(field))
	}
}

func (ptr *QFormLayout) RemoveRow3(layout QLayout_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_RemoveRow3(ptr.Pointer(), PointerFromQLayout(layout))
	}
}

func (ptr *QFormLayout) RemoveRow2(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_RemoveRow2(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QFormLayout) RemoveRow(row int) {
	if ptr.Pointer() != nil {
		C.QFormLayout_RemoveRow(ptr.Pointer(), C.int(int32(row)))
	}
}

func (ptr *QFormLayout) SetFieldGrowthPolicy(policy QFormLayout__FieldGrowthPolicy) {
	if ptr.Pointer() != nil {
		C.QFormLayout_SetFieldGrowthPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QFormLayout) SetFormAlignment(alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QFormLayout_SetFormAlignment(ptr.Pointer(), C.longlong(alignment))
	}
}

func (ptr *QFormLayout) SetHorizontalSpacing(spacing int) {
	if ptr.Pointer() != nil {
		C.QFormLayout_SetHorizontalSpacing(ptr.Pointer(), C.int(int32(spacing)))
	}
}

func (ptr *QFormLayout) SetItem(row int, role QFormLayout__ItemRole, item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_SetItem(ptr.Pointer(), C.int(int32(row)), C.longlong(role), PointerFromQLayoutItem(item))
	}
}

func (ptr *QFormLayout) SetLabelAlignment(alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QFormLayout_SetLabelAlignment(ptr.Pointer(), C.longlong(alignment))
	}
}

func (ptr *QFormLayout) SetLayout(row int, role QFormLayout__ItemRole, layout QLayout_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_SetLayout(ptr.Pointer(), C.int(int32(row)), C.longlong(role), PointerFromQLayout(layout))
	}
}

func (ptr *QFormLayout) SetRowWrapPolicy(policy QFormLayout__RowWrapPolicy) {
	if ptr.Pointer() != nil {
		C.QFormLayout_SetRowWrapPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QFormLayout) SetVerticalSpacing(spacing int) {
	if ptr.Pointer() != nil {
		C.QFormLayout_SetVerticalSpacing(ptr.Pointer(), C.int(int32(spacing)))
	}
}

func (ptr *QFormLayout) SetWidget(row int, role QFormLayout__ItemRole, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QFormLayout_SetWidget(ptr.Pointer(), C.int(int32(row)), C.longlong(role), PointerFromQWidget(widget))
	}
}

//export callbackQFormLayout_DestroyQFormLayout
func callbackQFormLayout_DestroyQFormLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFormLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFormLayoutFromPointer(ptr).DestroyQFormLayoutDefault()
	}
}

func (ptr *QFormLayout) ConnectDestroyQFormLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFormLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFormLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFormLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFormLayout) DisconnectDestroyQFormLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFormLayout")
	}
}

func (ptr *QFormLayout) DestroyQFormLayout() {
	if ptr.Pointer() != nil {
		C.QFormLayout_DestroyQFormLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFormLayout) DestroyQFormLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QFormLayout_DestroyQFormLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFormLayout) FieldGrowthPolicy() QFormLayout__FieldGrowthPolicy {
	if ptr.Pointer() != nil {
		return QFormLayout__FieldGrowthPolicy(C.QFormLayout_FieldGrowthPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFormLayout) RowWrapPolicy() QFormLayout__RowWrapPolicy {
	if ptr.Pointer() != nil {
		return QFormLayout__RowWrapPolicy(C.QFormLayout_RowWrapPolicy(ptr.Pointer()))
	}
	return 0
}

//export callbackQFormLayout_SizeHint
func callbackQFormLayout_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQFormLayoutFromPointer(ptr).SizeHintDefault())
}

func (ptr *QFormLayout) ConnectSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFormLayout) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QFormLayout) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QFormLayout_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QFormLayout) SizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QFormLayout_SizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QFormLayout) LabelForField2(field QLayout_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QFormLayout_LabelForField2(ptr.Pointer(), PointerFromQLayout(field)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFormLayout) LabelForField(field QWidget_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QFormLayout_LabelForField(ptr.Pointer(), PointerFromQWidget(field)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QFormLayout) FormAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QFormLayout_FormAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFormLayout) LabelAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QFormLayout_LabelAlignment(ptr.Pointer()))
	}
	return 0
}

//export callbackQFormLayout_Count
func callbackQFormLayout_Count(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "count"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQFormLayoutFromPointer(ptr).CountDefault()))
}

func (ptr *QFormLayout) ConnectCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "count"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFormLayout) DisconnectCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "count")
	}
}

func (ptr *QFormLayout) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFormLayout_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFormLayout) CountDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFormLayout_CountDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFormLayout) HorizontalSpacing() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFormLayout_HorizontalSpacing(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFormLayout) RowCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFormLayout_RowCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFormLayout) VerticalSpacing() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFormLayout_VerticalSpacing(ptr.Pointer())))
	}
	return 0
}

type QFrame struct {
	QWidget
}

type QFrame_ITF interface {
	QWidget_ITF
	QFrame_PTR() *QFrame
}

func (ptr *QFrame) QFrame_PTR() *QFrame {
	return ptr
}

func (ptr *QFrame) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QFrame) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQFrame(ptr QFrame_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFrame_PTR().Pointer()
	}
	return nil
}

func NewQFrameFromPointer(ptr unsafe.Pointer) (n *QFrame) {
	n = new(QFrame)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QFrame__Shadow
//QFrame::Shadow
type QFrame__Shadow int64

const (
	QFrame__Plain  QFrame__Shadow = QFrame__Shadow(0x0010)
	QFrame__Raised QFrame__Shadow = QFrame__Shadow(0x0020)
	QFrame__Sunken QFrame__Shadow = QFrame__Shadow(0x0030)
)

//go:generate stringer -type=QFrame__Shape
//QFrame::Shape
type QFrame__Shape int64

const (
	QFrame__NoFrame     QFrame__Shape = QFrame__Shape(0)
	QFrame__Box         QFrame__Shape = QFrame__Shape(0x0001)
	QFrame__Panel       QFrame__Shape = QFrame__Shape(0x0002)
	QFrame__WinPanel    QFrame__Shape = QFrame__Shape(0x0003)
	QFrame__HLine       QFrame__Shape = QFrame__Shape(0x0004)
	QFrame__VLine       QFrame__Shape = QFrame__Shape(0x0005)
	QFrame__StyledPanel QFrame__Shape = QFrame__Shape(0x0006)
)

//go:generate stringer -type=QFrame__StyleMask
//QFrame::StyleMask
type QFrame__StyleMask int64

var (
	QFrame__Shadow_Mask QFrame__StyleMask = QFrame__StyleMask(0x00f0)
	QFrame__Shape_Mask  QFrame__StyleMask = QFrame__StyleMask(0x000f)
)

func NewQFrame(parent QWidget_ITF, ff core.Qt__WindowType) *QFrame {
	tmpValue := NewQFrameFromPointer(C.QFrame_NewQFrame(PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QFrame) SetFrameRect(vqr core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QFrame_SetFrameRect(ptr.Pointer(), core.PointerFromQRect(vqr))
	}
}

func (ptr *QFrame) SetFrameShadow(vqf QFrame__Shadow) {
	if ptr.Pointer() != nil {
		C.QFrame_SetFrameShadow(ptr.Pointer(), C.longlong(vqf))
	}
}

func (ptr *QFrame) SetFrameShape(vqf QFrame__Shape) {
	if ptr.Pointer() != nil {
		C.QFrame_SetFrameShape(ptr.Pointer(), C.longlong(vqf))
	}
}

func (ptr *QFrame) SetFrameStyle(style int) {
	if ptr.Pointer() != nil {
		C.QFrame_SetFrameStyle(ptr.Pointer(), C.int(int32(style)))
	}
}

func (ptr *QFrame) SetLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QFrame_SetLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QFrame) SetMidLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QFrame_SetMidLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

//export callbackQFrame_DestroyQFrame
func callbackQFrame_DestroyQFrame(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QFrame"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQFrameFromPointer(ptr).DestroyQFrameDefault()
	}
}

func (ptr *QFrame) ConnectDestroyQFrame(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QFrame"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QFrame", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QFrame", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QFrame) DisconnectDestroyQFrame() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QFrame")
	}
}

func (ptr *QFrame) DestroyQFrame() {
	if ptr.Pointer() != nil {
		C.QFrame_DestroyQFrame(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFrame) DestroyQFrameDefault() {
	if ptr.Pointer() != nil {
		C.QFrame_DestroyQFrameDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QFrame) FrameShadow() QFrame__Shadow {
	if ptr.Pointer() != nil {
		return QFrame__Shadow(C.QFrame_FrameShadow(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFrame) FrameShape() QFrame__Shape {
	if ptr.Pointer() != nil {
		return QFrame__Shape(C.QFrame_FrameShape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFrame) FrameRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QFrame_FrameRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QFrame) FrameStyle() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFrame_FrameStyle(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFrame) FrameWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFrame_FrameWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFrame) LineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFrame_LineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFrame) MidLineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QFrame_MidLineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QFrame) InitStyleOption(option QStyleOptionFrame_ITF) {
	if ptr.Pointer() != nil {
		C.QFrame_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionFrame(option))
	}
}

type QGesture struct {
	core.QObject
}

type QGesture_ITF interface {
	core.QObject_ITF
	QGesture_PTR() *QGesture
}

func (ptr *QGesture) QGesture_PTR() *QGesture {
	return ptr
}

func (ptr *QGesture) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QGesture) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQGesture(ptr QGesture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGesture_PTR().Pointer()
	}
	return nil
}

func NewQGestureFromPointer(ptr unsafe.Pointer) (n *QGesture) {
	n = new(QGesture)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGesture__GestureCancelPolicy
//QGesture::GestureCancelPolicy
type QGesture__GestureCancelPolicy int64

const (
	QGesture__CancelNone         QGesture__GestureCancelPolicy = QGesture__GestureCancelPolicy(0)
	QGesture__CancelAllInContext QGesture__GestureCancelPolicy = QGesture__GestureCancelPolicy(1)
)

func NewQGesture(parent core.QObject_ITF) *QGesture {
	tmpValue := NewQGestureFromPointer(C.QGesture_NewQGesture(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QGesture_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGesture_QGesture_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QGesture) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGesture_QGesture_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QGesture) SetGestureCancelPolicy(policy QGesture__GestureCancelPolicy) {
	if ptr.Pointer() != nil {
		C.QGesture_SetGestureCancelPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QGesture) SetHotSpot(value core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture_SetHotSpot(ptr.Pointer(), core.PointerFromQPointF(value))
	}
}

func (ptr *QGesture) UnsetHotSpot() {
	if ptr.Pointer() != nil {
		C.QGesture_UnsetHotSpot(ptr.Pointer())
	}
}

//export callbackQGesture_DestroyQGesture
func callbackQGesture_DestroyQGesture(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGesture"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGestureFromPointer(ptr).DestroyQGestureDefault()
	}
}

func (ptr *QGesture) ConnectDestroyQGesture(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGesture"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGesture", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGesture", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGesture) DisconnectDestroyQGesture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGesture")
	}
}

func (ptr *QGesture) DestroyQGesture() {
	if ptr.Pointer() != nil {
		C.QGesture_DestroyQGesture(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGesture) DestroyQGestureDefault() {
	if ptr.Pointer() != nil {
		C.QGesture_DestroyQGestureDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGesture) GestureCancelPolicy() QGesture__GestureCancelPolicy {
	if ptr.Pointer() != nil {
		return QGesture__GestureCancelPolicy(C.QGesture_GestureCancelPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGesture) HotSpot() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGesture_HotSpot(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGesture) State() core.Qt__GestureState {
	if ptr.Pointer() != nil {
		return core.Qt__GestureState(C.QGesture_State(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGesture) GestureType() core.Qt__GestureType {
	if ptr.Pointer() != nil {
		return core.Qt__GestureType(C.QGesture_GestureType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGesture) HasHotSpot() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGesture_HasHotSpot(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQGesture_MetaObject
func callbackQGesture_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQGestureFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QGesture) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QGesture_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGesture) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QGesture___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QGesture) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QGesture) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QGesture___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QGesture) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGesture___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGesture) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGesture) __findChildren_newList2() unsafe.Pointer {
	return C.QGesture___findChildren_newList2(ptr.Pointer())
}

func (ptr *QGesture) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGesture___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGesture) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGesture) __findChildren_newList3() unsafe.Pointer {
	return C.QGesture___findChildren_newList3(ptr.Pointer())
}

func (ptr *QGesture) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGesture___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGesture) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGesture) __findChildren_newList() unsafe.Pointer {
	return C.QGesture___findChildren_newList(ptr.Pointer())
}

func (ptr *QGesture) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGesture___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGesture) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGesture) __children_newList() unsafe.Pointer {
	return C.QGesture___children_newList(ptr.Pointer())
}

//export callbackQGesture_Event
func callbackQGesture_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGestureFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QGesture) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGesture_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQGesture_EventFilter
func callbackQGesture_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGestureFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QGesture) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGesture_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGesture_ChildEvent
func callbackQGesture_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQGestureFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QGesture) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQGesture_ConnectNotify
func callbackQGesture_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGestureFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGesture) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGesture_CustomEvent
func callbackQGesture_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGestureFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGesture) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGesture_DeleteLater
func callbackQGesture_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGestureFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QGesture) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QGesture_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGesture_Destroyed
func callbackQGesture_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQGesture_DisconnectNotify
func callbackQGesture_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGestureFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGesture) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGesture_ObjectNameChanged
func callbackQGesture_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQGesture_TimerEvent
func callbackQGesture_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQGestureFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QGesture) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGesture_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QGestureEvent struct {
	core.QEvent
}

type QGestureEvent_ITF interface {
	core.QEvent_ITF
	QGestureEvent_PTR() *QGestureEvent
}

func (ptr *QGestureEvent) QGestureEvent_PTR() *QGestureEvent {
	return ptr
}

func (ptr *QGestureEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGestureEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGestureEvent(ptr QGestureEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGestureEvent_PTR().Pointer()
	}
	return nil
}

func NewQGestureEventFromPointer(ptr unsafe.Pointer) (n *QGestureEvent) {
	n = new(QGestureEvent)
	n.SetPointer(ptr)
	return
}
func NewQGestureEvent(gestures []*QGesture) *QGestureEvent {
	tmpValue := NewQGestureEventFromPointer(C.QGestureEvent_NewQGestureEvent(func() unsafe.Pointer {
		tmpList := NewQGestureEventFromPointer(NewQGestureEventFromPointer(nil).__QGestureEvent_gestures_newList())
		for _, v := range gestures {
			tmpList.__QGestureEvent_gestures_setList(v)
		}
		return tmpList.Pointer()
	}()))
	runtime.SetFinalizer(tmpValue, (*QGestureEvent).DestroyQGestureEvent)
	return tmpValue
}

func (ptr *QGestureEvent) Accept(gesture QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_Accept(ptr.Pointer(), PointerFromQGesture(gesture))
	}
}

func (ptr *QGestureEvent) Accept2(gestureType core.Qt__GestureType) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_Accept2(ptr.Pointer(), C.longlong(gestureType))
	}
}

func (ptr *QGestureEvent) Ignore(gesture QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_Ignore(ptr.Pointer(), PointerFromQGesture(gesture))
	}
}

func (ptr *QGestureEvent) Ignore2(gestureType core.Qt__GestureType) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_Ignore2(ptr.Pointer(), C.longlong(gestureType))
	}
}

func (ptr *QGestureEvent) SetAccepted(gesture QGesture_ITF, value bool) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_SetAccepted(ptr.Pointer(), PointerFromQGesture(gesture), C.char(int8(qt.GoBoolToInt(value))))
	}
}

func (ptr *QGestureEvent) SetAccepted2(gestureType core.Qt__GestureType, value bool) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_SetAccepted2(ptr.Pointer(), C.longlong(gestureType), C.char(int8(qt.GoBoolToInt(value))))
	}
}

//export callbackQGestureEvent_DestroyQGestureEvent
func callbackQGestureEvent_DestroyQGestureEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGestureEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGestureEventFromPointer(ptr).DestroyQGestureEventDefault()
	}
}

func (ptr *QGestureEvent) ConnectDestroyQGestureEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGestureEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGestureEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGestureEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGestureEvent) DisconnectDestroyQGestureEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGestureEvent")
	}
}

func (ptr *QGestureEvent) DestroyQGestureEvent() {
	if ptr.Pointer() != nil {
		C.QGestureEvent_DestroyQGestureEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGestureEvent) DestroyQGestureEventDefault() {
	if ptr.Pointer() != nil {
		C.QGestureEvent_DestroyQGestureEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGestureEvent) Gesture(ty core.Qt__GestureType) *QGesture {
	if ptr.Pointer() != nil {
		tmpValue := NewQGestureFromPointer(C.QGestureEvent_Gesture(ptr.Pointer(), C.longlong(ty)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) ActiveGestures() []*QGesture {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGesture {
			out := make([]*QGesture, int(l.len))
			tmpList := NewQGestureEventFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__activeGestures_atList(i)
			}
			return out
		}(C.QGestureEvent_ActiveGestures(ptr.Pointer()))
	}
	return make([]*QGesture, 0)
}

func (ptr *QGestureEvent) CanceledGestures() []*QGesture {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGesture {
			out := make([]*QGesture, int(l.len))
			tmpList := NewQGestureEventFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__canceledGestures_atList(i)
			}
			return out
		}(C.QGestureEvent_CanceledGestures(ptr.Pointer()))
	}
	return make([]*QGesture, 0)
}

func (ptr *QGestureEvent) Gestures() []*QGesture {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGesture {
			out := make([]*QGesture, int(l.len))
			tmpList := NewQGestureEventFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__gestures_atList(i)
			}
			return out
		}(C.QGestureEvent_Gestures(ptr.Pointer()))
	}
	return make([]*QGesture, 0)
}

func (ptr *QGestureEvent) MapToGraphicsScene(gesturePoint core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGestureEvent_MapToGraphicsScene(ptr.Pointer(), core.PointerFromQPointF(gesturePoint)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QGestureEvent_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) IsAccepted(gesture QGesture_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGestureEvent_IsAccepted(ptr.Pointer(), PointerFromQGesture(gesture))) != 0
	}
	return false
}

func (ptr *QGestureEvent) IsAccepted2(gestureType core.Qt__GestureType) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGestureEvent_IsAccepted2(ptr.Pointer(), C.longlong(gestureType))) != 0
	}
	return false
}

func (ptr *QGestureEvent) __QGestureEvent_gestures_atList(i int) *QGesture {
	if ptr.Pointer() != nil {
		tmpValue := NewQGestureFromPointer(C.QGestureEvent___QGestureEvent_gestures_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) __QGestureEvent_gestures_setList(i QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___QGestureEvent_gestures_setList(ptr.Pointer(), PointerFromQGesture(i))
	}
}

func (ptr *QGestureEvent) __QGestureEvent_gestures_newList() unsafe.Pointer {
	return C.QGestureEvent___QGestureEvent_gestures_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __activeGestures_atList(i int) *QGesture {
	if ptr.Pointer() != nil {
		tmpValue := NewQGestureFromPointer(C.QGestureEvent___activeGestures_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) __activeGestures_setList(i QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___activeGestures_setList(ptr.Pointer(), PointerFromQGesture(i))
	}
}

func (ptr *QGestureEvent) __activeGestures_newList() unsafe.Pointer {
	return C.QGestureEvent___activeGestures_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __canceledGestures_atList(i int) *QGesture {
	if ptr.Pointer() != nil {
		tmpValue := NewQGestureFromPointer(C.QGestureEvent___canceledGestures_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) __canceledGestures_setList(i QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___canceledGestures_setList(ptr.Pointer(), PointerFromQGesture(i))
	}
}

func (ptr *QGestureEvent) __canceledGestures_newList() unsafe.Pointer {
	return C.QGestureEvent___canceledGestures_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __gestures_atList(i int) *QGesture {
	if ptr.Pointer() != nil {
		tmpValue := NewQGestureFromPointer(C.QGestureEvent___gestures_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) __gestures_setList(i QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___gestures_setList(ptr.Pointer(), PointerFromQGesture(i))
	}
}

func (ptr *QGestureEvent) __gestures_newList() unsafe.Pointer {
	return C.QGestureEvent___gestures_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __m_accepted_atList(v core.Qt__GestureType, i int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGestureEvent___m_accepted_atList(ptr.Pointer(), C.longlong(v), C.int(int32(i)))) != 0
	}
	return false
}

func (ptr *QGestureEvent) __m_accepted_setList(key core.Qt__GestureType, i bool) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___m_accepted_setList(ptr.Pointer(), C.longlong(key), C.char(int8(qt.GoBoolToInt(i))))
	}
}

func (ptr *QGestureEvent) __m_accepted_newList() unsafe.Pointer {
	return C.QGestureEvent___m_accepted_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __m_accepted_keyList() []core.Qt__GestureType {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []core.Qt__GestureType {
			out := make([]core.Qt__GestureType, int(l.len))
			tmpList := NewQGestureEventFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____m_accepted_keyList_atList(i)
			}
			return out
		}(C.QGestureEvent___m_accepted_keyList(ptr.Pointer()))
	}
	return make([]core.Qt__GestureType, 0)
}

func (ptr *QGestureEvent) __setM_accepted__atList(v core.Qt__GestureType, i int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGestureEvent___setM_accepted__atList(ptr.Pointer(), C.longlong(v), C.int(int32(i)))) != 0
	}
	return false
}

func (ptr *QGestureEvent) __setM_accepted__setList(key core.Qt__GestureType, i bool) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___setM_accepted__setList(ptr.Pointer(), C.longlong(key), C.char(int8(qt.GoBoolToInt(i))))
	}
}

func (ptr *QGestureEvent) __setM_accepted__newList() unsafe.Pointer {
	return C.QGestureEvent___setM_accepted__newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __setM_accepted__keyList() []core.Qt__GestureType {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []core.Qt__GestureType {
			out := make([]core.Qt__GestureType, int(l.len))
			tmpList := NewQGestureEventFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____setM_accepted__keyList_atList(i)
			}
			return out
		}(C.QGestureEvent___setM_accepted__keyList(ptr.Pointer()))
	}
	return make([]core.Qt__GestureType, 0)
}

func (ptr *QGestureEvent) __m_gestures_atList(i int) *QGesture {
	if ptr.Pointer() != nil {
		tmpValue := NewQGestureFromPointer(C.QGestureEvent___m_gestures_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) __m_gestures_setList(i QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___m_gestures_setList(ptr.Pointer(), PointerFromQGesture(i))
	}
}

func (ptr *QGestureEvent) __m_gestures_newList() unsafe.Pointer {
	return C.QGestureEvent___m_gestures_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __setM_gestures__atList(i int) *QGesture {
	if ptr.Pointer() != nil {
		tmpValue := NewQGestureFromPointer(C.QGestureEvent___setM_gestures__atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) __setM_gestures__setList(i QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___setM_gestures__setList(ptr.Pointer(), PointerFromQGesture(i))
	}
}

func (ptr *QGestureEvent) __setM_gestures__newList() unsafe.Pointer {
	return C.QGestureEvent___setM_gestures__newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __m_targetWidgets_atList(v core.Qt__GestureType, i int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QGestureEvent___m_targetWidgets_atList(ptr.Pointer(), C.longlong(v), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) __m_targetWidgets_setList(key core.Qt__GestureType, i QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___m_targetWidgets_setList(ptr.Pointer(), C.longlong(key), PointerFromQWidget(i))
	}
}

func (ptr *QGestureEvent) __m_targetWidgets_newList() unsafe.Pointer {
	return C.QGestureEvent___m_targetWidgets_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __m_targetWidgets_keyList() []core.Qt__GestureType {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []core.Qt__GestureType {
			out := make([]core.Qt__GestureType, int(l.len))
			tmpList := NewQGestureEventFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____m_targetWidgets_keyList_atList(i)
			}
			return out
		}(C.QGestureEvent___m_targetWidgets_keyList(ptr.Pointer()))
	}
	return make([]core.Qt__GestureType, 0)
}

func (ptr *QGestureEvent) __setM_targetWidgets__atList(v core.Qt__GestureType, i int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QGestureEvent___setM_targetWidgets__atList(ptr.Pointer(), C.longlong(v), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureEvent) __setM_targetWidgets__setList(key core.Qt__GestureType, i QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureEvent___setM_targetWidgets__setList(ptr.Pointer(), C.longlong(key), PointerFromQWidget(i))
	}
}

func (ptr *QGestureEvent) __setM_targetWidgets__newList() unsafe.Pointer {
	return C.QGestureEvent___setM_targetWidgets__newList(ptr.Pointer())
}

func (ptr *QGestureEvent) __setM_targetWidgets__keyList() []core.Qt__GestureType {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []core.Qt__GestureType {
			out := make([]core.Qt__GestureType, int(l.len))
			tmpList := NewQGestureEventFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____setM_targetWidgets__keyList_atList(i)
			}
			return out
		}(C.QGestureEvent___setM_targetWidgets__keyList(ptr.Pointer()))
	}
	return make([]core.Qt__GestureType, 0)
}

func (ptr *QGestureEvent) ____m_accepted_keyList_atList(i int) core.Qt__GestureType {
	if ptr.Pointer() != nil {
		return core.Qt__GestureType(C.QGestureEvent_____m_accepted_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return 0
}

func (ptr *QGestureEvent) ____m_accepted_keyList_setList(i core.Qt__GestureType) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_____m_accepted_keyList_setList(ptr.Pointer(), C.longlong(i))
	}
}

func (ptr *QGestureEvent) ____m_accepted_keyList_newList() unsafe.Pointer {
	return C.QGestureEvent_____m_accepted_keyList_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) ____setM_accepted__keyList_atList(i int) core.Qt__GestureType {
	if ptr.Pointer() != nil {
		return core.Qt__GestureType(C.QGestureEvent_____setM_accepted__keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return 0
}

func (ptr *QGestureEvent) ____setM_accepted__keyList_setList(i core.Qt__GestureType) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_____setM_accepted__keyList_setList(ptr.Pointer(), C.longlong(i))
	}
}

func (ptr *QGestureEvent) ____setM_accepted__keyList_newList() unsafe.Pointer {
	return C.QGestureEvent_____setM_accepted__keyList_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) ____m_targetWidgets_keyList_atList(i int) core.Qt__GestureType {
	if ptr.Pointer() != nil {
		return core.Qt__GestureType(C.QGestureEvent_____m_targetWidgets_keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return 0
}

func (ptr *QGestureEvent) ____m_targetWidgets_keyList_setList(i core.Qt__GestureType) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_____m_targetWidgets_keyList_setList(ptr.Pointer(), C.longlong(i))
	}
}

func (ptr *QGestureEvent) ____m_targetWidgets_keyList_newList() unsafe.Pointer {
	return C.QGestureEvent_____m_targetWidgets_keyList_newList(ptr.Pointer())
}

func (ptr *QGestureEvent) ____setM_targetWidgets__keyList_atList(i int) core.Qt__GestureType {
	if ptr.Pointer() != nil {
		return core.Qt__GestureType(C.QGestureEvent_____setM_targetWidgets__keyList_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return 0
}

func (ptr *QGestureEvent) ____setM_targetWidgets__keyList_setList(i core.Qt__GestureType) {
	if ptr.Pointer() != nil {
		C.QGestureEvent_____setM_targetWidgets__keyList_setList(ptr.Pointer(), C.longlong(i))
	}
}

func (ptr *QGestureEvent) ____setM_targetWidgets__keyList_newList() unsafe.Pointer {
	return C.QGestureEvent_____setM_targetWidgets__keyList_newList(ptr.Pointer())
}

type QGestureRecognizer struct {
	ptr unsafe.Pointer
}

type QGestureRecognizer_ITF interface {
	QGestureRecognizer_PTR() *QGestureRecognizer
}

func (ptr *QGestureRecognizer) QGestureRecognizer_PTR() *QGestureRecognizer {
	return ptr
}

func (ptr *QGestureRecognizer) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QGestureRecognizer) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQGestureRecognizer(ptr QGestureRecognizer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGestureRecognizer_PTR().Pointer()
	}
	return nil
}

func NewQGestureRecognizerFromPointer(ptr unsafe.Pointer) (n *QGestureRecognizer) {
	n = new(QGestureRecognizer)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGestureRecognizer__ResultFlag
//QGestureRecognizer::ResultFlag
type QGestureRecognizer__ResultFlag int64

const (
	QGestureRecognizer__Ignore           QGestureRecognizer__ResultFlag = QGestureRecognizer__ResultFlag(0x0001)
	QGestureRecognizer__MayBeGesture     QGestureRecognizer__ResultFlag = QGestureRecognizer__ResultFlag(0x0002)
	QGestureRecognizer__TriggerGesture   QGestureRecognizer__ResultFlag = QGestureRecognizer__ResultFlag(0x0004)
	QGestureRecognizer__FinishGesture    QGestureRecognizer__ResultFlag = QGestureRecognizer__ResultFlag(0x0008)
	QGestureRecognizer__CancelGesture    QGestureRecognizer__ResultFlag = QGestureRecognizer__ResultFlag(0x0010)
	QGestureRecognizer__ResultState_Mask QGestureRecognizer__ResultFlag = QGestureRecognizer__ResultFlag(0x00ff)
	QGestureRecognizer__ConsumeEventHint QGestureRecognizer__ResultFlag = QGestureRecognizer__ResultFlag(0x0100)
	QGestureRecognizer__ResultHint_Mask  QGestureRecognizer__ResultFlag = QGestureRecognizer__ResultFlag(0xff00)
)

//export callbackQGestureRecognizer_Create
func callbackQGestureRecognizer_Create(ptr unsafe.Pointer, target unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "create"); signal != nil {
		return PointerFromQGesture((*(*func(*core.QObject) *QGesture)(signal))(core.NewQObjectFromPointer(target)))
	}

	return PointerFromQGesture(NewQGestureRecognizerFromPointer(ptr).CreateDefault(core.NewQObjectFromPointer(target)))
}

func (ptr *QGestureRecognizer) ConnectCreate(f func(target *core.QObject) *QGesture) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "create"); signal != nil {
			f := func(target *core.QObject) *QGesture {
				(*(*func(*core.QObject) *QGesture)(signal))(target)
				return f(target)
			}
			qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGestureRecognizer) DisconnectCreate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "create")
	}
}

func (ptr *QGestureRecognizer) Create(target core.QObject_ITF) *QGesture {
	if ptr.Pointer() != nil {
		tmpValue := NewQGestureFromPointer(C.QGestureRecognizer_Create(ptr.Pointer(), core.PointerFromQObject(target)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGestureRecognizer) CreateDefault(target core.QObject_ITF) *QGesture {
	if ptr.Pointer() != nil {
		tmpValue := NewQGestureFromPointer(C.QGestureRecognizer_CreateDefault(ptr.Pointer(), core.PointerFromQObject(target)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQGestureRecognizer() *QGestureRecognizer {
	return NewQGestureRecognizerFromPointer(C.QGestureRecognizer_NewQGestureRecognizer())
}

//export callbackQGestureRecognizer_Recognize
func callbackQGestureRecognizer_Recognize(ptr unsafe.Pointer, gesture unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "recognize"); signal != nil {
		return C.longlong((*(*func(*QGesture, *core.QObject, *core.QEvent) QGestureRecognizer__ResultFlag)(signal))(NewQGestureFromPointer(gesture), core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))
	}

	return C.longlong(0)
}

func (ptr *QGestureRecognizer) ConnectRecognize(f func(gesture *QGesture, watched *core.QObject, event *core.QEvent) QGestureRecognizer__ResultFlag) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "recognize"); signal != nil {
			f := func(gesture *QGesture, watched *core.QObject, event *core.QEvent) QGestureRecognizer__ResultFlag {
				(*(*func(*QGesture, *core.QObject, *core.QEvent) QGestureRecognizer__ResultFlag)(signal))(gesture, watched, event)
				return f(gesture, watched, event)
			}
			qt.ConnectSignal(ptr.Pointer(), "recognize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "recognize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGestureRecognizer) DisconnectRecognize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "recognize")
	}
}

func (ptr *QGestureRecognizer) Recognize(gesture QGesture_ITF, watched core.QObject_ITF, event core.QEvent_ITF) QGestureRecognizer__ResultFlag {
	if ptr.Pointer() != nil {
		return QGestureRecognizer__ResultFlag(C.QGestureRecognizer_Recognize(ptr.Pointer(), PointerFromQGesture(gesture), core.PointerFromQObject(watched), core.PointerFromQEvent(event)))
	}
	return 0
}

func QGestureRecognizer_RegisterRecognizer(recognizer QGestureRecognizer_ITF) core.Qt__GestureType {
	return core.Qt__GestureType(C.QGestureRecognizer_QGestureRecognizer_RegisterRecognizer(PointerFromQGestureRecognizer(recognizer)))
}

func (ptr *QGestureRecognizer) RegisterRecognizer(recognizer QGestureRecognizer_ITF) core.Qt__GestureType {
	return core.Qt__GestureType(C.QGestureRecognizer_QGestureRecognizer_RegisterRecognizer(PointerFromQGestureRecognizer(recognizer)))
}

//export callbackQGestureRecognizer_Reset
func callbackQGestureRecognizer_Reset(ptr unsafe.Pointer, gesture unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "reset"); signal != nil {
		(*(*func(*QGesture))(signal))(NewQGestureFromPointer(gesture))
	} else {
		NewQGestureRecognizerFromPointer(ptr).ResetDefault(NewQGestureFromPointer(gesture))
	}
}

func (ptr *QGestureRecognizer) ConnectReset(f func(gesture *QGesture)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "reset"); signal != nil {
			f := func(gesture *QGesture) {
				(*(*func(*QGesture))(signal))(gesture)
				f(gesture)
			}
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGestureRecognizer) DisconnectReset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "reset")
	}
}

func (ptr *QGestureRecognizer) Reset(gesture QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureRecognizer_Reset(ptr.Pointer(), PointerFromQGesture(gesture))
	}
}

func (ptr *QGestureRecognizer) ResetDefault(gesture QGesture_ITF) {
	if ptr.Pointer() != nil {
		C.QGestureRecognizer_ResetDefault(ptr.Pointer(), PointerFromQGesture(gesture))
	}
}

func QGestureRecognizer_UnregisterRecognizer(ty core.Qt__GestureType) {
	C.QGestureRecognizer_QGestureRecognizer_UnregisterRecognizer(C.longlong(ty))
}

func (ptr *QGestureRecognizer) UnregisterRecognizer(ty core.Qt__GestureType) {
	C.QGestureRecognizer_QGestureRecognizer_UnregisterRecognizer(C.longlong(ty))
}

//export callbackQGestureRecognizer_DestroyQGestureRecognizer
func callbackQGestureRecognizer_DestroyQGestureRecognizer(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGestureRecognizer"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGestureRecognizerFromPointer(ptr).DestroyQGestureRecognizerDefault()
	}
}

func (ptr *QGestureRecognizer) ConnectDestroyQGestureRecognizer(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGestureRecognizer"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGestureRecognizer", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGestureRecognizer", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGestureRecognizer) DisconnectDestroyQGestureRecognizer() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGestureRecognizer")
	}
}

func (ptr *QGestureRecognizer) DestroyQGestureRecognizer() {
	if ptr.Pointer() != nil {
		C.QGestureRecognizer_DestroyQGestureRecognizer(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QGestureRecognizer) DestroyQGestureRecognizerDefault() {
	if ptr.Pointer() != nil {
		C.QGestureRecognizer_DestroyQGestureRecognizerDefault(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

type QGraphicsAnchor struct {
	core.QObject
}

type QGraphicsAnchor_ITF interface {
	core.QObject_ITF
	QGraphicsAnchor_PTR() *QGraphicsAnchor
}

func (ptr *QGraphicsAnchor) QGraphicsAnchor_PTR() *QGraphicsAnchor {
	return ptr
}

func (ptr *QGraphicsAnchor) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsAnchor) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsAnchor(ptr QGraphicsAnchor_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsAnchor_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsAnchorFromPointer(ptr unsafe.Pointer) (n *QGraphicsAnchor) {
	n = new(QGraphicsAnchor)
	n.SetPointer(ptr)
	return
}
func QGraphicsAnchor_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsAnchor_QGraphicsAnchor_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QGraphicsAnchor) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsAnchor_QGraphicsAnchor_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QGraphicsAnchor) SetSizePolicy(policy QSizePolicy__Policy) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_SetSizePolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QGraphicsAnchor) SetSpacing(spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_SetSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QGraphicsAnchor) UnsetSpacing() {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_UnsetSpacing(ptr.Pointer())
	}
}

//export callbackQGraphicsAnchor_DestroyQGraphicsAnchor
func callbackQGraphicsAnchor_DestroyQGraphicsAnchor(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsAnchor"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsAnchorFromPointer(ptr).DestroyQGraphicsAnchorDefault()
	}
}

func (ptr *QGraphicsAnchor) ConnectDestroyQGraphicsAnchor(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsAnchor"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsAnchor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsAnchor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsAnchor) DisconnectDestroyQGraphicsAnchor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsAnchor")
	}
}

func (ptr *QGraphicsAnchor) DestroyQGraphicsAnchor() {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_DestroyQGraphicsAnchor(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsAnchor) DestroyQGraphicsAnchorDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_DestroyQGraphicsAnchorDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsAnchor) SizePolicy() QSizePolicy__Policy {
	if ptr.Pointer() != nil {
		return QSizePolicy__Policy(C.QGraphicsAnchor_SizePolicy(ptr.Pointer()))
	}
	return 0
}

//export callbackQGraphicsAnchor_MetaObject
func callbackQGraphicsAnchor_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQGraphicsAnchorFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QGraphicsAnchor) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QGraphicsAnchor_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsAnchor) Spacing() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsAnchor_Spacing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsAnchor) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QGraphicsAnchor___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsAnchor) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QGraphicsAnchor) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QGraphicsAnchor___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QGraphicsAnchor) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsAnchor___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsAnchor) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsAnchor) __findChildren_newList2() unsafe.Pointer {
	return C.QGraphicsAnchor___findChildren_newList2(ptr.Pointer())
}

func (ptr *QGraphicsAnchor) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsAnchor___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsAnchor) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsAnchor) __findChildren_newList3() unsafe.Pointer {
	return C.QGraphicsAnchor___findChildren_newList3(ptr.Pointer())
}

func (ptr *QGraphicsAnchor) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsAnchor___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsAnchor) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsAnchor) __findChildren_newList() unsafe.Pointer {
	return C.QGraphicsAnchor___findChildren_newList(ptr.Pointer())
}

func (ptr *QGraphicsAnchor) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsAnchor___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsAnchor) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsAnchor) __children_newList() unsafe.Pointer {
	return C.QGraphicsAnchor___children_newList(ptr.Pointer())
}

//export callbackQGraphicsAnchor_Event
func callbackQGraphicsAnchor_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsAnchorFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QGraphicsAnchor) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsAnchor_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQGraphicsAnchor_EventFilter
func callbackQGraphicsAnchor_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsAnchorFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsAnchor) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsAnchor_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGraphicsAnchor_ChildEvent
func callbackQGraphicsAnchor_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQGraphicsAnchorFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QGraphicsAnchor) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQGraphicsAnchor_ConnectNotify
func callbackQGraphicsAnchor_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsAnchorFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsAnchor) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsAnchor_CustomEvent
func callbackQGraphicsAnchor_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsAnchorFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsAnchor) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsAnchor_DeleteLater
func callbackQGraphicsAnchor_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsAnchorFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QGraphicsAnchor) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsAnchor_Destroyed
func callbackQGraphicsAnchor_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQGraphicsAnchor_DisconnectNotify
func callbackQGraphicsAnchor_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsAnchorFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsAnchor) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsAnchor_ObjectNameChanged
func callbackQGraphicsAnchor_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQGraphicsAnchor_TimerEvent
func callbackQGraphicsAnchor_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQGraphicsAnchorFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QGraphicsAnchor) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchor_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QGraphicsAnchorLayout struct {
	QGraphicsLayout
}

type QGraphicsAnchorLayout_ITF interface {
	QGraphicsLayout_ITF
	QGraphicsAnchorLayout_PTR() *QGraphicsAnchorLayout
}

func (ptr *QGraphicsAnchorLayout) QGraphicsAnchorLayout_PTR() *QGraphicsAnchorLayout {
	return ptr
}

func (ptr *QGraphicsAnchorLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsLayout_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsAnchorLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsLayout_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsAnchorLayout(ptr QGraphicsAnchorLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsAnchorLayout_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsAnchorLayoutFromPointer(ptr unsafe.Pointer) (n *QGraphicsAnchorLayout) {
	n = new(QGraphicsAnchorLayout)
	n.SetPointer(ptr)
	return
}
func (ptr *QGraphicsAnchorLayout) AddAnchor(firstItem QGraphicsLayoutItem_ITF, firstEdge core.Qt__AnchorPoint, secondItem QGraphicsLayoutItem_ITF, secondEdge core.Qt__AnchorPoint) *QGraphicsAnchor {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsAnchorFromPointer(C.QGraphicsAnchorLayout_AddAnchor(ptr.Pointer(), PointerFromQGraphicsLayoutItem(firstItem), C.longlong(firstEdge), PointerFromQGraphicsLayoutItem(secondItem), C.longlong(secondEdge)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsAnchorLayout) Anchor(firstItem QGraphicsLayoutItem_ITF, firstEdge core.Qt__AnchorPoint, secondItem QGraphicsLayoutItem_ITF, secondEdge core.Qt__AnchorPoint) *QGraphicsAnchor {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsAnchorFromPointer(C.QGraphicsAnchorLayout_Anchor(ptr.Pointer(), PointerFromQGraphicsLayoutItem(firstItem), C.longlong(firstEdge), PointerFromQGraphicsLayoutItem(secondItem), C.longlong(secondEdge)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQGraphicsAnchorLayout(parent QGraphicsLayoutItem_ITF) *QGraphicsAnchorLayout {
	return NewQGraphicsAnchorLayoutFromPointer(C.QGraphicsAnchorLayout_NewQGraphicsAnchorLayout(PointerFromQGraphicsLayoutItem(parent)))
}

func (ptr *QGraphicsAnchorLayout) AddAnchors(firstItem QGraphicsLayoutItem_ITF, secondItem QGraphicsLayoutItem_ITF, orientations core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchorLayout_AddAnchors(ptr.Pointer(), PointerFromQGraphicsLayoutItem(firstItem), PointerFromQGraphicsLayoutItem(secondItem), C.longlong(orientations))
	}
}

func (ptr *QGraphicsAnchorLayout) AddCornerAnchors(firstItem QGraphicsLayoutItem_ITF, firstCorner core.Qt__Corner, secondItem QGraphicsLayoutItem_ITF, secondCorner core.Qt__Corner) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchorLayout_AddCornerAnchors(ptr.Pointer(), PointerFromQGraphicsLayoutItem(firstItem), C.longlong(firstCorner), PointerFromQGraphicsLayoutItem(secondItem), C.longlong(secondCorner))
	}
}

//export callbackQGraphicsAnchorLayout_RemoveAt
func callbackQGraphicsAnchorLayout_RemoveAt(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "removeAt"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQGraphicsAnchorLayoutFromPointer(ptr).RemoveAtDefault(int(int32(index)))
	}
}

func (ptr *QGraphicsAnchorLayout) ConnectRemoveAt(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "removeAt"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "removeAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "removeAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsAnchorLayout) DisconnectRemoveAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "removeAt")
	}
}

func (ptr *QGraphicsAnchorLayout) RemoveAt(index int) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchorLayout_RemoveAt(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QGraphicsAnchorLayout) RemoveAtDefault(index int) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchorLayout_RemoveAtDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QGraphicsAnchorLayout) SetHorizontalSpacing(spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchorLayout_SetHorizontalSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QGraphicsAnchorLayout) SetSpacing(spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchorLayout_SetSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QGraphicsAnchorLayout) SetVerticalSpacing(spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchorLayout_SetVerticalSpacing(ptr.Pointer(), C.double(spacing))
	}
}

//export callbackQGraphicsAnchorLayout_DestroyQGraphicsAnchorLayout
func callbackQGraphicsAnchorLayout_DestroyQGraphicsAnchorLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsAnchorLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsAnchorLayoutFromPointer(ptr).DestroyQGraphicsAnchorLayoutDefault()
	}
}

func (ptr *QGraphicsAnchorLayout) ConnectDestroyQGraphicsAnchorLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsAnchorLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsAnchorLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsAnchorLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsAnchorLayout) DisconnectDestroyQGraphicsAnchorLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsAnchorLayout")
	}
}

func (ptr *QGraphicsAnchorLayout) DestroyQGraphicsAnchorLayout() {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchorLayout_DestroyQGraphicsAnchorLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsAnchorLayout) DestroyQGraphicsAnchorLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsAnchorLayout_DestroyQGraphicsAnchorLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsAnchorLayout_ItemAt
func callbackQGraphicsAnchorLayout_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemAt"); signal != nil {
		return PointerFromQGraphicsLayoutItem((*(*func(int) *QGraphicsLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQGraphicsLayoutItem(NewQGraphicsAnchorLayoutFromPointer(ptr).ItemAtDefault(int(int32(index))))
}

func (ptr *QGraphicsAnchorLayout) ConnectItemAt(f func(index int) *QGraphicsLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemAt"); signal != nil {
			f := func(index int) *QGraphicsLayoutItem {
				(*(*func(int) *QGraphicsLayoutItem)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsAnchorLayout) DisconnectItemAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemAt")
	}
}

func (ptr *QGraphicsAnchorLayout) ItemAt(index int) *QGraphicsLayoutItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsLayoutItemFromPointer(C.QGraphicsAnchorLayout_ItemAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QGraphicsAnchorLayout) ItemAtDefault(index int) *QGraphicsLayoutItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsLayoutItemFromPointer(C.QGraphicsAnchorLayout_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

//export callbackQGraphicsAnchorLayout_SizeHint
func callbackQGraphicsAnchorLayout_SizeHint(ptr unsafe.Pointer, which C.longlong, constraint unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSizeF((*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
	}

	return core.PointerFromQSizeF(NewQGraphicsAnchorLayoutFromPointer(ptr).SizeHintDefault(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
}

func (ptr *QGraphicsAnchorLayout) ConnectSizeHint(f func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF {
				(*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(which, constraint)
				return f(which, constraint)
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsAnchorLayout) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QGraphicsAnchorLayout) SizeHint(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsAnchorLayout_SizeHint(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsAnchorLayout) SizeHintDefault(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsAnchorLayout_SizeHintDefault(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsAnchorLayout_Count
func callbackQGraphicsAnchorLayout_Count(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "count"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQGraphicsAnchorLayoutFromPointer(ptr).CountDefault()))
}

func (ptr *QGraphicsAnchorLayout) ConnectCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "count"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsAnchorLayout) DisconnectCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "count")
	}
}

func (ptr *QGraphicsAnchorLayout) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsAnchorLayout_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsAnchorLayout) CountDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsAnchorLayout_CountDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsAnchorLayout) HorizontalSpacing() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsAnchorLayout_HorizontalSpacing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsAnchorLayout) VerticalSpacing() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsAnchorLayout_VerticalSpacing(ptr.Pointer()))
	}
	return 0
}

type QGraphicsBlurEffect struct {
	QGraphicsEffect
}

type QGraphicsBlurEffect_ITF interface {
	QGraphicsEffect_ITF
	QGraphicsBlurEffect_PTR() *QGraphicsBlurEffect
}

func (ptr *QGraphicsBlurEffect) QGraphicsBlurEffect_PTR() *QGraphicsBlurEffect {
	return ptr
}

func (ptr *QGraphicsBlurEffect) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsEffect_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsBlurEffect) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsEffect_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsBlurEffect(ptr QGraphicsBlurEffect_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsBlurEffect_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsBlurEffectFromPointer(ptr unsafe.Pointer) (n *QGraphicsBlurEffect) {
	n = new(QGraphicsBlurEffect)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsBlurEffect__BlurHint
//QGraphicsBlurEffect::BlurHint
type QGraphicsBlurEffect__BlurHint int64

const (
	QGraphicsBlurEffect__PerformanceHint QGraphicsBlurEffect__BlurHint = QGraphicsBlurEffect__BlurHint(0x00)
	QGraphicsBlurEffect__QualityHint     QGraphicsBlurEffect__BlurHint = QGraphicsBlurEffect__BlurHint(0x01)
	QGraphicsBlurEffect__AnimationHint   QGraphicsBlurEffect__BlurHint = QGraphicsBlurEffect__BlurHint(0x02)
)

func NewQGraphicsBlurEffect(parent core.QObject_ITF) *QGraphicsBlurEffect {
	tmpValue := NewQGraphicsBlurEffectFromPointer(C.QGraphicsBlurEffect_NewQGraphicsBlurEffect(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQGraphicsBlurEffect_BlurHintsChanged
func callbackQGraphicsBlurEffect_BlurHintsChanged(ptr unsafe.Pointer, hints C.longlong) {
	if signal := qt.GetSignal(ptr, "blurHintsChanged"); signal != nil {
		(*(*func(QGraphicsBlurEffect__BlurHint))(signal))(QGraphicsBlurEffect__BlurHint(hints))
	}

}

func (ptr *QGraphicsBlurEffect) ConnectBlurHintsChanged(f func(hints QGraphicsBlurEffect__BlurHint)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "blurHintsChanged") {
			C.QGraphicsBlurEffect_ConnectBlurHintsChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "blurHintsChanged"); signal != nil {
			f := func(hints QGraphicsBlurEffect__BlurHint) {
				(*(*func(QGraphicsBlurEffect__BlurHint))(signal))(hints)
				f(hints)
			}
			qt.ConnectSignal(ptr.Pointer(), "blurHintsChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "blurHintsChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsBlurEffect) DisconnectBlurHintsChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_DisconnectBlurHintsChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "blurHintsChanged")
	}
}

func (ptr *QGraphicsBlurEffect) BlurHintsChanged(hints QGraphicsBlurEffect__BlurHint) {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_BlurHintsChanged(ptr.Pointer(), C.longlong(hints))
	}
}

//export callbackQGraphicsBlurEffect_BlurRadiusChanged
func callbackQGraphicsBlurEffect_BlurRadiusChanged(ptr unsafe.Pointer, radius C.double) {
	if signal := qt.GetSignal(ptr, "blurRadiusChanged"); signal != nil {
		(*(*func(float64))(signal))(float64(radius))
	}

}

func (ptr *QGraphicsBlurEffect) ConnectBlurRadiusChanged(f func(radius float64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "blurRadiusChanged") {
			C.QGraphicsBlurEffect_ConnectBlurRadiusChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "blurRadiusChanged"); signal != nil {
			f := func(radius float64) {
				(*(*func(float64))(signal))(radius)
				f(radius)
			}
			qt.ConnectSignal(ptr.Pointer(), "blurRadiusChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "blurRadiusChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsBlurEffect) DisconnectBlurRadiusChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_DisconnectBlurRadiusChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "blurRadiusChanged")
	}
}

func (ptr *QGraphicsBlurEffect) BlurRadiusChanged(radius float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_BlurRadiusChanged(ptr.Pointer(), C.double(radius))
	}
}

//export callbackQGraphicsBlurEffect_Draw
func callbackQGraphicsBlurEffect_Draw(ptr unsafe.Pointer, painter unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "draw"); signal != nil {
		(*(*func(*gui.QPainter))(signal))(gui.NewQPainterFromPointer(painter))
	} else {
		NewQGraphicsBlurEffectFromPointer(ptr).DrawDefault(gui.NewQPainterFromPointer(painter))
	}
}

func (ptr *QGraphicsBlurEffect) ConnectDraw(f func(painter *gui.QPainter)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "draw"); signal != nil {
			f := func(painter *gui.QPainter) {
				(*(*func(*gui.QPainter))(signal))(painter)
				f(painter)
			}
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsBlurEffect) DisconnectDraw() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "draw")
	}
}

func (ptr *QGraphicsBlurEffect) Draw(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_Draw(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

func (ptr *QGraphicsBlurEffect) DrawDefault(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_DrawDefault(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

//export callbackQGraphicsBlurEffect_SetBlurHints
func callbackQGraphicsBlurEffect_SetBlurHints(ptr unsafe.Pointer, hints C.longlong) {
	if signal := qt.GetSignal(ptr, "setBlurHints"); signal != nil {
		(*(*func(QGraphicsBlurEffect__BlurHint))(signal))(QGraphicsBlurEffect__BlurHint(hints))
	} else {
		NewQGraphicsBlurEffectFromPointer(ptr).SetBlurHintsDefault(QGraphicsBlurEffect__BlurHint(hints))
	}
}

func (ptr *QGraphicsBlurEffect) ConnectSetBlurHints(f func(hints QGraphicsBlurEffect__BlurHint)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setBlurHints"); signal != nil {
			f := func(hints QGraphicsBlurEffect__BlurHint) {
				(*(*func(QGraphicsBlurEffect__BlurHint))(signal))(hints)
				f(hints)
			}
			qt.ConnectSignal(ptr.Pointer(), "setBlurHints", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setBlurHints", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsBlurEffect) DisconnectSetBlurHints() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setBlurHints")
	}
}

func (ptr *QGraphicsBlurEffect) SetBlurHints(hints QGraphicsBlurEffect__BlurHint) {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_SetBlurHints(ptr.Pointer(), C.longlong(hints))
	}
}

func (ptr *QGraphicsBlurEffect) SetBlurHintsDefault(hints QGraphicsBlurEffect__BlurHint) {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_SetBlurHintsDefault(ptr.Pointer(), C.longlong(hints))
	}
}

//export callbackQGraphicsBlurEffect_SetBlurRadius
func callbackQGraphicsBlurEffect_SetBlurRadius(ptr unsafe.Pointer, blurRadius C.double) {
	if signal := qt.GetSignal(ptr, "setBlurRadius"); signal != nil {
		(*(*func(float64))(signal))(float64(blurRadius))
	} else {
		NewQGraphicsBlurEffectFromPointer(ptr).SetBlurRadiusDefault(float64(blurRadius))
	}
}

func (ptr *QGraphicsBlurEffect) ConnectSetBlurRadius(f func(blurRadius float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setBlurRadius"); signal != nil {
			f := func(blurRadius float64) {
				(*(*func(float64))(signal))(blurRadius)
				f(blurRadius)
			}
			qt.ConnectSignal(ptr.Pointer(), "setBlurRadius", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setBlurRadius", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsBlurEffect) DisconnectSetBlurRadius() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setBlurRadius")
	}
}

func (ptr *QGraphicsBlurEffect) SetBlurRadius(blurRadius float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_SetBlurRadius(ptr.Pointer(), C.double(blurRadius))
	}
}

func (ptr *QGraphicsBlurEffect) SetBlurRadiusDefault(blurRadius float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_SetBlurRadiusDefault(ptr.Pointer(), C.double(blurRadius))
	}
}

//export callbackQGraphicsBlurEffect_DestroyQGraphicsBlurEffect
func callbackQGraphicsBlurEffect_DestroyQGraphicsBlurEffect(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsBlurEffect"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsBlurEffectFromPointer(ptr).DestroyQGraphicsBlurEffectDefault()
	}
}

func (ptr *QGraphicsBlurEffect) ConnectDestroyQGraphicsBlurEffect(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsBlurEffect"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsBlurEffect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsBlurEffect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsBlurEffect) DisconnectDestroyQGraphicsBlurEffect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsBlurEffect")
	}
}

func (ptr *QGraphicsBlurEffect) DestroyQGraphicsBlurEffect() {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_DestroyQGraphicsBlurEffect(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsBlurEffect) DestroyQGraphicsBlurEffectDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsBlurEffect_DestroyQGraphicsBlurEffectDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsBlurEffect) BlurHints() QGraphicsBlurEffect__BlurHint {
	if ptr.Pointer() != nil {
		return QGraphicsBlurEffect__BlurHint(C.QGraphicsBlurEffect_BlurHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsBlurEffect) BlurRadius() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsBlurEffect_BlurRadius(ptr.Pointer()))
	}
	return 0
}

type QGraphicsColorizeEffect struct {
	QGraphicsEffect
}

type QGraphicsColorizeEffect_ITF interface {
	QGraphicsEffect_ITF
	QGraphicsColorizeEffect_PTR() *QGraphicsColorizeEffect
}

func (ptr *QGraphicsColorizeEffect) QGraphicsColorizeEffect_PTR() *QGraphicsColorizeEffect {
	return ptr
}

func (ptr *QGraphicsColorizeEffect) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsEffect_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsColorizeEffect) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsEffect_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsColorizeEffect(ptr QGraphicsColorizeEffect_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsColorizeEffect_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsColorizeEffectFromPointer(ptr unsafe.Pointer) (n *QGraphicsColorizeEffect) {
	n = new(QGraphicsColorizeEffect)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsColorizeEffect(parent core.QObject_ITF) *QGraphicsColorizeEffect {
	tmpValue := NewQGraphicsColorizeEffectFromPointer(C.QGraphicsColorizeEffect_NewQGraphicsColorizeEffect(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQGraphicsColorizeEffect_ColorChanged
func callbackQGraphicsColorizeEffect_ColorChanged(ptr unsafe.Pointer, color unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "colorChanged"); signal != nil {
		(*(*func(*gui.QColor))(signal))(gui.NewQColorFromPointer(color))
	}

}

func (ptr *QGraphicsColorizeEffect) ConnectColorChanged(f func(color *gui.QColor)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "colorChanged") {
			C.QGraphicsColorizeEffect_ConnectColorChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "colorChanged"); signal != nil {
			f := func(color *gui.QColor) {
				(*(*func(*gui.QColor))(signal))(color)
				f(color)
			}
			qt.ConnectSignal(ptr.Pointer(), "colorChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "colorChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsColorizeEffect) DisconnectColorChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_DisconnectColorChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "colorChanged")
	}
}

func (ptr *QGraphicsColorizeEffect) ColorChanged(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_ColorChanged(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

//export callbackQGraphicsColorizeEffect_Draw
func callbackQGraphicsColorizeEffect_Draw(ptr unsafe.Pointer, painter unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "draw"); signal != nil {
		(*(*func(*gui.QPainter))(signal))(gui.NewQPainterFromPointer(painter))
	} else {
		NewQGraphicsColorizeEffectFromPointer(ptr).DrawDefault(gui.NewQPainterFromPointer(painter))
	}
}

func (ptr *QGraphicsColorizeEffect) ConnectDraw(f func(painter *gui.QPainter)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "draw"); signal != nil {
			f := func(painter *gui.QPainter) {
				(*(*func(*gui.QPainter))(signal))(painter)
				f(painter)
			}
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsColorizeEffect) DisconnectDraw() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "draw")
	}
}

func (ptr *QGraphicsColorizeEffect) Draw(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_Draw(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

func (ptr *QGraphicsColorizeEffect) DrawDefault(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_DrawDefault(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

//export callbackQGraphicsColorizeEffect_SetColor
func callbackQGraphicsColorizeEffect_SetColor(ptr unsafe.Pointer, c unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setColor"); signal != nil {
		(*(*func(*gui.QColor))(signal))(gui.NewQColorFromPointer(c))
	} else {
		NewQGraphicsColorizeEffectFromPointer(ptr).SetColorDefault(gui.NewQColorFromPointer(c))
	}
}

func (ptr *QGraphicsColorizeEffect) ConnectSetColor(f func(c *gui.QColor)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setColor"); signal != nil {
			f := func(c *gui.QColor) {
				(*(*func(*gui.QColor))(signal))(c)
				f(c)
			}
			qt.ConnectSignal(ptr.Pointer(), "setColor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setColor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsColorizeEffect) DisconnectSetColor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setColor")
	}
}

func (ptr *QGraphicsColorizeEffect) SetColor(c gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_SetColor(ptr.Pointer(), gui.PointerFromQColor(c))
	}
}

func (ptr *QGraphicsColorizeEffect) SetColorDefault(c gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_SetColorDefault(ptr.Pointer(), gui.PointerFromQColor(c))
	}
}

//export callbackQGraphicsColorizeEffect_SetStrength
func callbackQGraphicsColorizeEffect_SetStrength(ptr unsafe.Pointer, strength C.double) {
	if signal := qt.GetSignal(ptr, "setStrength"); signal != nil {
		(*(*func(float64))(signal))(float64(strength))
	} else {
		NewQGraphicsColorizeEffectFromPointer(ptr).SetStrengthDefault(float64(strength))
	}
}

func (ptr *QGraphicsColorizeEffect) ConnectSetStrength(f func(strength float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setStrength"); signal != nil {
			f := func(strength float64) {
				(*(*func(float64))(signal))(strength)
				f(strength)
			}
			qt.ConnectSignal(ptr.Pointer(), "setStrength", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setStrength", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsColorizeEffect) DisconnectSetStrength() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setStrength")
	}
}

func (ptr *QGraphicsColorizeEffect) SetStrength(strength float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_SetStrength(ptr.Pointer(), C.double(strength))
	}
}

func (ptr *QGraphicsColorizeEffect) SetStrengthDefault(strength float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_SetStrengthDefault(ptr.Pointer(), C.double(strength))
	}
}

//export callbackQGraphicsColorizeEffect_StrengthChanged
func callbackQGraphicsColorizeEffect_StrengthChanged(ptr unsafe.Pointer, strength C.double) {
	if signal := qt.GetSignal(ptr, "strengthChanged"); signal != nil {
		(*(*func(float64))(signal))(float64(strength))
	}

}

func (ptr *QGraphicsColorizeEffect) ConnectStrengthChanged(f func(strength float64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "strengthChanged") {
			C.QGraphicsColorizeEffect_ConnectStrengthChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "strengthChanged"); signal != nil {
			f := func(strength float64) {
				(*(*func(float64))(signal))(strength)
				f(strength)
			}
			qt.ConnectSignal(ptr.Pointer(), "strengthChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "strengthChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsColorizeEffect) DisconnectStrengthChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_DisconnectStrengthChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "strengthChanged")
	}
}

func (ptr *QGraphicsColorizeEffect) StrengthChanged(strength float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_StrengthChanged(ptr.Pointer(), C.double(strength))
	}
}

//export callbackQGraphicsColorizeEffect_DestroyQGraphicsColorizeEffect
func callbackQGraphicsColorizeEffect_DestroyQGraphicsColorizeEffect(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsColorizeEffect"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsColorizeEffectFromPointer(ptr).DestroyQGraphicsColorizeEffectDefault()
	}
}

func (ptr *QGraphicsColorizeEffect) ConnectDestroyQGraphicsColorizeEffect(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsColorizeEffect"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsColorizeEffect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsColorizeEffect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsColorizeEffect) DisconnectDestroyQGraphicsColorizeEffect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsColorizeEffect")
	}
}

func (ptr *QGraphicsColorizeEffect) DestroyQGraphicsColorizeEffect() {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_DestroyQGraphicsColorizeEffect(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsColorizeEffect) DestroyQGraphicsColorizeEffectDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsColorizeEffect_DestroyQGraphicsColorizeEffectDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsColorizeEffect) Color() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QGraphicsColorizeEffect_Color(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsColorizeEffect) Strength() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsColorizeEffect_Strength(ptr.Pointer()))
	}
	return 0
}

type QGraphicsDropShadowEffect struct {
	QGraphicsEffect
}

type QGraphicsDropShadowEffect_ITF interface {
	QGraphicsEffect_ITF
	QGraphicsDropShadowEffect_PTR() *QGraphicsDropShadowEffect
}

func (ptr *QGraphicsDropShadowEffect) QGraphicsDropShadowEffect_PTR() *QGraphicsDropShadowEffect {
	return ptr
}

func (ptr *QGraphicsDropShadowEffect) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsEffect_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsDropShadowEffect) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsEffect_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsDropShadowEffect(ptr QGraphicsDropShadowEffect_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsDropShadowEffect_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsDropShadowEffectFromPointer(ptr unsafe.Pointer) (n *QGraphicsDropShadowEffect) {
	n = new(QGraphicsDropShadowEffect)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsDropShadowEffect(parent core.QObject_ITF) *QGraphicsDropShadowEffect {
	tmpValue := NewQGraphicsDropShadowEffectFromPointer(C.QGraphicsDropShadowEffect_NewQGraphicsDropShadowEffect(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQGraphicsDropShadowEffect_BlurRadiusChanged
func callbackQGraphicsDropShadowEffect_BlurRadiusChanged(ptr unsafe.Pointer, blurRadius C.double) {
	if signal := qt.GetSignal(ptr, "blurRadiusChanged"); signal != nil {
		(*(*func(float64))(signal))(float64(blurRadius))
	}

}

func (ptr *QGraphicsDropShadowEffect) ConnectBlurRadiusChanged(f func(blurRadius float64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "blurRadiusChanged") {
			C.QGraphicsDropShadowEffect_ConnectBlurRadiusChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "blurRadiusChanged"); signal != nil {
			f := func(blurRadius float64) {
				(*(*func(float64))(signal))(blurRadius)
				f(blurRadius)
			}
			qt.ConnectSignal(ptr.Pointer(), "blurRadiusChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "blurRadiusChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectBlurRadiusChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_DisconnectBlurRadiusChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "blurRadiusChanged")
	}
}

func (ptr *QGraphicsDropShadowEffect) BlurRadiusChanged(blurRadius float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_BlurRadiusChanged(ptr.Pointer(), C.double(blurRadius))
	}
}

//export callbackQGraphicsDropShadowEffect_ColorChanged
func callbackQGraphicsDropShadowEffect_ColorChanged(ptr unsafe.Pointer, color unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "colorChanged"); signal != nil {
		(*(*func(*gui.QColor))(signal))(gui.NewQColorFromPointer(color))
	}

}

func (ptr *QGraphicsDropShadowEffect) ConnectColorChanged(f func(color *gui.QColor)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "colorChanged") {
			C.QGraphicsDropShadowEffect_ConnectColorChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "colorChanged"); signal != nil {
			f := func(color *gui.QColor) {
				(*(*func(*gui.QColor))(signal))(color)
				f(color)
			}
			qt.ConnectSignal(ptr.Pointer(), "colorChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "colorChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectColorChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_DisconnectColorChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "colorChanged")
	}
}

func (ptr *QGraphicsDropShadowEffect) ColorChanged(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_ColorChanged(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

//export callbackQGraphicsDropShadowEffect_Draw
func callbackQGraphicsDropShadowEffect_Draw(ptr unsafe.Pointer, painter unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "draw"); signal != nil {
		(*(*func(*gui.QPainter))(signal))(gui.NewQPainterFromPointer(painter))
	} else {
		NewQGraphicsDropShadowEffectFromPointer(ptr).DrawDefault(gui.NewQPainterFromPointer(painter))
	}
}

func (ptr *QGraphicsDropShadowEffect) ConnectDraw(f func(painter *gui.QPainter)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "draw"); signal != nil {
			f := func(painter *gui.QPainter) {
				(*(*func(*gui.QPainter))(signal))(painter)
				f(painter)
			}
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectDraw() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "draw")
	}
}

func (ptr *QGraphicsDropShadowEffect) Draw(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_Draw(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

func (ptr *QGraphicsDropShadowEffect) DrawDefault(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_DrawDefault(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

//export callbackQGraphicsDropShadowEffect_OffsetChanged
func callbackQGraphicsDropShadowEffect_OffsetChanged(ptr unsafe.Pointer, offset unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "offsetChanged"); signal != nil {
		(*(*func(*core.QPointF))(signal))(core.NewQPointFFromPointer(offset))
	}

}

func (ptr *QGraphicsDropShadowEffect) ConnectOffsetChanged(f func(offset *core.QPointF)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "offsetChanged") {
			C.QGraphicsDropShadowEffect_ConnectOffsetChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "offsetChanged"); signal != nil {
			f := func(offset *core.QPointF) {
				(*(*func(*core.QPointF))(signal))(offset)
				f(offset)
			}
			qt.ConnectSignal(ptr.Pointer(), "offsetChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "offsetChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectOffsetChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_DisconnectOffsetChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "offsetChanged")
	}
}

func (ptr *QGraphicsDropShadowEffect) OffsetChanged(offset core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_OffsetChanged(ptr.Pointer(), core.PointerFromQPointF(offset))
	}
}

//export callbackQGraphicsDropShadowEffect_SetBlurRadius
func callbackQGraphicsDropShadowEffect_SetBlurRadius(ptr unsafe.Pointer, blurRadius C.double) {
	if signal := qt.GetSignal(ptr, "setBlurRadius"); signal != nil {
		(*(*func(float64))(signal))(float64(blurRadius))
	} else {
		NewQGraphicsDropShadowEffectFromPointer(ptr).SetBlurRadiusDefault(float64(blurRadius))
	}
}

func (ptr *QGraphicsDropShadowEffect) ConnectSetBlurRadius(f func(blurRadius float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setBlurRadius"); signal != nil {
			f := func(blurRadius float64) {
				(*(*func(float64))(signal))(blurRadius)
				f(blurRadius)
			}
			qt.ConnectSignal(ptr.Pointer(), "setBlurRadius", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setBlurRadius", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectSetBlurRadius() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setBlurRadius")
	}
}

func (ptr *QGraphicsDropShadowEffect) SetBlurRadius(blurRadius float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetBlurRadius(ptr.Pointer(), C.double(blurRadius))
	}
}

func (ptr *QGraphicsDropShadowEffect) SetBlurRadiusDefault(blurRadius float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetBlurRadiusDefault(ptr.Pointer(), C.double(blurRadius))
	}
}

//export callbackQGraphicsDropShadowEffect_SetColor
func callbackQGraphicsDropShadowEffect_SetColor(ptr unsafe.Pointer, color unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setColor"); signal != nil {
		(*(*func(*gui.QColor))(signal))(gui.NewQColorFromPointer(color))
	} else {
		NewQGraphicsDropShadowEffectFromPointer(ptr).SetColorDefault(gui.NewQColorFromPointer(color))
	}
}

func (ptr *QGraphicsDropShadowEffect) ConnectSetColor(f func(color *gui.QColor)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setColor"); signal != nil {
			f := func(color *gui.QColor) {
				(*(*func(*gui.QColor))(signal))(color)
				f(color)
			}
			qt.ConnectSignal(ptr.Pointer(), "setColor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setColor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectSetColor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setColor")
	}
}

func (ptr *QGraphicsDropShadowEffect) SetColor(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetColor(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

func (ptr *QGraphicsDropShadowEffect) SetColorDefault(color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetColorDefault(ptr.Pointer(), gui.PointerFromQColor(color))
	}
}

//export callbackQGraphicsDropShadowEffect_SetOffset
func callbackQGraphicsDropShadowEffect_SetOffset(ptr unsafe.Pointer, ofs unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setOffset"); signal != nil {
		(*(*func(*core.QPointF))(signal))(core.NewQPointFFromPointer(ofs))
	} else {
		NewQGraphicsDropShadowEffectFromPointer(ptr).SetOffsetDefault(core.NewQPointFFromPointer(ofs))
	}
}

func (ptr *QGraphicsDropShadowEffect) ConnectSetOffset(f func(ofs *core.QPointF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOffset"); signal != nil {
			f := func(ofs *core.QPointF) {
				(*(*func(*core.QPointF))(signal))(ofs)
				f(ofs)
			}
			qt.ConnectSignal(ptr.Pointer(), "setOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectSetOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOffset")
	}
}

func (ptr *QGraphicsDropShadowEffect) SetOffset(ofs core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetOffset(ptr.Pointer(), core.PointerFromQPointF(ofs))
	}
}

func (ptr *QGraphicsDropShadowEffect) SetOffsetDefault(ofs core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetOffsetDefault(ptr.Pointer(), core.PointerFromQPointF(ofs))
	}
}

//export callbackQGraphicsDropShadowEffect_SetOffset2
func callbackQGraphicsDropShadowEffect_SetOffset2(ptr unsafe.Pointer, d C.double) {
	if signal := qt.GetSignal(ptr, "setOffset2"); signal != nil {
		(*(*func(float64))(signal))(float64(d))
	} else {
		NewQGraphicsDropShadowEffectFromPointer(ptr).SetOffset2Default(float64(d))
	}
}

func (ptr *QGraphicsDropShadowEffect) ConnectSetOffset2(f func(d float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOffset2"); signal != nil {
			f := func(d float64) {
				(*(*func(float64))(signal))(d)
				f(d)
			}
			qt.ConnectSignal(ptr.Pointer(), "setOffset2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOffset2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectSetOffset2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOffset2")
	}
}

func (ptr *QGraphicsDropShadowEffect) SetOffset2(d float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetOffset2(ptr.Pointer(), C.double(d))
	}
}

func (ptr *QGraphicsDropShadowEffect) SetOffset2Default(d float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetOffset2Default(ptr.Pointer(), C.double(d))
	}
}

//export callbackQGraphicsDropShadowEffect_SetOffset3
func callbackQGraphicsDropShadowEffect_SetOffset3(ptr unsafe.Pointer, dx C.double, dy C.double) {
	if signal := qt.GetSignal(ptr, "setOffset3"); signal != nil {
		(*(*func(float64, float64))(signal))(float64(dx), float64(dy))
	} else {
		NewQGraphicsDropShadowEffectFromPointer(ptr).SetOffset3Default(float64(dx), float64(dy))
	}
}

func (ptr *QGraphicsDropShadowEffect) ConnectSetOffset3(f func(dx float64, dy float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOffset3"); signal != nil {
			f := func(dx float64, dy float64) {
				(*(*func(float64, float64))(signal))(dx, dy)
				f(dx, dy)
			}
			qt.ConnectSignal(ptr.Pointer(), "setOffset3", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOffset3", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectSetOffset3() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOffset3")
	}
}

func (ptr *QGraphicsDropShadowEffect) SetOffset3(dx float64, dy float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetOffset3(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

func (ptr *QGraphicsDropShadowEffect) SetOffset3Default(dx float64, dy float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetOffset3Default(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

//export callbackQGraphicsDropShadowEffect_SetXOffset
func callbackQGraphicsDropShadowEffect_SetXOffset(ptr unsafe.Pointer, dx C.double) {
	if signal := qt.GetSignal(ptr, "setXOffset"); signal != nil {
		(*(*func(float64))(signal))(float64(dx))
	} else {
		NewQGraphicsDropShadowEffectFromPointer(ptr).SetXOffsetDefault(float64(dx))
	}
}

func (ptr *QGraphicsDropShadowEffect) ConnectSetXOffset(f func(dx float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setXOffset"); signal != nil {
			f := func(dx float64) {
				(*(*func(float64))(signal))(dx)
				f(dx)
			}
			qt.ConnectSignal(ptr.Pointer(), "setXOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setXOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectSetXOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setXOffset")
	}
}

func (ptr *QGraphicsDropShadowEffect) SetXOffset(dx float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetXOffset(ptr.Pointer(), C.double(dx))
	}
}

func (ptr *QGraphicsDropShadowEffect) SetXOffsetDefault(dx float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetXOffsetDefault(ptr.Pointer(), C.double(dx))
	}
}

//export callbackQGraphicsDropShadowEffect_SetYOffset
func callbackQGraphicsDropShadowEffect_SetYOffset(ptr unsafe.Pointer, dy C.double) {
	if signal := qt.GetSignal(ptr, "setYOffset"); signal != nil {
		(*(*func(float64))(signal))(float64(dy))
	} else {
		NewQGraphicsDropShadowEffectFromPointer(ptr).SetYOffsetDefault(float64(dy))
	}
}

func (ptr *QGraphicsDropShadowEffect) ConnectSetYOffset(f func(dy float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setYOffset"); signal != nil {
			f := func(dy float64) {
				(*(*func(float64))(signal))(dy)
				f(dy)
			}
			qt.ConnectSignal(ptr.Pointer(), "setYOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setYOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectSetYOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setYOffset")
	}
}

func (ptr *QGraphicsDropShadowEffect) SetYOffset(dy float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetYOffset(ptr.Pointer(), C.double(dy))
	}
}

func (ptr *QGraphicsDropShadowEffect) SetYOffsetDefault(dy float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_SetYOffsetDefault(ptr.Pointer(), C.double(dy))
	}
}

//export callbackQGraphicsDropShadowEffect_DestroyQGraphicsDropShadowEffect
func callbackQGraphicsDropShadowEffect_DestroyQGraphicsDropShadowEffect(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsDropShadowEffect"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsDropShadowEffectFromPointer(ptr).DestroyQGraphicsDropShadowEffectDefault()
	}
}

func (ptr *QGraphicsDropShadowEffect) ConnectDestroyQGraphicsDropShadowEffect(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsDropShadowEffect"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsDropShadowEffect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsDropShadowEffect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsDropShadowEffect) DisconnectDestroyQGraphicsDropShadowEffect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsDropShadowEffect")
	}
}

func (ptr *QGraphicsDropShadowEffect) DestroyQGraphicsDropShadowEffect() {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_DestroyQGraphicsDropShadowEffect(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsDropShadowEffect) DestroyQGraphicsDropShadowEffectDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsDropShadowEffect_DestroyQGraphicsDropShadowEffectDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsDropShadowEffect) Color() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QGraphicsDropShadowEffect_Color(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsDropShadowEffect) Offset() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsDropShadowEffect_Offset(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsDropShadowEffect) BlurRadius() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsDropShadowEffect_BlurRadius(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsDropShadowEffect) XOffset() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsDropShadowEffect_XOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsDropShadowEffect) YOffset() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsDropShadowEffect_YOffset(ptr.Pointer()))
	}
	return 0
}

type QGraphicsEffect struct {
	core.QObject
}

type QGraphicsEffect_ITF interface {
	core.QObject_ITF
	QGraphicsEffect_PTR() *QGraphicsEffect
}

func (ptr *QGraphicsEffect) QGraphicsEffect_PTR() *QGraphicsEffect {
	return ptr
}

func (ptr *QGraphicsEffect) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsEffect) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsEffect(ptr QGraphicsEffect_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsEffect_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsEffectFromPointer(ptr unsafe.Pointer) (n *QGraphicsEffect) {
	n = new(QGraphicsEffect)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsEffect__ChangeFlag
//QGraphicsEffect::ChangeFlag
type QGraphicsEffect__ChangeFlag int64

const (
	QGraphicsEffect__SourceAttached            QGraphicsEffect__ChangeFlag = QGraphicsEffect__ChangeFlag(0x1)
	QGraphicsEffect__SourceDetached            QGraphicsEffect__ChangeFlag = QGraphicsEffect__ChangeFlag(0x2)
	QGraphicsEffect__SourceBoundingRectChanged QGraphicsEffect__ChangeFlag = QGraphicsEffect__ChangeFlag(0x4)
	QGraphicsEffect__SourceInvalidated         QGraphicsEffect__ChangeFlag = QGraphicsEffect__ChangeFlag(0x8)
)

//go:generate stringer -type=QGraphicsEffect__PixmapPadMode
//QGraphicsEffect::PixmapPadMode
type QGraphicsEffect__PixmapPadMode int64

const (
	QGraphicsEffect__NoPad                      QGraphicsEffect__PixmapPadMode = QGraphicsEffect__PixmapPadMode(0)
	QGraphicsEffect__PadToTransparentBorder     QGraphicsEffect__PixmapPadMode = QGraphicsEffect__PixmapPadMode(1)
	QGraphicsEffect__PadToEffectiveBoundingRect QGraphicsEffect__PixmapPadMode = QGraphicsEffect__PixmapPadMode(2)
)

func NewQGraphicsEffect(parent core.QObject_ITF) *QGraphicsEffect {
	tmpValue := NewQGraphicsEffectFromPointer(C.QGraphicsEffect_NewQGraphicsEffect(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QGraphicsEffect_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsEffect_QGraphicsEffect_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QGraphicsEffect) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsEffect_QGraphicsEffect_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQGraphicsEffect_Draw
func callbackQGraphicsEffect_Draw(ptr unsafe.Pointer, painter unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "draw"); signal != nil {
		(*(*func(*gui.QPainter))(signal))(gui.NewQPainterFromPointer(painter))
	}

}

func (ptr *QGraphicsEffect) ConnectDraw(f func(painter *gui.QPainter)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "draw"); signal != nil {
			f := func(painter *gui.QPainter) {
				(*(*func(*gui.QPainter))(signal))(painter)
				f(painter)
			}
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEffect) DisconnectDraw() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "draw")
	}
}

func (ptr *QGraphicsEffect) Draw(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_Draw(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

func (ptr *QGraphicsEffect) DrawSource(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_DrawSource(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

//export callbackQGraphicsEffect_EnabledChanged
func callbackQGraphicsEffect_EnabledChanged(ptr unsafe.Pointer, enabled C.char) {
	if signal := qt.GetSignal(ptr, "enabledChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(enabled) != 0)
	}

}

func (ptr *QGraphicsEffect) ConnectEnabledChanged(f func(enabled bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "enabledChanged") {
			C.QGraphicsEffect_ConnectEnabledChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "enabledChanged"); signal != nil {
			f := func(enabled bool) {
				(*(*func(bool))(signal))(enabled)
				f(enabled)
			}
			qt.ConnectSignal(ptr.Pointer(), "enabledChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "enabledChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEffect) DisconnectEnabledChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_DisconnectEnabledChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "enabledChanged")
	}
}

func (ptr *QGraphicsEffect) EnabledChanged(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_EnabledChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

//export callbackQGraphicsEffect_SetEnabled
func callbackQGraphicsEffect_SetEnabled(ptr unsafe.Pointer, enable C.char) {
	if signal := qt.GetSignal(ptr, "setEnabled"); signal != nil {
		(*(*func(bool))(signal))(int8(enable) != 0)
	} else {
		NewQGraphicsEffectFromPointer(ptr).SetEnabledDefault(int8(enable) != 0)
	}
}

func (ptr *QGraphicsEffect) ConnectSetEnabled(f func(enable bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setEnabled"); signal != nil {
			f := func(enable bool) {
				(*(*func(bool))(signal))(enable)
				f(enable)
			}
			qt.ConnectSignal(ptr.Pointer(), "setEnabled", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setEnabled", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEffect) DisconnectSetEnabled() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setEnabled")
	}
}

func (ptr *QGraphicsEffect) SetEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_SetEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QGraphicsEffect) SetEnabledDefault(enable bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_SetEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQGraphicsEffect_SourceChanged
func callbackQGraphicsEffect_SourceChanged(ptr unsafe.Pointer, flags C.longlong) {
	if signal := qt.GetSignal(ptr, "sourceChanged"); signal != nil {
		(*(*func(QGraphicsEffect__ChangeFlag))(signal))(QGraphicsEffect__ChangeFlag(flags))
	} else {
		NewQGraphicsEffectFromPointer(ptr).SourceChangedDefault(QGraphicsEffect__ChangeFlag(flags))
	}
}

func (ptr *QGraphicsEffect) ConnectSourceChanged(f func(flags QGraphicsEffect__ChangeFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sourceChanged"); signal != nil {
			f := func(flags QGraphicsEffect__ChangeFlag) {
				(*(*func(QGraphicsEffect__ChangeFlag))(signal))(flags)
				f(flags)
			}
			qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEffect) DisconnectSourceChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sourceChanged")
	}
}

func (ptr *QGraphicsEffect) SourceChanged(flags QGraphicsEffect__ChangeFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_SourceChanged(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QGraphicsEffect) SourceChangedDefault(flags QGraphicsEffect__ChangeFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_SourceChangedDefault(ptr.Pointer(), C.longlong(flags))
	}
}

//export callbackQGraphicsEffect_Update
func callbackQGraphicsEffect_Update(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "update"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsEffectFromPointer(ptr).UpdateDefault()
	}
}

func (ptr *QGraphicsEffect) ConnectUpdate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "update"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "update", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "update", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEffect) DisconnectUpdate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "update")
	}
}

func (ptr *QGraphicsEffect) Update() {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_Update(ptr.Pointer())
	}
}

func (ptr *QGraphicsEffect) UpdateDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_UpdateDefault(ptr.Pointer())
	}
}

func (ptr *QGraphicsEffect) UpdateBoundingRect() {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_UpdateBoundingRect(ptr.Pointer())
	}
}

//export callbackQGraphicsEffect_DestroyQGraphicsEffect
func callbackQGraphicsEffect_DestroyQGraphicsEffect(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsEffect"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsEffectFromPointer(ptr).DestroyQGraphicsEffectDefault()
	}
}

func (ptr *QGraphicsEffect) ConnectDestroyQGraphicsEffect(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsEffect"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsEffect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsEffect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEffect) DisconnectDestroyQGraphicsEffect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsEffect")
	}
}

func (ptr *QGraphicsEffect) DestroyQGraphicsEffect() {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_DestroyQGraphicsEffect(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsEffect) DestroyQGraphicsEffectDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_DestroyQGraphicsEffectDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsEffect) SourcePixmap(system core.Qt__CoordinateSystem, offset core.QPoint_ITF, mode QGraphicsEffect__PixmapPadMode) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QGraphicsEffect_SourcePixmap(ptr.Pointer(), C.longlong(system), core.PointerFromQPoint(offset), C.longlong(mode)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEffect) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsEffect_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsEffect_BoundingRectFor
func callbackQGraphicsEffect_BoundingRectFor(ptr unsafe.Pointer, rect unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRectFor"); signal != nil {
		return core.PointerFromQRectF((*(*func(*core.QRectF) *core.QRectF)(signal))(core.NewQRectFFromPointer(rect)))
	}

	return core.PointerFromQRectF(NewQGraphicsEffectFromPointer(ptr).BoundingRectForDefault(core.NewQRectFFromPointer(rect)))
}

func (ptr *QGraphicsEffect) ConnectBoundingRectFor(f func(rect *core.QRectF) *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRectFor"); signal != nil {
			f := func(rect *core.QRectF) *core.QRectF {
				(*(*func(*core.QRectF) *core.QRectF)(signal))(rect)
				return f(rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRectFor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRectFor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEffect) DisconnectBoundingRectFor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRectFor")
	}
}

func (ptr *QGraphicsEffect) BoundingRectFor(rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsEffect_BoundingRectFor(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEffect) BoundingRectForDefault(rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsEffect_BoundingRectForDefault(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEffect) SourceBoundingRect(system core.Qt__CoordinateSystem) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsEffect_SourceBoundingRect(ptr.Pointer(), C.longlong(system)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEffect) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsEffect_IsEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsEffect) SourceIsPixmap() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsEffect_SourceIsPixmap(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQGraphicsEffect_MetaObject
func callbackQGraphicsEffect_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQGraphicsEffectFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QGraphicsEffect) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QGraphicsEffect_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsEffect) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QGraphicsEffect___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEffect) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QGraphicsEffect) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QGraphicsEffect___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QGraphicsEffect) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsEffect___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEffect) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsEffect) __findChildren_newList2() unsafe.Pointer {
	return C.QGraphicsEffect___findChildren_newList2(ptr.Pointer())
}

func (ptr *QGraphicsEffect) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsEffect___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEffect) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsEffect) __findChildren_newList3() unsafe.Pointer {
	return C.QGraphicsEffect___findChildren_newList3(ptr.Pointer())
}

func (ptr *QGraphicsEffect) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsEffect___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEffect) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsEffect) __findChildren_newList() unsafe.Pointer {
	return C.QGraphicsEffect___findChildren_newList(ptr.Pointer())
}

func (ptr *QGraphicsEffect) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsEffect___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEffect) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsEffect) __children_newList() unsafe.Pointer {
	return C.QGraphicsEffect___children_newList(ptr.Pointer())
}

//export callbackQGraphicsEffect_Event
func callbackQGraphicsEffect_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsEffectFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QGraphicsEffect) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsEffect_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQGraphicsEffect_EventFilter
func callbackQGraphicsEffect_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsEffectFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsEffect) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsEffect_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGraphicsEffect_ChildEvent
func callbackQGraphicsEffect_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQGraphicsEffectFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QGraphicsEffect) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQGraphicsEffect_ConnectNotify
func callbackQGraphicsEffect_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsEffectFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsEffect) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsEffect_CustomEvent
func callbackQGraphicsEffect_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsEffectFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsEffect) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsEffect_DeleteLater
func callbackQGraphicsEffect_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsEffectFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QGraphicsEffect) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsEffect_Destroyed
func callbackQGraphicsEffect_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQGraphicsEffect_DisconnectNotify
func callbackQGraphicsEffect_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsEffectFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsEffect) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsEffect_ObjectNameChanged
func callbackQGraphicsEffect_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQGraphicsEffect_TimerEvent
func callbackQGraphicsEffect_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQGraphicsEffectFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QGraphicsEffect) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEffect_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QGraphicsEllipseItem struct {
	QAbstractGraphicsShapeItem
}

type QGraphicsEllipseItem_ITF interface {
	QAbstractGraphicsShapeItem_ITF
	QGraphicsEllipseItem_PTR() *QGraphicsEllipseItem
}

func (ptr *QGraphicsEllipseItem) QGraphicsEllipseItem_PTR() *QGraphicsEllipseItem {
	return ptr
}

func (ptr *QGraphicsEllipseItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractGraphicsShapeItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsEllipseItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractGraphicsShapeItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsEllipseItem(ptr QGraphicsEllipseItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsEllipseItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsEllipseItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsEllipseItem) {
	n = new(QGraphicsEllipseItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsEllipseItem__anonymous
//QGraphicsEllipseItem::anonymous
type QGraphicsEllipseItem__anonymous int64

const (
	QGraphicsEllipseItem__Type QGraphicsEllipseItem__anonymous = QGraphicsEllipseItem__anonymous(4)
)

func NewQGraphicsEllipseItem(parent QGraphicsItem_ITF) *QGraphicsEllipseItem {
	return NewQGraphicsEllipseItemFromPointer(C.QGraphicsEllipseItem_NewQGraphicsEllipseItem(PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsEllipseItem2(rect core.QRectF_ITF, parent QGraphicsItem_ITF) *QGraphicsEllipseItem {
	return NewQGraphicsEllipseItemFromPointer(C.QGraphicsEllipseItem_NewQGraphicsEllipseItem2(core.PointerFromQRectF(rect), PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsEllipseItem3(x float64, y float64, width float64, height float64, parent QGraphicsItem_ITF) *QGraphicsEllipseItem {
	return NewQGraphicsEllipseItemFromPointer(C.QGraphicsEllipseItem_NewQGraphicsEllipseItem3(C.double(x), C.double(y), C.double(width), C.double(height), PointerFromQGraphicsItem(parent)))
}

//export callbackQGraphicsEllipseItem_Paint
func callbackQGraphicsEllipseItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsEllipseItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsEllipseItem) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEllipseItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsEllipseItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEllipseItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsEllipseItem) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEllipseItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsEllipseItem) SetRect(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsEllipseItem_SetRect(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsEllipseItem) SetRect2(x float64, y float64, width float64, height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsEllipseItem_SetRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height))
	}
}

func (ptr *QGraphicsEllipseItem) SetSpanAngle(angle int) {
	if ptr.Pointer() != nil {
		C.QGraphicsEllipseItem_SetSpanAngle(ptr.Pointer(), C.int(int32(angle)))
	}
}

func (ptr *QGraphicsEllipseItem) SetStartAngle(angle int) {
	if ptr.Pointer() != nil {
		C.QGraphicsEllipseItem_SetStartAngle(ptr.Pointer(), C.int(int32(angle)))
	}
}

//export callbackQGraphicsEllipseItem_DestroyQGraphicsEllipseItem
func callbackQGraphicsEllipseItem_DestroyQGraphicsEllipseItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsEllipseItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsEllipseItemFromPointer(ptr).DestroyQGraphicsEllipseItemDefault()
	}
}

func (ptr *QGraphicsEllipseItem) ConnectDestroyQGraphicsEllipseItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsEllipseItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsEllipseItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsEllipseItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEllipseItem) DisconnectDestroyQGraphicsEllipseItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsEllipseItem")
	}
}

func (ptr *QGraphicsEllipseItem) DestroyQGraphicsEllipseItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsEllipseItem_DestroyQGraphicsEllipseItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsEllipseItem) DestroyQGraphicsEllipseItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsEllipseItem_DestroyQGraphicsEllipseItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsEllipseItem_BoundingRect
func callbackQGraphicsEllipseItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsEllipseItemFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsEllipseItem) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsEllipseItem) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsEllipseItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsEllipseItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEllipseItem) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsEllipseItem_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEllipseItem) Rect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsEllipseItem_Rect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsEllipseItem) SpanAngle() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsEllipseItem_SpanAngle(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsEllipseItem) StartAngle() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsEllipseItem_StartAngle(ptr.Pointer())))
	}
	return 0
}

type QGraphicsGridLayout struct {
	QGraphicsLayout
}

type QGraphicsGridLayout_ITF interface {
	QGraphicsLayout_ITF
	QGraphicsGridLayout_PTR() *QGraphicsGridLayout
}

func (ptr *QGraphicsGridLayout) QGraphicsGridLayout_PTR() *QGraphicsGridLayout {
	return ptr
}

func (ptr *QGraphicsGridLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsLayout_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsGridLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsLayout_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsGridLayout(ptr QGraphicsGridLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsGridLayout_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsGridLayoutFromPointer(ptr unsafe.Pointer) (n *QGraphicsGridLayout) {
	n = new(QGraphicsGridLayout)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsGridLayout(parent QGraphicsLayoutItem_ITF) *QGraphicsGridLayout {
	return NewQGraphicsGridLayoutFromPointer(C.QGraphicsGridLayout_NewQGraphicsGridLayout(PointerFromQGraphicsLayoutItem(parent)))
}

func (ptr *QGraphicsGridLayout) AddItem2(item QGraphicsLayoutItem_ITF, row int, column int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_AddItem2(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item), C.int(int32(row)), C.int(int32(column)), C.longlong(alignment))
	}
}

func (ptr *QGraphicsGridLayout) AddItem(item QGraphicsLayoutItem_ITF, row int, column int, rowSpan int, columnSpan int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_AddItem(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item), C.int(int32(row)), C.int(int32(column)), C.int(int32(rowSpan)), C.int(int32(columnSpan)), C.longlong(alignment))
	}
}

//export callbackQGraphicsGridLayout_RemoveAt
func callbackQGraphicsGridLayout_RemoveAt(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "removeAt"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQGraphicsGridLayoutFromPointer(ptr).RemoveAtDefault(int(int32(index)))
	}
}

func (ptr *QGraphicsGridLayout) ConnectRemoveAt(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "removeAt"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "removeAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "removeAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsGridLayout) DisconnectRemoveAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "removeAt")
	}
}

func (ptr *QGraphicsGridLayout) RemoveAt(index int) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_RemoveAt(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QGraphicsGridLayout) RemoveAtDefault(index int) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_RemoveAtDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QGraphicsGridLayout) RemoveItem(item QGraphicsLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_RemoveItem(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item))
	}
}

func (ptr *QGraphicsGridLayout) SetAlignment(item QGraphicsLayoutItem_ITF, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetAlignment(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item), C.longlong(alignment))
	}
}

func (ptr *QGraphicsGridLayout) SetColumnAlignment(column int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetColumnAlignment(ptr.Pointer(), C.int(int32(column)), C.longlong(alignment))
	}
}

func (ptr *QGraphicsGridLayout) SetColumnFixedWidth(column int, width float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetColumnFixedWidth(ptr.Pointer(), C.int(int32(column)), C.double(width))
	}
}

func (ptr *QGraphicsGridLayout) SetColumnMaximumWidth(column int, width float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetColumnMaximumWidth(ptr.Pointer(), C.int(int32(column)), C.double(width))
	}
}

func (ptr *QGraphicsGridLayout) SetColumnMinimumWidth(column int, width float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetColumnMinimumWidth(ptr.Pointer(), C.int(int32(column)), C.double(width))
	}
}

func (ptr *QGraphicsGridLayout) SetColumnPreferredWidth(column int, width float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetColumnPreferredWidth(ptr.Pointer(), C.int(int32(column)), C.double(width))
	}
}

func (ptr *QGraphicsGridLayout) SetColumnSpacing(column int, spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetColumnSpacing(ptr.Pointer(), C.int(int32(column)), C.double(spacing))
	}
}

func (ptr *QGraphicsGridLayout) SetColumnStretchFactor(column int, stretch int) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetColumnStretchFactor(ptr.Pointer(), C.int(int32(column)), C.int(int32(stretch)))
	}
}

func (ptr *QGraphicsGridLayout) SetHorizontalSpacing(spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetHorizontalSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QGraphicsGridLayout) SetRowAlignment(row int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetRowAlignment(ptr.Pointer(), C.int(int32(row)), C.longlong(alignment))
	}
}

func (ptr *QGraphicsGridLayout) SetRowFixedHeight(row int, height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetRowFixedHeight(ptr.Pointer(), C.int(int32(row)), C.double(height))
	}
}

func (ptr *QGraphicsGridLayout) SetRowMaximumHeight(row int, height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetRowMaximumHeight(ptr.Pointer(), C.int(int32(row)), C.double(height))
	}
}

func (ptr *QGraphicsGridLayout) SetRowMinimumHeight(row int, height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetRowMinimumHeight(ptr.Pointer(), C.int(int32(row)), C.double(height))
	}
}

func (ptr *QGraphicsGridLayout) SetRowPreferredHeight(row int, height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetRowPreferredHeight(ptr.Pointer(), C.int(int32(row)), C.double(height))
	}
}

func (ptr *QGraphicsGridLayout) SetRowSpacing(row int, spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetRowSpacing(ptr.Pointer(), C.int(int32(row)), C.double(spacing))
	}
}

func (ptr *QGraphicsGridLayout) SetRowStretchFactor(row int, stretch int) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetRowStretchFactor(ptr.Pointer(), C.int(int32(row)), C.int(int32(stretch)))
	}
}

func (ptr *QGraphicsGridLayout) SetSpacing(spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QGraphicsGridLayout) SetVerticalSpacing(spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_SetVerticalSpacing(ptr.Pointer(), C.double(spacing))
	}
}

//export callbackQGraphicsGridLayout_DestroyQGraphicsGridLayout
func callbackQGraphicsGridLayout_DestroyQGraphicsGridLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsGridLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsGridLayoutFromPointer(ptr).DestroyQGraphicsGridLayoutDefault()
	}
}

func (ptr *QGraphicsGridLayout) ConnectDestroyQGraphicsGridLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsGridLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsGridLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsGridLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsGridLayout) DisconnectDestroyQGraphicsGridLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsGridLayout")
	}
}

func (ptr *QGraphicsGridLayout) DestroyQGraphicsGridLayout() {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_DestroyQGraphicsGridLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsGridLayout) DestroyQGraphicsGridLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsGridLayout_DestroyQGraphicsGridLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsGridLayout_SizeHint
func callbackQGraphicsGridLayout_SizeHint(ptr unsafe.Pointer, which C.longlong, constraint unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSizeF((*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
	}

	return core.PointerFromQSizeF(NewQGraphicsGridLayoutFromPointer(ptr).SizeHintDefault(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
}

func (ptr *QGraphicsGridLayout) ConnectSizeHint(f func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF {
				(*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(which, constraint)
				return f(which, constraint)
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsGridLayout) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QGraphicsGridLayout) SizeHint(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsGridLayout_SizeHint(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsGridLayout) SizeHintDefault(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsGridLayout_SizeHintDefault(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsGridLayout) Alignment(item QGraphicsLayoutItem_ITF) core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QGraphicsGridLayout_Alignment(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item)))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) ColumnAlignment(column int) core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QGraphicsGridLayout_ColumnAlignment(ptr.Pointer(), C.int(int32(column))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) RowAlignment(row int) core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QGraphicsGridLayout_RowAlignment(ptr.Pointer(), C.int(int32(row))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) ColumnCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsGridLayout_ColumnCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) ColumnStretchFactor(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsGridLayout_ColumnStretchFactor(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

//export callbackQGraphicsGridLayout_Count
func callbackQGraphicsGridLayout_Count(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "count"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQGraphicsGridLayoutFromPointer(ptr).CountDefault()))
}

func (ptr *QGraphicsGridLayout) ConnectCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "count"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsGridLayout) DisconnectCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "count")
	}
}

func (ptr *QGraphicsGridLayout) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsGridLayout_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) CountDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsGridLayout_CountDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) RowCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsGridLayout_RowCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) RowStretchFactor(row int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsGridLayout_RowStretchFactor(ptr.Pointer(), C.int(int32(row)))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) ColumnMaximumWidth(column int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_ColumnMaximumWidth(ptr.Pointer(), C.int(int32(column))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) ColumnMinimumWidth(column int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_ColumnMinimumWidth(ptr.Pointer(), C.int(int32(column))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) ColumnPreferredWidth(column int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_ColumnPreferredWidth(ptr.Pointer(), C.int(int32(column))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) ColumnSpacing(column int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_ColumnSpacing(ptr.Pointer(), C.int(int32(column))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) HorizontalSpacing() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_HorizontalSpacing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) RowMaximumHeight(row int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_RowMaximumHeight(ptr.Pointer(), C.int(int32(row))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) RowMinimumHeight(row int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_RowMinimumHeight(ptr.Pointer(), C.int(int32(row))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) RowPreferredHeight(row int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_RowPreferredHeight(ptr.Pointer(), C.int(int32(row))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) RowSpacing(row int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_RowSpacing(ptr.Pointer(), C.int(int32(row))))
	}
	return 0
}

func (ptr *QGraphicsGridLayout) VerticalSpacing() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsGridLayout_VerticalSpacing(ptr.Pointer()))
	}
	return 0
}

type QGraphicsItem struct {
	ptr unsafe.Pointer
}

type QGraphicsItem_ITF interface {
	QGraphicsItem_PTR() *QGraphicsItem
}

func (ptr *QGraphicsItem) QGraphicsItem_PTR() *QGraphicsItem {
	return ptr
}

func (ptr *QGraphicsItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QGraphicsItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQGraphicsItem(ptr QGraphicsItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsItem) {
	n = new(QGraphicsItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsItem__CacheMode
//QGraphicsItem::CacheMode
type QGraphicsItem__CacheMode int64

const (
	QGraphicsItem__NoCache               QGraphicsItem__CacheMode = QGraphicsItem__CacheMode(0)
	QGraphicsItem__ItemCoordinateCache   QGraphicsItem__CacheMode = QGraphicsItem__CacheMode(1)
	QGraphicsItem__DeviceCoordinateCache QGraphicsItem__CacheMode = QGraphicsItem__CacheMode(2)
)

//go:generate stringer -type=QGraphicsItem__GraphicsItemChange
//QGraphicsItem::GraphicsItemChange
type QGraphicsItem__GraphicsItemChange int64

const (
	QGraphicsItem__ItemPositionChange                 QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(0)
	QGraphicsItem__ItemMatrixChange                   QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(1)
	QGraphicsItem__ItemVisibleChange                  QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(2)
	QGraphicsItem__ItemEnabledChange                  QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(3)
	QGraphicsItem__ItemSelectedChange                 QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(4)
	QGraphicsItem__ItemParentChange                   QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(5)
	QGraphicsItem__ItemChildAddedChange               QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(6)
	QGraphicsItem__ItemChildRemovedChange             QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(7)
	QGraphicsItem__ItemTransformChange                QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(8)
	QGraphicsItem__ItemPositionHasChanged             QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(9)
	QGraphicsItem__ItemTransformHasChanged            QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(10)
	QGraphicsItem__ItemSceneChange                    QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(11)
	QGraphicsItem__ItemVisibleHasChanged              QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(12)
	QGraphicsItem__ItemEnabledHasChanged              QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(13)
	QGraphicsItem__ItemSelectedHasChanged             QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(14)
	QGraphicsItem__ItemParentHasChanged               QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(15)
	QGraphicsItem__ItemSceneHasChanged                QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(16)
	QGraphicsItem__ItemCursorChange                   QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(17)
	QGraphicsItem__ItemCursorHasChanged               QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(18)
	QGraphicsItem__ItemToolTipChange                  QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(19)
	QGraphicsItem__ItemToolTipHasChanged              QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(20)
	QGraphicsItem__ItemFlagsChange                    QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(21)
	QGraphicsItem__ItemFlagsHaveChanged               QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(22)
	QGraphicsItem__ItemZValueChange                   QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(23)
	QGraphicsItem__ItemZValueHasChanged               QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(24)
	QGraphicsItem__ItemOpacityChange                  QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(25)
	QGraphicsItem__ItemOpacityHasChanged              QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(26)
	QGraphicsItem__ItemScenePositionHasChanged        QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(27)
	QGraphicsItem__ItemRotationChange                 QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(28)
	QGraphicsItem__ItemRotationHasChanged             QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(29)
	QGraphicsItem__ItemScaleChange                    QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(30)
	QGraphicsItem__ItemScaleHasChanged                QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(31)
	QGraphicsItem__ItemTransformOriginPointChange     QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(32)
	QGraphicsItem__ItemTransformOriginPointHasChanged QGraphicsItem__GraphicsItemChange = QGraphicsItem__GraphicsItemChange(33)
)

//go:generate stringer -type=QGraphicsItem__GraphicsItemFlag
//QGraphicsItem::GraphicsItemFlag
type QGraphicsItem__GraphicsItemFlag int64

const (
	QGraphicsItem__ItemIsMovable                        QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x1)
	QGraphicsItem__ItemIsSelectable                     QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x2)
	QGraphicsItem__ItemIsFocusable                      QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x4)
	QGraphicsItem__ItemClipsToShape                     QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x8)
	QGraphicsItem__ItemClipsChildrenToShape             QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x10)
	QGraphicsItem__ItemIgnoresTransformations           QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x20)
	QGraphicsItem__ItemIgnoresParentOpacity             QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x40)
	QGraphicsItem__ItemDoesntPropagateOpacityToChildren QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x80)
	QGraphicsItem__ItemStacksBehindParent               QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x100)
	QGraphicsItem__ItemUsesExtendedStyleOption          QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x200)
	QGraphicsItem__ItemHasNoContents                    QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x400)
	QGraphicsItem__ItemSendsGeometryChanges             QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x800)
	QGraphicsItem__ItemAcceptsInputMethod               QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x1000)
	QGraphicsItem__ItemNegativeZStacksBehindParent      QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x2000)
	QGraphicsItem__ItemIsPanel                          QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x4000)
	QGraphicsItem__ItemIsFocusScope                     QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x8000)
	QGraphicsItem__ItemSendsScenePositionChanges        QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x10000)
	QGraphicsItem__ItemStopsClickFocusPropagation       QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x20000)
	QGraphicsItem__ItemStopsFocusHandling               QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x40000)
	QGraphicsItem__ItemContainsChildrenInShape          QGraphicsItem__GraphicsItemFlag = QGraphicsItem__GraphicsItemFlag(0x80000)
)

//go:generate stringer -type=QGraphicsItem__PanelModality
//QGraphicsItem::PanelModality
type QGraphicsItem__PanelModality int64

const (
	QGraphicsItem__NonModal   QGraphicsItem__PanelModality = QGraphicsItem__PanelModality(0)
	QGraphicsItem__PanelModal QGraphicsItem__PanelModality = QGraphicsItem__PanelModality(1)
	QGraphicsItem__SceneModal QGraphicsItem__PanelModality = QGraphicsItem__PanelModality(2)
)

//go:generate stringer -type=QGraphicsItem__anonymous
//QGraphicsItem::anonymous
type QGraphicsItem__anonymous int64

const (
	QGraphicsItem__Type     QGraphicsItem__anonymous = QGraphicsItem__anonymous(1)
	QGraphicsItem__UserType QGraphicsItem__anonymous = QGraphicsItem__anonymous(65536)
)

func NewQGraphicsItem(parent QGraphicsItem_ITF) *QGraphicsItem {
	return NewQGraphicsItemFromPointer(C.QGraphicsItem_NewQGraphicsItem(PointerFromQGraphicsItem(parent)))
}

func (ptr *QGraphicsItem) ToGraphicsObject() *QGraphicsObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsObjectFromPointer(C.QGraphicsItem_ToGraphicsObject(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsItem_ItemChange
func callbackQGraphicsItem_ItemChange(ptr unsafe.Pointer, change C.longlong, value unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemChange"); signal != nil {
		return core.PointerFromQVariant((*(*func(QGraphicsItem__GraphicsItemChange, *core.QVariant) *core.QVariant)(signal))(QGraphicsItem__GraphicsItemChange(change), core.NewQVariantFromPointer(value)))
	}

	return core.PointerFromQVariant(NewQGraphicsItemFromPointer(ptr).ItemChangeDefault(QGraphicsItem__GraphicsItemChange(change), core.NewQVariantFromPointer(value)))
}

func (ptr *QGraphicsItem) ConnectItemChange(f func(change QGraphicsItem__GraphicsItemChange, value *core.QVariant) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemChange"); signal != nil {
			f := func(change QGraphicsItem__GraphicsItemChange, value *core.QVariant) *core.QVariant {
				(*(*func(QGraphicsItem__GraphicsItemChange, *core.QVariant) *core.QVariant)(signal))(change, value)
				return f(change, value)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemChange", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemChange", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectItemChange() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemChange")
	}
}

func (ptr *QGraphicsItem) ItemChange(change QGraphicsItem__GraphicsItemChange, value core.QVariant_ITF) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QGraphicsItem_ItemChange(ptr.Pointer(), C.longlong(change), core.PointerFromQVariant(value)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) ItemChangeDefault(change QGraphicsItem__GraphicsItemChange, value core.QVariant_ITF) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QGraphicsItem_ItemChangeDefault(ptr.Pointer(), C.longlong(change), core.PointerFromQVariant(value)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsItem_SceneEvent
func callbackQGraphicsItem_SceneEvent(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "sceneEvent"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsItemFromPointer(ptr).SceneEventDefault(core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsItem) ConnectSceneEvent(f func(event *core.QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sceneEvent"); signal != nil {
			f := func(event *core.QEvent) bool {
				(*(*func(*core.QEvent) bool)(signal))(event)
				return f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "sceneEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sceneEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectSceneEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sceneEvent")
	}
}

func (ptr *QGraphicsItem) SceneEvent(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_SceneEvent(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) SceneEventDefault(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_SceneEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGraphicsItem_SceneEventFilter
func callbackQGraphicsItem_SceneEventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "sceneEventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QGraphicsItem, *core.QEvent) bool)(signal))(NewQGraphicsItemFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsItemFromPointer(ptr).SceneEventFilterDefault(NewQGraphicsItemFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsItem) ConnectSceneEventFilter(f func(watched *QGraphicsItem, event *core.QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sceneEventFilter"); signal != nil {
			f := func(watched *QGraphicsItem, event *core.QEvent) bool {
				(*(*func(*QGraphicsItem, *core.QEvent) bool)(signal))(watched, event)
				return f(watched, event)
			}
			qt.ConnectSignal(ptr.Pointer(), "sceneEventFilter", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sceneEventFilter", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectSceneEventFilter() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sceneEventFilter")
	}
}

func (ptr *QGraphicsItem) SceneEventFilter(watched QGraphicsItem_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_SceneEventFilter(ptr.Pointer(), PointerFromQGraphicsItem(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) SceneEventFilterDefault(watched QGraphicsItem_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_SceneEventFilterDefault(ptr.Pointer(), PointerFromQGraphicsItem(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGraphicsItem_Advance
func callbackQGraphicsItem_Advance(ptr unsafe.Pointer, phase C.int) {
	if signal := qt.GetSignal(ptr, "advance"); signal != nil {
		(*(*func(int))(signal))(int(int32(phase)))
	} else {
		NewQGraphicsItemFromPointer(ptr).AdvanceDefault(int(int32(phase)))
	}
}

func (ptr *QGraphicsItem) ConnectAdvance(f func(phase int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "advance"); signal != nil {
			f := func(phase int) {
				(*(*func(int))(signal))(phase)
				f(phase)
			}
			qt.ConnectSignal(ptr.Pointer(), "advance", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "advance", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectAdvance() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "advance")
	}
}

func (ptr *QGraphicsItem) Advance(phase int) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_Advance(ptr.Pointer(), C.int(int32(phase)))
	}
}

func (ptr *QGraphicsItem) AdvanceDefault(phase int) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_AdvanceDefault(ptr.Pointer(), C.int(int32(phase)))
	}
}

func (ptr *QGraphicsItem) ClearFocus() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_ClearFocus(ptr.Pointer())
	}
}

//export callbackQGraphicsItem_ContextMenuEvent
func callbackQGraphicsItem_ContextMenuEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "contextMenuEvent"); signal != nil {
		(*(*func(*QGraphicsSceneContextMenuEvent))(signal))(NewQGraphicsSceneContextMenuEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).ContextMenuEventDefault(NewQGraphicsSceneContextMenuEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectContextMenuEvent(f func(event *QGraphicsSceneContextMenuEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "contextMenuEvent"); signal != nil {
			f := func(event *QGraphicsSceneContextMenuEvent) {
				(*(*func(*QGraphicsSceneContextMenuEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "contextMenuEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "contextMenuEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectContextMenuEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "contextMenuEvent")
	}
}

func (ptr *QGraphicsItem) ContextMenuEvent(event QGraphicsSceneContextMenuEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_ContextMenuEvent(ptr.Pointer(), PointerFromQGraphicsSceneContextMenuEvent(event))
	}
}

func (ptr *QGraphicsItem) ContextMenuEventDefault(event QGraphicsSceneContextMenuEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_ContextMenuEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneContextMenuEvent(event))
	}
}

//export callbackQGraphicsItem_DragEnterEvent
func callbackQGraphicsItem_DragEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dragEnterEvent"); signal != nil {
		(*(*func(*QGraphicsSceneDragDropEvent))(signal))(NewQGraphicsSceneDragDropEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).DragEnterEventDefault(NewQGraphicsSceneDragDropEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectDragEnterEvent(f func(event *QGraphicsSceneDragDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dragEnterEvent"); signal != nil {
			f := func(event *QGraphicsSceneDragDropEvent) {
				(*(*func(*QGraphicsSceneDragDropEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dragEnterEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dragEnterEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectDragEnterEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dragEnterEvent")
	}
}

func (ptr *QGraphicsItem) DragEnterEvent(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DragEnterEvent(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

func (ptr *QGraphicsItem) DragEnterEventDefault(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DragEnterEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

//export callbackQGraphicsItem_DragLeaveEvent
func callbackQGraphicsItem_DragLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dragLeaveEvent"); signal != nil {
		(*(*func(*QGraphicsSceneDragDropEvent))(signal))(NewQGraphicsSceneDragDropEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).DragLeaveEventDefault(NewQGraphicsSceneDragDropEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectDragLeaveEvent(f func(event *QGraphicsSceneDragDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dragLeaveEvent"); signal != nil {
			f := func(event *QGraphicsSceneDragDropEvent) {
				(*(*func(*QGraphicsSceneDragDropEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dragLeaveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dragLeaveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectDragLeaveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dragLeaveEvent")
	}
}

func (ptr *QGraphicsItem) DragLeaveEvent(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DragLeaveEvent(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

func (ptr *QGraphicsItem) DragLeaveEventDefault(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DragLeaveEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

//export callbackQGraphicsItem_DragMoveEvent
func callbackQGraphicsItem_DragMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dragMoveEvent"); signal != nil {
		(*(*func(*QGraphicsSceneDragDropEvent))(signal))(NewQGraphicsSceneDragDropEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).DragMoveEventDefault(NewQGraphicsSceneDragDropEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectDragMoveEvent(f func(event *QGraphicsSceneDragDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dragMoveEvent"); signal != nil {
			f := func(event *QGraphicsSceneDragDropEvent) {
				(*(*func(*QGraphicsSceneDragDropEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dragMoveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dragMoveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectDragMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dragMoveEvent")
	}
}

func (ptr *QGraphicsItem) DragMoveEvent(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DragMoveEvent(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

func (ptr *QGraphicsItem) DragMoveEventDefault(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DragMoveEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

//export callbackQGraphicsItem_DropEvent
func callbackQGraphicsItem_DropEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dropEvent"); signal != nil {
		(*(*func(*QGraphicsSceneDragDropEvent))(signal))(NewQGraphicsSceneDragDropEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).DropEventDefault(NewQGraphicsSceneDragDropEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectDropEvent(f func(event *QGraphicsSceneDragDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dropEvent"); signal != nil {
			f := func(event *QGraphicsSceneDragDropEvent) {
				(*(*func(*QGraphicsSceneDragDropEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dropEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dropEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectDropEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dropEvent")
	}
}

func (ptr *QGraphicsItem) DropEvent(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DropEvent(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

func (ptr *QGraphicsItem) DropEventDefault(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DropEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

func (ptr *QGraphicsItem) EnsureVisible(rect core.QRectF_ITF, xmargin int, ymargin int) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_EnsureVisible(ptr.Pointer(), core.PointerFromQRectF(rect), C.int(int32(xmargin)), C.int(int32(ymargin)))
	}
}

func (ptr *QGraphicsItem) EnsureVisible2(x float64, y float64, w float64, h float64, xmargin int, ymargin int) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_EnsureVisible2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h), C.int(int32(xmargin)), C.int(int32(ymargin)))
	}
}

//export callbackQGraphicsItem_FocusInEvent
func callbackQGraphicsItem_FocusInEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "focusInEvent"); signal != nil {
		(*(*func(*gui.QFocusEvent))(signal))(gui.NewQFocusEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).FocusInEventDefault(gui.NewQFocusEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectFocusInEvent(f func(event *gui.QFocusEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "focusInEvent"); signal != nil {
			f := func(event *gui.QFocusEvent) {
				(*(*func(*gui.QFocusEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusInEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusInEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectFocusInEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "focusInEvent")
	}
}

func (ptr *QGraphicsItem) FocusInEvent(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_FocusInEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

func (ptr *QGraphicsItem) FocusInEventDefault(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_FocusInEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

//export callbackQGraphicsItem_FocusOutEvent
func callbackQGraphicsItem_FocusOutEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "focusOutEvent"); signal != nil {
		(*(*func(*gui.QFocusEvent))(signal))(gui.NewQFocusEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).FocusOutEventDefault(gui.NewQFocusEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectFocusOutEvent(f func(event *gui.QFocusEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "focusOutEvent"); signal != nil {
			f := func(event *gui.QFocusEvent) {
				(*(*func(*gui.QFocusEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusOutEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusOutEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectFocusOutEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "focusOutEvent")
	}
}

func (ptr *QGraphicsItem) FocusOutEvent(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_FocusOutEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

func (ptr *QGraphicsItem) FocusOutEventDefault(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_FocusOutEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

func (ptr *QGraphicsItem) GrabKeyboard() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_GrabKeyboard(ptr.Pointer())
	}
}

func (ptr *QGraphicsItem) GrabMouse() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_GrabMouse(ptr.Pointer())
	}
}

func (ptr *QGraphicsItem) Hide() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_Hide(ptr.Pointer())
	}
}

//export callbackQGraphicsItem_HoverEnterEvent
func callbackQGraphicsItem_HoverEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hoverEnterEvent"); signal != nil {
		(*(*func(*QGraphicsSceneHoverEvent))(signal))(NewQGraphicsSceneHoverEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).HoverEnterEventDefault(NewQGraphicsSceneHoverEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectHoverEnterEvent(f func(event *QGraphicsSceneHoverEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hoverEnterEvent"); signal != nil {
			f := func(event *QGraphicsSceneHoverEvent) {
				(*(*func(*QGraphicsSceneHoverEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "hoverEnterEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hoverEnterEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectHoverEnterEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hoverEnterEvent")
	}
}

func (ptr *QGraphicsItem) HoverEnterEvent(event QGraphicsSceneHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_HoverEnterEvent(ptr.Pointer(), PointerFromQGraphicsSceneHoverEvent(event))
	}
}

func (ptr *QGraphicsItem) HoverEnterEventDefault(event QGraphicsSceneHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_HoverEnterEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneHoverEvent(event))
	}
}

//export callbackQGraphicsItem_HoverLeaveEvent
func callbackQGraphicsItem_HoverLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hoverLeaveEvent"); signal != nil {
		(*(*func(*QGraphicsSceneHoverEvent))(signal))(NewQGraphicsSceneHoverEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).HoverLeaveEventDefault(NewQGraphicsSceneHoverEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectHoverLeaveEvent(f func(event *QGraphicsSceneHoverEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hoverLeaveEvent"); signal != nil {
			f := func(event *QGraphicsSceneHoverEvent) {
				(*(*func(*QGraphicsSceneHoverEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "hoverLeaveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hoverLeaveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectHoverLeaveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hoverLeaveEvent")
	}
}

func (ptr *QGraphicsItem) HoverLeaveEvent(event QGraphicsSceneHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_HoverLeaveEvent(ptr.Pointer(), PointerFromQGraphicsSceneHoverEvent(event))
	}
}

func (ptr *QGraphicsItem) HoverLeaveEventDefault(event QGraphicsSceneHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_HoverLeaveEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneHoverEvent(event))
	}
}

//export callbackQGraphicsItem_HoverMoveEvent
func callbackQGraphicsItem_HoverMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hoverMoveEvent"); signal != nil {
		(*(*func(*QGraphicsSceneHoverEvent))(signal))(NewQGraphicsSceneHoverEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).HoverMoveEventDefault(NewQGraphicsSceneHoverEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectHoverMoveEvent(f func(event *QGraphicsSceneHoverEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hoverMoveEvent"); signal != nil {
			f := func(event *QGraphicsSceneHoverEvent) {
				(*(*func(*QGraphicsSceneHoverEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "hoverMoveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hoverMoveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectHoverMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hoverMoveEvent")
	}
}

func (ptr *QGraphicsItem) HoverMoveEvent(event QGraphicsSceneHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_HoverMoveEvent(ptr.Pointer(), PointerFromQGraphicsSceneHoverEvent(event))
	}
}

func (ptr *QGraphicsItem) HoverMoveEventDefault(event QGraphicsSceneHoverEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_HoverMoveEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneHoverEvent(event))
	}
}

//export callbackQGraphicsItem_InputMethodEvent
func callbackQGraphicsItem_InputMethodEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "inputMethodEvent"); signal != nil {
		(*(*func(*gui.QInputMethodEvent))(signal))(gui.NewQInputMethodEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).InputMethodEventDefault(gui.NewQInputMethodEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectInputMethodEvent(f func(event *gui.QInputMethodEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "inputMethodEvent"); signal != nil {
			f := func(event *gui.QInputMethodEvent) {
				(*(*func(*gui.QInputMethodEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "inputMethodEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "inputMethodEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectInputMethodEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "inputMethodEvent")
	}
}

func (ptr *QGraphicsItem) InputMethodEvent(event gui.QInputMethodEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_InputMethodEvent(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
	}
}

func (ptr *QGraphicsItem) InputMethodEventDefault(event gui.QInputMethodEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_InputMethodEventDefault(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
	}
}

func (ptr *QGraphicsItem) InstallSceneEventFilter(filterItem QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_InstallSceneEventFilter(ptr.Pointer(), PointerFromQGraphicsItem(filterItem))
	}
}

//export callbackQGraphicsItem_KeyPressEvent
func callbackQGraphicsItem_KeyPressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "keyPressEvent"); signal != nil {
		(*(*func(*gui.QKeyEvent))(signal))(gui.NewQKeyEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).KeyPressEventDefault(gui.NewQKeyEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectKeyPressEvent(f func(event *gui.QKeyEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "keyPressEvent"); signal != nil {
			f := func(event *gui.QKeyEvent) {
				(*(*func(*gui.QKeyEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "keyPressEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "keyPressEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectKeyPressEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "keyPressEvent")
	}
}

func (ptr *QGraphicsItem) KeyPressEvent(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_KeyPressEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

func (ptr *QGraphicsItem) KeyPressEventDefault(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_KeyPressEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

//export callbackQGraphicsItem_KeyReleaseEvent
func callbackQGraphicsItem_KeyReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "keyReleaseEvent"); signal != nil {
		(*(*func(*gui.QKeyEvent))(signal))(gui.NewQKeyEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).KeyReleaseEventDefault(gui.NewQKeyEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectKeyReleaseEvent(f func(event *gui.QKeyEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "keyReleaseEvent"); signal != nil {
			f := func(event *gui.QKeyEvent) {
				(*(*func(*gui.QKeyEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "keyReleaseEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "keyReleaseEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectKeyReleaseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "keyReleaseEvent")
	}
}

func (ptr *QGraphicsItem) KeyReleaseEvent(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_KeyReleaseEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

func (ptr *QGraphicsItem) KeyReleaseEventDefault(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_KeyReleaseEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

//export callbackQGraphicsItem_MouseDoubleClickEvent
func callbackQGraphicsItem_MouseDoubleClickEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mouseDoubleClickEvent"); signal != nil {
		(*(*func(*QGraphicsSceneMouseEvent))(signal))(NewQGraphicsSceneMouseEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).MouseDoubleClickEventDefault(NewQGraphicsSceneMouseEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectMouseDoubleClickEvent(f func(event *QGraphicsSceneMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mouseDoubleClickEvent"); signal != nil {
			f := func(event *QGraphicsSceneMouseEvent) {
				(*(*func(*QGraphicsSceneMouseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "mouseDoubleClickEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mouseDoubleClickEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectMouseDoubleClickEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mouseDoubleClickEvent")
	}
}

func (ptr *QGraphicsItem) MouseDoubleClickEvent(event QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_MouseDoubleClickEvent(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(event))
	}
}

func (ptr *QGraphicsItem) MouseDoubleClickEventDefault(event QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_MouseDoubleClickEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(event))
	}
}

//export callbackQGraphicsItem_MouseMoveEvent
func callbackQGraphicsItem_MouseMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mouseMoveEvent"); signal != nil {
		(*(*func(*QGraphicsSceneMouseEvent))(signal))(NewQGraphicsSceneMouseEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).MouseMoveEventDefault(NewQGraphicsSceneMouseEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectMouseMoveEvent(f func(event *QGraphicsSceneMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mouseMoveEvent"); signal != nil {
			f := func(event *QGraphicsSceneMouseEvent) {
				(*(*func(*QGraphicsSceneMouseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "mouseMoveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mouseMoveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectMouseMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mouseMoveEvent")
	}
}

func (ptr *QGraphicsItem) MouseMoveEvent(event QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_MouseMoveEvent(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(event))
	}
}

func (ptr *QGraphicsItem) MouseMoveEventDefault(event QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_MouseMoveEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(event))
	}
}

//export callbackQGraphicsItem_MousePressEvent
func callbackQGraphicsItem_MousePressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mousePressEvent"); signal != nil {
		(*(*func(*QGraphicsSceneMouseEvent))(signal))(NewQGraphicsSceneMouseEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).MousePressEventDefault(NewQGraphicsSceneMouseEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectMousePressEvent(f func(event *QGraphicsSceneMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mousePressEvent"); signal != nil {
			f := func(event *QGraphicsSceneMouseEvent) {
				(*(*func(*QGraphicsSceneMouseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "mousePressEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mousePressEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectMousePressEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mousePressEvent")
	}
}

func (ptr *QGraphicsItem) MousePressEvent(event QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_MousePressEvent(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(event))
	}
}

func (ptr *QGraphicsItem) MousePressEventDefault(event QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_MousePressEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(event))
	}
}

//export callbackQGraphicsItem_MouseReleaseEvent
func callbackQGraphicsItem_MouseReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mouseReleaseEvent"); signal != nil {
		(*(*func(*QGraphicsSceneMouseEvent))(signal))(NewQGraphicsSceneMouseEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).MouseReleaseEventDefault(NewQGraphicsSceneMouseEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectMouseReleaseEvent(f func(event *QGraphicsSceneMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mouseReleaseEvent"); signal != nil {
			f := func(event *QGraphicsSceneMouseEvent) {
				(*(*func(*QGraphicsSceneMouseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "mouseReleaseEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mouseReleaseEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectMouseReleaseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mouseReleaseEvent")
	}
}

func (ptr *QGraphicsItem) MouseReleaseEvent(event QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_MouseReleaseEvent(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(event))
	}
}

func (ptr *QGraphicsItem) MouseReleaseEventDefault(event QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_MouseReleaseEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(event))
	}
}

func (ptr *QGraphicsItem) MoveBy(dx float64, dy float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_MoveBy(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

//export callbackQGraphicsItem_Paint
func callbackQGraphicsItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}

}

func (ptr *QGraphicsItem) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsItem) PrepareGeometryChange() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_PrepareGeometryChange(ptr.Pointer())
	}
}

func (ptr *QGraphicsItem) RemoveSceneEventFilter(filterItem QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_RemoveSceneEventFilter(ptr.Pointer(), PointerFromQGraphicsItem(filterItem))
	}
}

func (ptr *QGraphicsItem) ResetTransform() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_ResetTransform(ptr.Pointer())
	}
}

func (ptr *QGraphicsItem) Scroll(dx float64, dy float64, rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_Scroll(ptr.Pointer(), C.double(dx), C.double(dy), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsItem) SetAcceptDrops(on bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetAcceptDrops(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QGraphicsItem) SetAcceptHoverEvents(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetAcceptHoverEvents(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsItem) SetAcceptTouchEvents(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetAcceptTouchEvents(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsItem) SetAcceptedMouseButtons(buttons core.Qt__MouseButton) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetAcceptedMouseButtons(ptr.Pointer(), C.longlong(buttons))
	}
}

func (ptr *QGraphicsItem) SetActive(active bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetActive(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(active))))
	}
}

func (ptr *QGraphicsItem) SetBoundingRegionGranularity(granularity float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetBoundingRegionGranularity(ptr.Pointer(), C.double(granularity))
	}
}

func (ptr *QGraphicsItem) SetCacheMode(mode QGraphicsItem__CacheMode, logicalCacheSize core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetCacheMode(ptr.Pointer(), C.longlong(mode), core.PointerFromQSize(logicalCacheSize))
	}
}

func (ptr *QGraphicsItem) SetCursor(cursor gui.QCursor_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetCursor(ptr.Pointer(), gui.PointerFromQCursor(cursor))
	}
}

func (ptr *QGraphicsItem) SetData(key int, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetData(ptr.Pointer(), C.int(int32(key)), core.PointerFromQVariant(value))
	}
}

func (ptr *QGraphicsItem) SetEnabled(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsItem) SetFiltersChildEvents(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetFiltersChildEvents(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsItem) SetFlag(flag QGraphicsItem__GraphicsItemFlag, enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetFlag(ptr.Pointer(), C.longlong(flag), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsItem) SetFlags(flags QGraphicsItem__GraphicsItemFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QGraphicsItem) SetFocus(focusReason core.Qt__FocusReason) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetFocus(ptr.Pointer(), C.longlong(focusReason))
	}
}

func (ptr *QGraphicsItem) SetFocusProxy(item QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetFocusProxy(ptr.Pointer(), PointerFromQGraphicsItem(item))
	}
}

func (ptr *QGraphicsItem) SetGraphicsEffect(effect QGraphicsEffect_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetGraphicsEffect(ptr.Pointer(), PointerFromQGraphicsEffect(effect))
	}
}

func (ptr *QGraphicsItem) SetGroup(group QGraphicsItemGroup_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetGroup(ptr.Pointer(), PointerFromQGraphicsItemGroup(group))
	}
}

func (ptr *QGraphicsItem) SetInputMethodHints(hints core.Qt__InputMethodHint) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetInputMethodHints(ptr.Pointer(), C.longlong(hints))
	}
}

func (ptr *QGraphicsItem) SetOpacity(opacity float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetOpacity(ptr.Pointer(), C.double(opacity))
	}
}

func (ptr *QGraphicsItem) SetPanelModality(panelModality QGraphicsItem__PanelModality) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetPanelModality(ptr.Pointer(), C.longlong(panelModality))
	}
}

func (ptr *QGraphicsItem) SetParentItem(newParent QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetParentItem(ptr.Pointer(), PointerFromQGraphicsItem(newParent))
	}
}

func (ptr *QGraphicsItem) SetPos(pos core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetPos(ptr.Pointer(), core.PointerFromQPointF(pos))
	}
}

func (ptr *QGraphicsItem) SetPos2(x float64, y float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetPos2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QGraphicsItem) SetRotation(angle float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetRotation(ptr.Pointer(), C.double(angle))
	}
}

func (ptr *QGraphicsItem) SetScale(factor float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetScale(ptr.Pointer(), C.double(factor))
	}
}

func (ptr *QGraphicsItem) SetSelected(selected bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetSelected(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(selected))))
	}
}

func (ptr *QGraphicsItem) SetToolTip(toolTip string) {
	if ptr.Pointer() != nil {
		var toolTipC *C.char
		if toolTip != "" {
			toolTipC = C.CString(toolTip)
			defer C.free(unsafe.Pointer(toolTipC))
		}
		C.QGraphicsItem_SetToolTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: toolTipC, len: C.longlong(len(toolTip))})
	}
}

func (ptr *QGraphicsItem) SetTransform(matrix gui.QTransform_ITF, combine bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetTransform(ptr.Pointer(), gui.PointerFromQTransform(matrix), C.char(int8(qt.GoBoolToInt(combine))))
	}
}

func (ptr *QGraphicsItem) SetTransformOriginPoint(origin core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetTransformOriginPoint(ptr.Pointer(), core.PointerFromQPointF(origin))
	}
}

func (ptr *QGraphicsItem) SetTransformOriginPoint2(x float64, y float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetTransformOriginPoint2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QGraphicsItem) SetTransformations(transformations []*QGraphicsTransform) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetTransformations(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQGraphicsItemFromPointer(NewQGraphicsItemFromPointer(nil).__setTransformations_transformations_newList())
			for _, v := range transformations {
				tmpList.__setTransformations_transformations_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QGraphicsItem) SetVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QGraphicsItem) SetX(x float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetX(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QGraphicsItem) SetY(y float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetY(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QGraphicsItem) SetZValue(z float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_SetZValue(ptr.Pointer(), C.double(z))
	}
}

func (ptr *QGraphicsItem) Show() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_Show(ptr.Pointer())
	}
}

func (ptr *QGraphicsItem) StackBefore(sibling QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_StackBefore(ptr.Pointer(), PointerFromQGraphicsItem(sibling))
	}
}

func (ptr *QGraphicsItem) UngrabKeyboard() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_UngrabKeyboard(ptr.Pointer())
	}
}

func (ptr *QGraphicsItem) UngrabMouse() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_UngrabMouse(ptr.Pointer())
	}
}

func (ptr *QGraphicsItem) UnsetCursor() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_UnsetCursor(ptr.Pointer())
	}
}

func (ptr *QGraphicsItem) Update(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_Update(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsItem) Update2(x float64, y float64, width float64, height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_Update2(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height))
	}
}

//export callbackQGraphicsItem_WheelEvent
func callbackQGraphicsItem_WheelEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "wheelEvent"); signal != nil {
		(*(*func(*QGraphicsSceneWheelEvent))(signal))(NewQGraphicsSceneWheelEventFromPointer(event))
	} else {
		NewQGraphicsItemFromPointer(ptr).WheelEventDefault(NewQGraphicsSceneWheelEventFromPointer(event))
	}
}

func (ptr *QGraphicsItem) ConnectWheelEvent(f func(event *QGraphicsSceneWheelEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "wheelEvent"); signal != nil {
			f := func(event *QGraphicsSceneWheelEvent) {
				(*(*func(*QGraphicsSceneWheelEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "wheelEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "wheelEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectWheelEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "wheelEvent")
	}
}

func (ptr *QGraphicsItem) WheelEvent(event QGraphicsSceneWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_WheelEvent(ptr.Pointer(), PointerFromQGraphicsSceneWheelEvent(event))
	}
}

func (ptr *QGraphicsItem) WheelEventDefault(event QGraphicsSceneWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_WheelEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneWheelEvent(event))
	}
}

//export callbackQGraphicsItem_DestroyQGraphicsItem
func callbackQGraphicsItem_DestroyQGraphicsItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsItemFromPointer(ptr).DestroyQGraphicsItemDefault()
	}
}

func (ptr *QGraphicsItem) ConnectDestroyQGraphicsItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectDestroyQGraphicsItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsItem")
	}
}

func (ptr *QGraphicsItem) DestroyQGraphicsItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DestroyQGraphicsItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsItem) DestroyQGraphicsItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsItem_DestroyQGraphicsItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsItem) Cursor() *gui.QCursor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQCursorFromPointer(C.QGraphicsItem_Cursor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QCursor).DestroyQCursor)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) GraphicsEffect() *QGraphicsEffect {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsEffectFromPointer(C.QGraphicsItem_GraphicsEffect(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) CommonAncestorItem(other QGraphicsItem_ITF) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItem_CommonAncestorItem(ptr.Pointer(), PointerFromQGraphicsItem(other)))
	}
	return nil
}

func (ptr *QGraphicsItem) FocusItem() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItem_FocusItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsItem) FocusProxy() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItem_FocusProxy(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsItem) Panel() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItem_Panel(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsItem) ParentItem() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItem_ParentItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsItem) TopLevelItem() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItem_TopLevelItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsItem) CacheMode() QGraphicsItem__CacheMode {
	if ptr.Pointer() != nil {
		return QGraphicsItem__CacheMode(C.QGraphicsItem_CacheMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) Flags() QGraphicsItem__GraphicsItemFlag {
	if ptr.Pointer() != nil {
		return QGraphicsItem__GraphicsItemFlag(C.QGraphicsItem_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) PanelModality() QGraphicsItem__PanelModality {
	if ptr.Pointer() != nil {
		return QGraphicsItem__PanelModality(C.QGraphicsItem_PanelModality(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) Group() *QGraphicsItemGroup {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemGroupFromPointer(C.QGraphicsItem_Group(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsItem) ParentObject() *QGraphicsObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsObjectFromPointer(C.QGraphicsItem_ParentObject(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) Scene() *QGraphicsScene {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsSceneFromPointer(C.QGraphicsItem_Scene(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) ParentWidget() *QGraphicsWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsWidgetFromPointer(C.QGraphicsItem_ParentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) TopLevelWidget() *QGraphicsWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsWidgetFromPointer(C.QGraphicsItem_TopLevelWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) Window() *QGraphicsWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsWidgetFromPointer(C.QGraphicsItem_Window(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) ChildItems() []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsItemFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__childItems_atList(i)
			}
			return out
		}(C.QGraphicsItem_ChildItems(ptr.Pointer()))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsItem) CollidingItems(mode core.Qt__ItemSelectionMode) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsItemFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__collidingItems_atList(i)
			}
			return out
		}(C.QGraphicsItem_CollidingItems(ptr.Pointer(), C.longlong(mode)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsItem) Transformations() []*QGraphicsTransform {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsTransform {
			out := make([]*QGraphicsTransform, int(l.len))
			tmpList := NewQGraphicsItemFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__transformations_atList(i)
			}
			return out
		}(C.QGraphicsItem_Transformations(ptr.Pointer()))
	}
	return make([]*QGraphicsTransform, 0)
}

func (ptr *QGraphicsItem) ClipPath() *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_ClipPath(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromItem4(item QGraphicsItem_ITF, path gui.QPainterPath_ITF) *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_MapFromItem4(ptr.Pointer(), PointerFromQGraphicsItem(item), gui.PointerFromQPainterPath(path)))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromParent4(path gui.QPainterPath_ITF) *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_MapFromParent4(ptr.Pointer(), gui.PointerFromQPainterPath(path)))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromScene4(path gui.QPainterPath_ITF) *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_MapFromScene4(ptr.Pointer(), gui.PointerFromQPainterPath(path)))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToItem4(item QGraphicsItem_ITF, path gui.QPainterPath_ITF) *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_MapToItem4(ptr.Pointer(), PointerFromQGraphicsItem(item), gui.PointerFromQPainterPath(path)))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToParent4(path gui.QPainterPath_ITF) *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_MapToParent4(ptr.Pointer(), gui.PointerFromQPainterPath(path)))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToScene4(path gui.QPainterPath_ITF) *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_MapToScene4(ptr.Pointer(), gui.PointerFromQPainterPath(path)))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsItem_OpaqueArea
func callbackQGraphicsItem_OpaqueArea(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "opaqueArea"); signal != nil {
		return gui.PointerFromQPainterPath((*(*func() *gui.QPainterPath)(signal))())
	}

	return gui.PointerFromQPainterPath(NewQGraphicsItemFromPointer(ptr).OpaqueAreaDefault())
}

func (ptr *QGraphicsItem) ConnectOpaqueArea(f func() *gui.QPainterPath) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "opaqueArea"); signal != nil {
			f := func() *gui.QPainterPath {
				(*(*func() *gui.QPainterPath)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "opaqueArea", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "opaqueArea", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectOpaqueArea() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "opaqueArea")
	}
}

func (ptr *QGraphicsItem) OpaqueArea() *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_OpaqueArea(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) OpaqueAreaDefault() *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_OpaqueAreaDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsItem_Shape
func callbackQGraphicsItem_Shape(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "shape"); signal != nil {
		return gui.PointerFromQPainterPath((*(*func() *gui.QPainterPath)(signal))())
	}

	return gui.PointerFromQPainterPath(NewQGraphicsItemFromPointer(ptr).ShapeDefault())
}

func (ptr *QGraphicsItem) ConnectShape(f func() *gui.QPainterPath) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "shape"); signal != nil {
			f := func() *gui.QPainterPath {
				(*(*func() *gui.QPainterPath)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "shape", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "shape", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectShape() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "shape")
	}
}

func (ptr *QGraphicsItem) Shape() *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_Shape(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) ShapeDefault() *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsItem_ShapeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromItem(item QGraphicsItem_ITF, point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapFromItem(ptr.Pointer(), PointerFromQGraphicsItem(item), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromItem5(item QGraphicsItem_ITF, x float64, y float64) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapFromItem5(ptr.Pointer(), PointerFromQGraphicsItem(item), C.double(x), C.double(y)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromParent(point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapFromParent(ptr.Pointer(), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromParent5(x float64, y float64) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapFromParent5(ptr.Pointer(), C.double(x), C.double(y)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromScene(point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapFromScene(ptr.Pointer(), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromScene5(x float64, y float64) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapFromScene5(ptr.Pointer(), C.double(x), C.double(y)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToItem(item QGraphicsItem_ITF, point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapToItem(ptr.Pointer(), PointerFromQGraphicsItem(item), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToItem5(item QGraphicsItem_ITF, x float64, y float64) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapToItem5(ptr.Pointer(), PointerFromQGraphicsItem(item), C.double(x), C.double(y)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToParent(point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapToParent(ptr.Pointer(), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToParent5(x float64, y float64) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapToParent5(ptr.Pointer(), C.double(x), C.double(y)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToScene(point core.QPointF_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapToScene(ptr.Pointer(), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToScene5(x float64, y float64) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_MapToScene5(ptr.Pointer(), C.double(x), C.double(y)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) Pos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_Pos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) ScenePos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_ScenePos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) TransformOriginPoint() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItem_TransformOriginPoint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromItem3(item QGraphicsItem_ITF, polygon gui.QPolygonF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapFromItem3(ptr.Pointer(), PointerFromQGraphicsItem(item), gui.PointerFromQPolygonF(polygon)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromItem2(item QGraphicsItem_ITF, rect core.QRectF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapFromItem2(ptr.Pointer(), PointerFromQGraphicsItem(item), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromItem6(item QGraphicsItem_ITF, x float64, y float64, w float64, h float64) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapFromItem6(ptr.Pointer(), PointerFromQGraphicsItem(item), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromParent3(polygon gui.QPolygonF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapFromParent3(ptr.Pointer(), gui.PointerFromQPolygonF(polygon)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromParent2(rect core.QRectF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapFromParent2(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromParent6(x float64, y float64, w float64, h float64) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapFromParent6(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromScene3(polygon gui.QPolygonF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapFromScene3(ptr.Pointer(), gui.PointerFromQPolygonF(polygon)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromScene2(rect core.QRectF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapFromScene2(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapFromScene6(x float64, y float64, w float64, h float64) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapFromScene6(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToItem3(item QGraphicsItem_ITF, polygon gui.QPolygonF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapToItem3(ptr.Pointer(), PointerFromQGraphicsItem(item), gui.PointerFromQPolygonF(polygon)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToItem2(item QGraphicsItem_ITF, rect core.QRectF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapToItem2(ptr.Pointer(), PointerFromQGraphicsItem(item), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToItem6(item QGraphicsItem_ITF, x float64, y float64, w float64, h float64) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapToItem6(ptr.Pointer(), PointerFromQGraphicsItem(item), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToParent3(polygon gui.QPolygonF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapToParent3(ptr.Pointer(), gui.PointerFromQPolygonF(polygon)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToParent2(rect core.QRectF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapToParent2(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToParent6(x float64, y float64, w float64, h float64) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapToParent6(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToScene3(polygon gui.QPolygonF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapToScene3(ptr.Pointer(), gui.PointerFromQPolygonF(polygon)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToScene2(rect core.QRectF_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapToScene2(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapToScene6(x float64, y float64, w float64, h float64) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsItem_MapToScene6(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsItem_BoundingRect
func callbackQGraphicsItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(core.NewQRectF())
}

func (ptr *QGraphicsItem) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) ChildrenBoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_ChildrenBoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectFromItem(item QGraphicsItem_ITF, rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectFromItem(ptr.Pointer(), PointerFromQGraphicsItem(item), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectFromItem2(item QGraphicsItem_ITF, x float64, y float64, w float64, h float64) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectFromItem2(ptr.Pointer(), PointerFromQGraphicsItem(item), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectFromParent(rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectFromParent(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectFromParent2(x float64, y float64, w float64, h float64) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectFromParent2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectFromScene(rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectFromScene(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectFromScene2(x float64, y float64, w float64, h float64) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectFromScene2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectToItem(item QGraphicsItem_ITF, rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectToItem(ptr.Pointer(), PointerFromQGraphicsItem(item), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectToItem2(item QGraphicsItem_ITF, x float64, y float64, w float64, h float64) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectToItem2(ptr.Pointer(), PointerFromQGraphicsItem(item), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectToParent(rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectToParent(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectToParent2(x float64, y float64, w float64, h float64) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectToParent2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectToScene(rect core.QRectF_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectToScene(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) MapRectToScene2(x float64, y float64, w float64, h float64) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_MapRectToScene2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) SceneBoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItem_SceneBoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) BoundingRegion(itemToDeviceTransform gui.QTransform_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QGraphicsItem_BoundingRegion(ptr.Pointer(), gui.PointerFromQTransform(itemToDeviceTransform)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) ToolTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QGraphicsItem_ToolTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QGraphicsItem) DeviceTransform(viewportTransform gui.QTransform_ITF) *gui.QTransform {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTransformFromPointer(C.QGraphicsItem_DeviceTransform(ptr.Pointer(), gui.PointerFromQTransform(viewportTransform)))
		runtime.SetFinalizer(tmpValue, (*gui.QTransform).DestroyQTransform)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) ItemTransform(other QGraphicsItem_ITF, ok *bool) *gui.QTransform {
	if ptr.Pointer() != nil {
		var okC C.char
		if ok != nil {
			okC = C.char(int8(qt.GoBoolToInt(*ok)))
			defer func() { *ok = int8(okC) != 0 }()
		}
		tmpValue := gui.NewQTransformFromPointer(C.QGraphicsItem_ItemTransform(ptr.Pointer(), PointerFromQGraphicsItem(other), &okC))
		runtime.SetFinalizer(tmpValue, (*gui.QTransform).DestroyQTransform)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) SceneTransform() *gui.QTransform {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTransformFromPointer(C.QGraphicsItem_SceneTransform(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTransform).DestroyQTransform)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) Transform() *gui.QTransform {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTransformFromPointer(C.QGraphicsItem_Transform(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTransform).DestroyQTransform)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) Data(key int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QGraphicsItem_Data(ptr.Pointer(), C.int(int32(key))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsItem_InputMethodQuery
func callbackQGraphicsItem_InputMethodQuery(ptr unsafe.Pointer, query C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "inputMethodQuery"); signal != nil {
		return core.PointerFromQVariant((*(*func(core.Qt__InputMethodQuery) *core.QVariant)(signal))(core.Qt__InputMethodQuery(query)))
	}

	return core.PointerFromQVariant(NewQGraphicsItemFromPointer(ptr).InputMethodQueryDefault(core.Qt__InputMethodQuery(query)))
}

func (ptr *QGraphicsItem) ConnectInputMethodQuery(f func(query core.Qt__InputMethodQuery) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "inputMethodQuery"); signal != nil {
			f := func(query core.Qt__InputMethodQuery) *core.QVariant {
				(*(*func(core.Qt__InputMethodQuery) *core.QVariant)(signal))(query)
				return f(query)
			}
			qt.ConnectSignal(ptr.Pointer(), "inputMethodQuery", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "inputMethodQuery", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectInputMethodQuery() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "inputMethodQuery")
	}
}

func (ptr *QGraphicsItem) InputMethodQuery(query core.Qt__InputMethodQuery) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QGraphicsItem_InputMethodQuery(ptr.Pointer(), C.longlong(query)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) InputMethodQueryDefault(query core.Qt__InputMethodQuery) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QGraphicsItem_InputMethodQueryDefault(ptr.Pointer(), C.longlong(query)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) InputMethodHints() core.Qt__InputMethodHint {
	if ptr.Pointer() != nil {
		return core.Qt__InputMethodHint(C.QGraphicsItem_InputMethodHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) AcceptedMouseButtons() core.Qt__MouseButton {
	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QGraphicsItem_AcceptedMouseButtons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) AcceptDrops() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_AcceptDrops(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) AcceptHoverEvents() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_AcceptHoverEvents(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) AcceptTouchEvents() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_AcceptTouchEvents(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQGraphicsItem_CollidesWithItem
func callbackQGraphicsItem_CollidesWithItem(ptr unsafe.Pointer, other unsafe.Pointer, mode C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "collidesWithItem"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QGraphicsItem, core.Qt__ItemSelectionMode) bool)(signal))(NewQGraphicsItemFromPointer(other), core.Qt__ItemSelectionMode(mode)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsItemFromPointer(ptr).CollidesWithItemDefault(NewQGraphicsItemFromPointer(other), core.Qt__ItemSelectionMode(mode)))))
}

func (ptr *QGraphicsItem) ConnectCollidesWithItem(f func(other *QGraphicsItem, mode core.Qt__ItemSelectionMode) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "collidesWithItem"); signal != nil {
			f := func(other *QGraphicsItem, mode core.Qt__ItemSelectionMode) bool {
				(*(*func(*QGraphicsItem, core.Qt__ItemSelectionMode) bool)(signal))(other, mode)
				return f(other, mode)
			}
			qt.ConnectSignal(ptr.Pointer(), "collidesWithItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "collidesWithItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectCollidesWithItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "collidesWithItem")
	}
}

func (ptr *QGraphicsItem) CollidesWithItem(other QGraphicsItem_ITF, mode core.Qt__ItemSelectionMode) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_CollidesWithItem(ptr.Pointer(), PointerFromQGraphicsItem(other), C.longlong(mode))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) CollidesWithItemDefault(other QGraphicsItem_ITF, mode core.Qt__ItemSelectionMode) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_CollidesWithItemDefault(ptr.Pointer(), PointerFromQGraphicsItem(other), C.longlong(mode))) != 0
	}
	return false
}

//export callbackQGraphicsItem_CollidesWithPath
func callbackQGraphicsItem_CollidesWithPath(ptr unsafe.Pointer, path unsafe.Pointer, mode C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "collidesWithPath"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*gui.QPainterPath, core.Qt__ItemSelectionMode) bool)(signal))(gui.NewQPainterPathFromPointer(path), core.Qt__ItemSelectionMode(mode)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsItemFromPointer(ptr).CollidesWithPathDefault(gui.NewQPainterPathFromPointer(path), core.Qt__ItemSelectionMode(mode)))))
}

func (ptr *QGraphicsItem) ConnectCollidesWithPath(f func(path *gui.QPainterPath, mode core.Qt__ItemSelectionMode) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "collidesWithPath"); signal != nil {
			f := func(path *gui.QPainterPath, mode core.Qt__ItemSelectionMode) bool {
				(*(*func(*gui.QPainterPath, core.Qt__ItemSelectionMode) bool)(signal))(path, mode)
				return f(path, mode)
			}
			qt.ConnectSignal(ptr.Pointer(), "collidesWithPath", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "collidesWithPath", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectCollidesWithPath() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "collidesWithPath")
	}
}

func (ptr *QGraphicsItem) CollidesWithPath(path gui.QPainterPath_ITF, mode core.Qt__ItemSelectionMode) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_CollidesWithPath(ptr.Pointer(), gui.PointerFromQPainterPath(path), C.longlong(mode))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) CollidesWithPathDefault(path gui.QPainterPath_ITF, mode core.Qt__ItemSelectionMode) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_CollidesWithPathDefault(ptr.Pointer(), gui.PointerFromQPainterPath(path), C.longlong(mode))) != 0
	}
	return false
}

//export callbackQGraphicsItem_Contains
func callbackQGraphicsItem_Contains(ptr unsafe.Pointer, point unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "contains"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QPointF) bool)(signal))(core.NewQPointFFromPointer(point)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsItemFromPointer(ptr).ContainsDefault(core.NewQPointFFromPointer(point)))))
}

func (ptr *QGraphicsItem) ConnectContains(f func(point *core.QPointF) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "contains"); signal != nil {
			f := func(point *core.QPointF) bool {
				(*(*func(*core.QPointF) bool)(signal))(point)
				return f(point)
			}
			qt.ConnectSignal(ptr.Pointer(), "contains", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "contains", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectContains() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "contains")
	}
}

func (ptr *QGraphicsItem) Contains(point core.QPointF_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_Contains(ptr.Pointer(), core.PointerFromQPointF(point))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) ContainsDefault(point core.QPointF_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_ContainsDefault(ptr.Pointer(), core.PointerFromQPointF(point))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) FiltersChildEvents() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_FiltersChildEvents(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) HasCursor() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_HasCursor(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) HasFocus() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_HasFocus(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsActive() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsActive(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsAncestorOf(child QGraphicsItem_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsAncestorOf(ptr.Pointer(), PointerFromQGraphicsItem(child))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsClipped() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsClipped(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsObscured(rect core.QRectF_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsObscured(ptr.Pointer(), core.PointerFromQRectF(rect))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsObscured2(x float64, y float64, w float64, h float64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsObscured2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h))) != 0
	}
	return false
}

//export callbackQGraphicsItem_IsObscuredBy
func callbackQGraphicsItem_IsObscuredBy(ptr unsafe.Pointer, item unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isObscuredBy"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QGraphicsItem) bool)(signal))(NewQGraphicsItemFromPointer(item)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsItemFromPointer(ptr).IsObscuredByDefault(NewQGraphicsItemFromPointer(item)))))
}

func (ptr *QGraphicsItem) ConnectIsObscuredBy(f func(item *QGraphicsItem) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isObscuredBy"); signal != nil {
			f := func(item *QGraphicsItem) bool {
				(*(*func(*QGraphicsItem) bool)(signal))(item)
				return f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "isObscuredBy", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isObscuredBy", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectIsObscuredBy() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isObscuredBy")
	}
}

func (ptr *QGraphicsItem) IsObscuredBy(item QGraphicsItem_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsObscuredBy(ptr.Pointer(), PointerFromQGraphicsItem(item))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsObscuredByDefault(item QGraphicsItem_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsObscuredByDefault(ptr.Pointer(), PointerFromQGraphicsItem(item))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsPanel() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsPanel(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsSelected() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsSelected(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsUnderMouse() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsUnderMouse(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsVisibleTo(parent QGraphicsItem_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsVisibleTo(ptr.Pointer(), PointerFromQGraphicsItem(parent))) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsWidget() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsWidget(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) IsWindow() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItem_IsWindow(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsItem) ToGraphicsObject2() *QGraphicsObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsObjectFromPointer(C.QGraphicsItem_ToGraphicsObject2(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsItem_Type
func callbackQGraphicsItem_Type(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "type"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQGraphicsItemFromPointer(ptr).TypeDefault()))
}

func (ptr *QGraphicsItem) ConnectType(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "type"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "type", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "type", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItem) DisconnectType() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "type")
	}
}

func (ptr *QGraphicsItem) Type() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsItem_Type(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsItem) TypeDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsItem_TypeDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsItem) BoundingRegionGranularity() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItem_BoundingRegionGranularity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) EffectiveOpacity() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItem_EffectiveOpacity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) Opacity() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItem_Opacity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) Rotation() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItem_Rotation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) Scale() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItem_Scale(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) X() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItem_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) Y() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItem_Y(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) ZValue() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItem_ZValue(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsItem) __setTransformations_transformations_atList(i int) *QGraphicsTransform {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsTransformFromPointer(C.QGraphicsItem___setTransformations_transformations_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) __setTransformations_transformations_setList(i QGraphicsTransform_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem___setTransformations_transformations_setList(ptr.Pointer(), PointerFromQGraphicsTransform(i))
	}
}

func (ptr *QGraphicsItem) __setTransformations_transformations_newList() unsafe.Pointer {
	return C.QGraphicsItem___setTransformations_transformations_newList(ptr.Pointer())
}

func (ptr *QGraphicsItem) __childItems_atList(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItem___childItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsItem) __childItems_setList(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem___childItems_setList(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsItem) __childItems_newList() unsafe.Pointer {
	return C.QGraphicsItem___childItems_newList(ptr.Pointer())
}

func (ptr *QGraphicsItem) __children_atList(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItem___children_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsItem) __children_setList(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem___children_setList(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsItem) __children_newList() unsafe.Pointer {
	return C.QGraphicsItem___children_newList(ptr.Pointer())
}

func (ptr *QGraphicsItem) __collidingItems_atList(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItem___collidingItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsItem) __collidingItems_setList(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem___collidingItems_setList(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsItem) __collidingItems_newList() unsafe.Pointer {
	return C.QGraphicsItem___collidingItems_newList(ptr.Pointer())
}

func (ptr *QGraphicsItem) __transformations_atList(i int) *QGraphicsTransform {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsTransformFromPointer(C.QGraphicsItem___transformations_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItem) __transformations_setList(i QGraphicsTransform_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItem___transformations_setList(ptr.Pointer(), PointerFromQGraphicsTransform(i))
	}
}

func (ptr *QGraphicsItem) __transformations_newList() unsafe.Pointer {
	return C.QGraphicsItem___transformations_newList(ptr.Pointer())
}

type QGraphicsItemAnimation struct {
	core.QObject
}

type QGraphicsItemAnimation_ITF interface {
	core.QObject_ITF
	QGraphicsItemAnimation_PTR() *QGraphicsItemAnimation
}

func (ptr *QGraphicsItemAnimation) QGraphicsItemAnimation_PTR() *QGraphicsItemAnimation {
	return ptr
}

func (ptr *QGraphicsItemAnimation) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsItemAnimation(ptr QGraphicsItemAnimation_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsItemAnimation_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsItemAnimationFromPointer(ptr unsafe.Pointer) (n *QGraphicsItemAnimation) {
	n = new(QGraphicsItemAnimation)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsItemAnimation(parent core.QObject_ITF) *QGraphicsItemAnimation {
	tmpValue := NewQGraphicsItemAnimationFromPointer(C.QGraphicsItemAnimation_NewQGraphicsItemAnimation(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QGraphicsItemAnimation_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsItemAnimation_QGraphicsItemAnimation_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QGraphicsItemAnimation) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsItemAnimation_QGraphicsItemAnimation_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQGraphicsItemAnimation_AfterAnimationStep
func callbackQGraphicsItemAnimation_AfterAnimationStep(ptr unsafe.Pointer, step C.double) {
	if signal := qt.GetSignal(ptr, "afterAnimationStep"); signal != nil {
		(*(*func(float64))(signal))(float64(step))
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).AfterAnimationStepDefault(float64(step))
	}
}

func (ptr *QGraphicsItemAnimation) ConnectAfterAnimationStep(f func(step float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "afterAnimationStep"); signal != nil {
			f := func(step float64) {
				(*(*func(float64))(signal))(step)
				f(step)
			}
			qt.ConnectSignal(ptr.Pointer(), "afterAnimationStep", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "afterAnimationStep", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItemAnimation) DisconnectAfterAnimationStep() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "afterAnimationStep")
	}
}

func (ptr *QGraphicsItemAnimation) AfterAnimationStep(step float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_AfterAnimationStep(ptr.Pointer(), C.double(step))
	}
}

func (ptr *QGraphicsItemAnimation) AfterAnimationStepDefault(step float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_AfterAnimationStepDefault(ptr.Pointer(), C.double(step))
	}
}

//export callbackQGraphicsItemAnimation_BeforeAnimationStep
func callbackQGraphicsItemAnimation_BeforeAnimationStep(ptr unsafe.Pointer, step C.double) {
	if signal := qt.GetSignal(ptr, "beforeAnimationStep"); signal != nil {
		(*(*func(float64))(signal))(float64(step))
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).BeforeAnimationStepDefault(float64(step))
	}
}

func (ptr *QGraphicsItemAnimation) ConnectBeforeAnimationStep(f func(step float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "beforeAnimationStep"); signal != nil {
			f := func(step float64) {
				(*(*func(float64))(signal))(step)
				f(step)
			}
			qt.ConnectSignal(ptr.Pointer(), "beforeAnimationStep", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "beforeAnimationStep", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItemAnimation) DisconnectBeforeAnimationStep() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "beforeAnimationStep")
	}
}

func (ptr *QGraphicsItemAnimation) BeforeAnimationStep(step float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_BeforeAnimationStep(ptr.Pointer(), C.double(step))
	}
}

func (ptr *QGraphicsItemAnimation) BeforeAnimationStepDefault(step float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_BeforeAnimationStepDefault(ptr.Pointer(), C.double(step))
	}
}

func (ptr *QGraphicsItemAnimation) Clear() {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_Clear(ptr.Pointer())
	}
}

func (ptr *QGraphicsItemAnimation) SetItem(item QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_SetItem(ptr.Pointer(), PointerFromQGraphicsItem(item))
	}
}

func (ptr *QGraphicsItemAnimation) SetPosAt(step float64, point core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_SetPosAt(ptr.Pointer(), C.double(step), core.PointerFromQPointF(point))
	}
}

func (ptr *QGraphicsItemAnimation) SetRotationAt(step float64, angle float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_SetRotationAt(ptr.Pointer(), C.double(step), C.double(angle))
	}
}

func (ptr *QGraphicsItemAnimation) SetScaleAt(step float64, sx float64, sy float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_SetScaleAt(ptr.Pointer(), C.double(step), C.double(sx), C.double(sy))
	}
}

func (ptr *QGraphicsItemAnimation) SetShearAt(step float64, sh float64, sv float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_SetShearAt(ptr.Pointer(), C.double(step), C.double(sh), C.double(sv))
	}
}

//export callbackQGraphicsItemAnimation_SetStep
func callbackQGraphicsItemAnimation_SetStep(ptr unsafe.Pointer, step C.double) {
	if signal := qt.GetSignal(ptr, "setStep"); signal != nil {
		(*(*func(float64))(signal))(float64(step))
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).SetStepDefault(float64(step))
	}
}

func (ptr *QGraphicsItemAnimation) ConnectSetStep(f func(step float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setStep"); signal != nil {
			f := func(step float64) {
				(*(*func(float64))(signal))(step)
				f(step)
			}
			qt.ConnectSignal(ptr.Pointer(), "setStep", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setStep", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItemAnimation) DisconnectSetStep() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setStep")
	}
}

func (ptr *QGraphicsItemAnimation) SetStep(step float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_SetStep(ptr.Pointer(), C.double(step))
	}
}

func (ptr *QGraphicsItemAnimation) SetStepDefault(step float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_SetStepDefault(ptr.Pointer(), C.double(step))
	}
}

func (ptr *QGraphicsItemAnimation) SetTimeLine(timeLine core.QTimeLine_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_SetTimeLine(ptr.Pointer(), core.PointerFromQTimeLine(timeLine))
	}
}

func (ptr *QGraphicsItemAnimation) SetTranslationAt(step float64, dx float64, dy float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_SetTranslationAt(ptr.Pointer(), C.double(step), C.double(dx), C.double(dy))
	}
}

//export callbackQGraphicsItemAnimation_DestroyQGraphicsItemAnimation
func callbackQGraphicsItemAnimation_DestroyQGraphicsItemAnimation(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsItemAnimation"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).DestroyQGraphicsItemAnimationDefault()
	}
}

func (ptr *QGraphicsItemAnimation) ConnectDestroyQGraphicsItemAnimation(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsItemAnimation"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsItemAnimation", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsItemAnimation", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItemAnimation) DisconnectDestroyQGraphicsItemAnimation() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsItemAnimation")
	}
}

func (ptr *QGraphicsItemAnimation) DestroyQGraphicsItemAnimation() {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_DestroyQGraphicsItemAnimation(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsItemAnimation) DestroyQGraphicsItemAnimationDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_DestroyQGraphicsItemAnimationDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsItemAnimation) Item() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsItemAnimation_Item(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) MatrixAt(step float64) *gui.QMatrix {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQMatrixFromPointer(C.QGraphicsItemAnimation_MatrixAt(ptr.Pointer(), C.double(step)))
		runtime.SetFinalizer(tmpValue, (*gui.QMatrix).DestroyQMatrix)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) PosAt(step float64) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsItemAnimation_PosAt(ptr.Pointer(), C.double(step)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) TimeLine() *core.QTimeLine {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQTimeLineFromPointer(C.QGraphicsItemAnimation_TimeLine(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsItemAnimation_MetaObject
func callbackQGraphicsItemAnimation_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQGraphicsItemAnimationFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QGraphicsItemAnimation) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QGraphicsItemAnimation_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) HorizontalScaleAt(step float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItemAnimation_HorizontalScaleAt(ptr.Pointer(), C.double(step)))
	}
	return 0
}

func (ptr *QGraphicsItemAnimation) HorizontalShearAt(step float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItemAnimation_HorizontalShearAt(ptr.Pointer(), C.double(step)))
	}
	return 0
}

func (ptr *QGraphicsItemAnimation) RotationAt(step float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItemAnimation_RotationAt(ptr.Pointer(), C.double(step)))
	}
	return 0
}

func (ptr *QGraphicsItemAnimation) VerticalScaleAt(step float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItemAnimation_VerticalScaleAt(ptr.Pointer(), C.double(step)))
	}
	return 0
}

func (ptr *QGraphicsItemAnimation) VerticalShearAt(step float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItemAnimation_VerticalShearAt(ptr.Pointer(), C.double(step)))
	}
	return 0
}

func (ptr *QGraphicsItemAnimation) XTranslationAt(step float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItemAnimation_XTranslationAt(ptr.Pointer(), C.double(step)))
	}
	return 0
}

func (ptr *QGraphicsItemAnimation) YTranslationAt(step float64) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsItemAnimation_YTranslationAt(ptr.Pointer(), C.double(step)))
	}
	return 0
}

func (ptr *QGraphicsItemAnimation) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QGraphicsItemAnimation___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QGraphicsItemAnimation) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QGraphicsItemAnimation___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QGraphicsItemAnimation) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsItemAnimation___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsItemAnimation) __findChildren_newList2() unsafe.Pointer {
	return C.QGraphicsItemAnimation___findChildren_newList2(ptr.Pointer())
}

func (ptr *QGraphicsItemAnimation) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsItemAnimation___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsItemAnimation) __findChildren_newList3() unsafe.Pointer {
	return C.QGraphicsItemAnimation___findChildren_newList3(ptr.Pointer())
}

func (ptr *QGraphicsItemAnimation) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsItemAnimation___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsItemAnimation) __findChildren_newList() unsafe.Pointer {
	return C.QGraphicsItemAnimation___findChildren_newList(ptr.Pointer())
}

func (ptr *QGraphicsItemAnimation) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsItemAnimation___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItemAnimation) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsItemAnimation) __children_newList() unsafe.Pointer {
	return C.QGraphicsItemAnimation___children_newList(ptr.Pointer())
}

//export callbackQGraphicsItemAnimation_Event
func callbackQGraphicsItemAnimation_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsItemAnimationFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QGraphicsItemAnimation) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItemAnimation_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQGraphicsItemAnimation_EventFilter
func callbackQGraphicsItemAnimation_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsItemAnimationFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsItemAnimation) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsItemAnimation_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGraphicsItemAnimation_ChildEvent
func callbackQGraphicsItemAnimation_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QGraphicsItemAnimation) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQGraphicsItemAnimation_ConnectNotify
func callbackQGraphicsItemAnimation_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsItemAnimation) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsItemAnimation_CustomEvent
func callbackQGraphicsItemAnimation_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsItemAnimation) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsItemAnimation_DeleteLater
func callbackQGraphicsItemAnimation_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QGraphicsItemAnimation) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsItemAnimation_Destroyed
func callbackQGraphicsItemAnimation_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQGraphicsItemAnimation_DisconnectNotify
func callbackQGraphicsItemAnimation_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsItemAnimation) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsItemAnimation_ObjectNameChanged
func callbackQGraphicsItemAnimation_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQGraphicsItemAnimation_TimerEvent
func callbackQGraphicsItemAnimation_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQGraphicsItemAnimationFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QGraphicsItemAnimation) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemAnimation_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QGraphicsItemGroup struct {
	QGraphicsItem
}

type QGraphicsItemGroup_ITF interface {
	QGraphicsItem_ITF
	QGraphicsItemGroup_PTR() *QGraphicsItemGroup
}

func (ptr *QGraphicsItemGroup) QGraphicsItemGroup_PTR() *QGraphicsItemGroup {
	return ptr
}

func (ptr *QGraphicsItemGroup) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsItemGroup) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsItemGroup(ptr QGraphicsItemGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsItemGroup_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsItemGroupFromPointer(ptr unsafe.Pointer) (n *QGraphicsItemGroup) {
	n = new(QGraphicsItemGroup)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsItemGroup__anonymous
//QGraphicsItemGroup::anonymous
type QGraphicsItemGroup__anonymous int64

const (
	QGraphicsItemGroup__Type QGraphicsItemGroup__anonymous = QGraphicsItemGroup__anonymous(10)
)

func NewQGraphicsItemGroup(parent QGraphicsItem_ITF) *QGraphicsItemGroup {
	return NewQGraphicsItemGroupFromPointer(C.QGraphicsItemGroup_NewQGraphicsItemGroup(PointerFromQGraphicsItem(parent)))
}

func (ptr *QGraphicsItemGroup) AddToGroup(item QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemGroup_AddToGroup(ptr.Pointer(), PointerFromQGraphicsItem(item))
	}
}

//export callbackQGraphicsItemGroup_Paint
func callbackQGraphicsItemGroup_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsItemGroupFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsItemGroup) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItemGroup) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsItemGroup) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemGroup_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsItemGroup) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemGroup_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsItemGroup) RemoveFromGroup(item QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsItemGroup_RemoveFromGroup(ptr.Pointer(), PointerFromQGraphicsItem(item))
	}
}

//export callbackQGraphicsItemGroup_DestroyQGraphicsItemGroup
func callbackQGraphicsItemGroup_DestroyQGraphicsItemGroup(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsItemGroup"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsItemGroupFromPointer(ptr).DestroyQGraphicsItemGroupDefault()
	}
}

func (ptr *QGraphicsItemGroup) ConnectDestroyQGraphicsItemGroup(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsItemGroup"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsItemGroup", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsItemGroup", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItemGroup) DisconnectDestroyQGraphicsItemGroup() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsItemGroup")
	}
}

func (ptr *QGraphicsItemGroup) DestroyQGraphicsItemGroup() {
	if ptr.Pointer() != nil {
		C.QGraphicsItemGroup_DestroyQGraphicsItemGroup(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsItemGroup) DestroyQGraphicsItemGroupDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsItemGroup_DestroyQGraphicsItemGroupDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsItemGroup_BoundingRect
func callbackQGraphicsItemGroup_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsItemGroupFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsItemGroup) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsItemGroup) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsItemGroup) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItemGroup_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsItemGroup) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsItemGroup_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

type QGraphicsLayout struct {
	QGraphicsLayoutItem
}

type QGraphicsLayout_ITF interface {
	QGraphicsLayoutItem_ITF
	QGraphicsLayout_PTR() *QGraphicsLayout
}

func (ptr *QGraphicsLayout) QGraphicsLayout_PTR() *QGraphicsLayout {
	return ptr
}

func (ptr *QGraphicsLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsLayoutItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsLayoutItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsLayout(ptr QGraphicsLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsLayout_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsLayoutFromPointer(ptr unsafe.Pointer) (n *QGraphicsLayout) {
	n = new(QGraphicsLayout)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsLayout(parent QGraphicsLayoutItem_ITF) *QGraphicsLayout {
	return NewQGraphicsLayoutFromPointer(C.QGraphicsLayout_NewQGraphicsLayout(PointerFromQGraphicsLayoutItem(parent)))
}

func (ptr *QGraphicsLayout) Activate() {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_Activate(ptr.Pointer())
	}
}

func (ptr *QGraphicsLayout) AddChildLayoutItem(layoutItem QGraphicsLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_AddChildLayoutItem(ptr.Pointer(), PointerFromQGraphicsLayoutItem(layoutItem))
	}
}

//export callbackQGraphicsLayout_Invalidate
func callbackQGraphicsLayout_Invalidate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "invalidate"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsLayoutFromPointer(ptr).InvalidateDefault()
	}
}

func (ptr *QGraphicsLayout) ConnectInvalidate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "invalidate"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "invalidate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "invalidate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayout) DisconnectInvalidate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "invalidate")
	}
}

func (ptr *QGraphicsLayout) Invalidate() {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_Invalidate(ptr.Pointer())
	}
}

func (ptr *QGraphicsLayout) InvalidateDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_InvalidateDefault(ptr.Pointer())
	}
}

//export callbackQGraphicsLayout_RemoveAt
func callbackQGraphicsLayout_RemoveAt(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "removeAt"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QGraphicsLayout) ConnectRemoveAt(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "removeAt"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "removeAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "removeAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayout) DisconnectRemoveAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "removeAt")
	}
}

func (ptr *QGraphicsLayout) RemoveAt(index int) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_RemoveAt(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QGraphicsLayout) SetContentsMargins(left float64, top float64, right float64, bottom float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_SetContentsMargins(ptr.Pointer(), C.double(left), C.double(top), C.double(right), C.double(bottom))
	}
}

//export callbackQGraphicsLayout_WidgetEvent
func callbackQGraphicsLayout_WidgetEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "widgetEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(e))
	} else {
		NewQGraphicsLayoutFromPointer(ptr).WidgetEventDefault(core.NewQEventFromPointer(e))
	}
}

func (ptr *QGraphicsLayout) ConnectWidgetEvent(f func(e *core.QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "widgetEvent"); signal != nil {
			f := func(e *core.QEvent) {
				(*(*func(*core.QEvent))(signal))(e)
				f(e)
			}
			qt.ConnectSignal(ptr.Pointer(), "widgetEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "widgetEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayout) DisconnectWidgetEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "widgetEvent")
	}
}

func (ptr *QGraphicsLayout) WidgetEvent(e core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_WidgetEvent(ptr.Pointer(), core.PointerFromQEvent(e))
	}
}

func (ptr *QGraphicsLayout) WidgetEventDefault(e core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_WidgetEventDefault(ptr.Pointer(), core.PointerFromQEvent(e))
	}
}

//export callbackQGraphicsLayout_DestroyQGraphicsLayout
func callbackQGraphicsLayout_DestroyQGraphicsLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsLayoutFromPointer(ptr).DestroyQGraphicsLayoutDefault()
	}
}

func (ptr *QGraphicsLayout) ConnectDestroyQGraphicsLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayout) DisconnectDestroyQGraphicsLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsLayout")
	}
}

func (ptr *QGraphicsLayout) DestroyQGraphicsLayout() {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_DestroyQGraphicsLayout(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QGraphicsLayout) DestroyQGraphicsLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsLayout_DestroyQGraphicsLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

//export callbackQGraphicsLayout_ItemAt
func callbackQGraphicsLayout_ItemAt(ptr unsafe.Pointer, i C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemAt"); signal != nil {
		return PointerFromQGraphicsLayoutItem((*(*func(int) *QGraphicsLayoutItem)(signal))(int(int32(i))))
	}

	return PointerFromQGraphicsLayoutItem(nil)
}

func (ptr *QGraphicsLayout) ConnectItemAt(f func(i int) *QGraphicsLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemAt"); signal != nil {
			f := func(i int) *QGraphicsLayoutItem {
				(*(*func(int) *QGraphicsLayoutItem)(signal))(i)
				return f(i)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayout) DisconnectItemAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemAt")
	}
}

func (ptr *QGraphicsLayout) ItemAt(i int) *QGraphicsLayoutItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsLayoutItemFromPointer(C.QGraphicsLayout_ItemAt(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsLayout) IsActivated() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsLayout_IsActivated(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQGraphicsLayout_Count
func callbackQGraphicsLayout_Count(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "count"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(0))
}

func (ptr *QGraphicsLayout) ConnectCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "count"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayout) DisconnectCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "count")
	}
}

func (ptr *QGraphicsLayout) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsLayout_Count(ptr.Pointer())))
	}
	return 0
}

//export callbackQGraphicsLayout_SizeHint
func callbackQGraphicsLayout_SizeHint(ptr unsafe.Pointer, which C.longlong, constraint unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSizeF((*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
	}

	return core.PointerFromQSizeF(NewQGraphicsLayoutFromPointer(ptr).SizeHintDefault(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
}

func (ptr *QGraphicsLayout) SizeHint(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsLayout_SizeHint(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLayout) SizeHintDefault(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsLayout_SizeHintDefault(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

type QGraphicsLayoutItem struct {
	ptr unsafe.Pointer
}

type QGraphicsLayoutItem_ITF interface {
	QGraphicsLayoutItem_PTR() *QGraphicsLayoutItem
}

func (ptr *QGraphicsLayoutItem) QGraphicsLayoutItem_PTR() *QGraphicsLayoutItem {
	return ptr
}

func (ptr *QGraphicsLayoutItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQGraphicsLayoutItem(ptr QGraphicsLayoutItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsLayoutItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsLayoutItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsLayoutItem) {
	n = new(QGraphicsLayoutItem)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsLayoutItem(parent QGraphicsLayoutItem_ITF, isLayout bool) *QGraphicsLayoutItem {
	return NewQGraphicsLayoutItemFromPointer(C.QGraphicsLayoutItem_NewQGraphicsLayoutItem(PointerFromQGraphicsLayoutItem(parent), C.char(int8(qt.GoBoolToInt(isLayout)))))
}

//export callbackQGraphicsLayoutItem_SetGeometry
func callbackQGraphicsLayoutItem_SetGeometry(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setGeometry"); signal != nil {
		(*(*func(*core.QRectF))(signal))(core.NewQRectFFromPointer(rect))
	} else {
		NewQGraphicsLayoutItemFromPointer(ptr).SetGeometryDefault(core.NewQRectFFromPointer(rect))
	}
}

func (ptr *QGraphicsLayoutItem) ConnectSetGeometry(f func(rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setGeometry"); signal != nil {
			f := func(rect *core.QRectF) {
				(*(*func(*core.QRectF))(signal))(rect)
				f(rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayoutItem) DisconnectSetGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setGeometry")
	}
}

func (ptr *QGraphicsLayoutItem) SetGeometry(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetGeometry(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsLayoutItem) SetGeometryDefault(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetGeometryDefault(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsLayoutItem) SetGraphicsItem(item QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetGraphicsItem(ptr.Pointer(), PointerFromQGraphicsItem(item))
	}
}

func (ptr *QGraphicsLayoutItem) SetMaximumHeight(height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetMaximumHeight(ptr.Pointer(), C.double(height))
	}
}

func (ptr *QGraphicsLayoutItem) SetMaximumSize(size core.QSizeF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetMaximumSize(ptr.Pointer(), core.PointerFromQSizeF(size))
	}
}

func (ptr *QGraphicsLayoutItem) SetMaximumSize2(w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetMaximumSize2(ptr.Pointer(), C.double(w), C.double(h))
	}
}

func (ptr *QGraphicsLayoutItem) SetMaximumWidth(width float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetMaximumWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QGraphicsLayoutItem) SetMinimumHeight(height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetMinimumHeight(ptr.Pointer(), C.double(height))
	}
}

func (ptr *QGraphicsLayoutItem) SetMinimumSize(size core.QSizeF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetMinimumSize(ptr.Pointer(), core.PointerFromQSizeF(size))
	}
}

func (ptr *QGraphicsLayoutItem) SetMinimumSize2(w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetMinimumSize2(ptr.Pointer(), C.double(w), C.double(h))
	}
}

func (ptr *QGraphicsLayoutItem) SetMinimumWidth(width float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetMinimumWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QGraphicsLayoutItem) SetOwnedByLayout(ownership bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetOwnedByLayout(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(ownership))))
	}
}

func (ptr *QGraphicsLayoutItem) SetParentLayoutItem(parent QGraphicsLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetParentLayoutItem(ptr.Pointer(), PointerFromQGraphicsLayoutItem(parent))
	}
}

func (ptr *QGraphicsLayoutItem) SetPreferredHeight(height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetPreferredHeight(ptr.Pointer(), C.double(height))
	}
}

func (ptr *QGraphicsLayoutItem) SetPreferredSize(size core.QSizeF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetPreferredSize(ptr.Pointer(), core.PointerFromQSizeF(size))
	}
}

func (ptr *QGraphicsLayoutItem) SetPreferredSize2(w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetPreferredSize2(ptr.Pointer(), C.double(w), C.double(h))
	}
}

func (ptr *QGraphicsLayoutItem) SetPreferredWidth(width float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetPreferredWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QGraphicsLayoutItem) SetSizePolicy2(hPolicy QSizePolicy__Policy, vPolicy QSizePolicy__Policy, controlType QSizePolicy__ControlType) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetSizePolicy2(ptr.Pointer(), C.longlong(hPolicy), C.longlong(vPolicy), C.longlong(controlType))
	}
}

func (ptr *QGraphicsLayoutItem) SetSizePolicy(policy QSizePolicy_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_SetSizePolicy(ptr.Pointer(), PointerFromQSizePolicy(policy))
	}
}

//export callbackQGraphicsLayoutItem_UpdateGeometry
func callbackQGraphicsLayoutItem_UpdateGeometry(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateGeometry"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsLayoutItemFromPointer(ptr).UpdateGeometryDefault()
	}
}

func (ptr *QGraphicsLayoutItem) ConnectUpdateGeometry(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateGeometry"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "updateGeometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateGeometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayoutItem) DisconnectUpdateGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateGeometry")
	}
}

func (ptr *QGraphicsLayoutItem) UpdateGeometry() {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_UpdateGeometry(ptr.Pointer())
	}
}

func (ptr *QGraphicsLayoutItem) UpdateGeometryDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_UpdateGeometryDefault(ptr.Pointer())
	}
}

//export callbackQGraphicsLayoutItem_DestroyQGraphicsLayoutItem
func callbackQGraphicsLayoutItem_DestroyQGraphicsLayoutItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsLayoutItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsLayoutItemFromPointer(ptr).DestroyQGraphicsLayoutItemDefault()
	}
}

func (ptr *QGraphicsLayoutItem) ConnectDestroyQGraphicsLayoutItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsLayoutItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsLayoutItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsLayoutItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayoutItem) DisconnectDestroyQGraphicsLayoutItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsLayoutItem")
	}
}

func (ptr *QGraphicsLayoutItem) DestroyQGraphicsLayoutItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_DestroyQGraphicsLayoutItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsLayoutItem) DestroyQGraphicsLayoutItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_DestroyQGraphicsLayoutItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsLayoutItem) GraphicsItem() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsLayoutItem_GraphicsItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) ParentLayoutItem() *QGraphicsLayoutItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsLayoutItemFromPointer(C.QGraphicsLayoutItem_ParentLayoutItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) ContentsRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsLayoutItem_ContentsRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) Geometry() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsLayoutItem_Geometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) EffectiveSizeHint(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsLayoutItem_EffectiveSizeHint(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) MaximumSize() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsLayoutItem_MaximumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) MinimumSize() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsLayoutItem_MinimumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) PreferredSize() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsLayoutItem_PreferredSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsLayoutItem_SizeHint
func callbackQGraphicsLayoutItem_SizeHint(ptr unsafe.Pointer, which C.longlong, constraint unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSizeF((*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
	}

	return core.PointerFromQSizeF(core.NewQSizeF())
}

func (ptr *QGraphicsLayoutItem) ConnectSizeHint(f func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF {
				(*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(which, constraint)
				return f(which, constraint)
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayoutItem) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QGraphicsLayoutItem) SizeHint(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsLayoutItem_SizeHint(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) SizePolicy() *QSizePolicy {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizePolicyFromPointer(C.QGraphicsLayoutItem_SizePolicy(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSizePolicy).DestroyQSizePolicy)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLayoutItem) IsLayout() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsLayoutItem_IsLayout(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsLayoutItem) OwnedByLayout() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsLayoutItem_OwnedByLayout(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsLayoutItem) MaximumHeight() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsLayoutItem_MaximumHeight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsLayoutItem) MaximumWidth() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsLayoutItem_MaximumWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsLayoutItem) MinimumHeight() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsLayoutItem_MinimumHeight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsLayoutItem) MinimumWidth() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsLayoutItem_MinimumWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsLayoutItem) PreferredHeight() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsLayoutItem_PreferredHeight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsLayoutItem) PreferredWidth() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsLayoutItem_PreferredWidth(ptr.Pointer()))
	}
	return 0
}

//export callbackQGraphicsLayoutItem_GetContentsMargins
func callbackQGraphicsLayoutItem_GetContentsMargins(ptr unsafe.Pointer, left C.double, top C.double, right C.double, bottom C.double) {
	if signal := qt.GetSignal(ptr, "getContentsMargins"); signal != nil {
		(*(*func(float64, float64, float64, float64))(signal))(float64(left), float64(top), float64(right), float64(bottom))
	} else {
		NewQGraphicsLayoutItemFromPointer(ptr).GetContentsMarginsDefault(float64(left), float64(top), float64(right), float64(bottom))
	}
}

func (ptr *QGraphicsLayoutItem) ConnectGetContentsMargins(f func(left float64, top float64, right float64, bottom float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "getContentsMargins"); signal != nil {
			f := func(left float64, top float64, right float64, bottom float64) {
				(*(*func(float64, float64, float64, float64))(signal))(left, top, right, bottom)
				f(left, top, right, bottom)
			}
			qt.ConnectSignal(ptr.Pointer(), "getContentsMargins", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "getContentsMargins", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLayoutItem) DisconnectGetContentsMargins() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "getContentsMargins")
	}
}

func (ptr *QGraphicsLayoutItem) GetContentsMargins(left float64, top float64, right float64, bottom float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_GetContentsMargins(ptr.Pointer(), C.double(left), C.double(top), C.double(right), C.double(bottom))
	}
}

func (ptr *QGraphicsLayoutItem) GetContentsMarginsDefault(left float64, top float64, right float64, bottom float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLayoutItem_GetContentsMarginsDefault(ptr.Pointer(), C.double(left), C.double(top), C.double(right), C.double(bottom))
	}
}

type QGraphicsLineItem struct {
	QGraphicsItem
}

type QGraphicsLineItem_ITF interface {
	QGraphicsItem_ITF
	QGraphicsLineItem_PTR() *QGraphicsLineItem
}

func (ptr *QGraphicsLineItem) QGraphicsLineItem_PTR() *QGraphicsLineItem {
	return ptr
}

func (ptr *QGraphicsLineItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsLineItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsLineItem(ptr QGraphicsLineItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsLineItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsLineItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsLineItem) {
	n = new(QGraphicsLineItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsLineItem__anonymous
//QGraphicsLineItem::anonymous
type QGraphicsLineItem__anonymous int64

const (
	QGraphicsLineItem__Type QGraphicsLineItem__anonymous = QGraphicsLineItem__anonymous(6)
)

func NewQGraphicsLineItem(parent QGraphicsItem_ITF) *QGraphicsLineItem {
	return NewQGraphicsLineItemFromPointer(C.QGraphicsLineItem_NewQGraphicsLineItem(PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsLineItem2(line core.QLineF_ITF, parent QGraphicsItem_ITF) *QGraphicsLineItem {
	return NewQGraphicsLineItemFromPointer(C.QGraphicsLineItem_NewQGraphicsLineItem2(core.PointerFromQLineF(line), PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsLineItem3(x1 float64, y1 float64, x2 float64, y2 float64, parent QGraphicsItem_ITF) *QGraphicsLineItem {
	return NewQGraphicsLineItemFromPointer(C.QGraphicsLineItem_NewQGraphicsLineItem3(C.double(x1), C.double(y1), C.double(x2), C.double(y2), PointerFromQGraphicsItem(parent)))
}

//export callbackQGraphicsLineItem_Paint
func callbackQGraphicsLineItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsLineItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsLineItem) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLineItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsLineItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLineItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsLineItem) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLineItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsLineItem) SetLine(line core.QLineF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLineItem_SetLine(ptr.Pointer(), core.PointerFromQLineF(line))
	}
}

func (ptr *QGraphicsLineItem) SetLine2(x1 float64, y1 float64, x2 float64, y2 float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLineItem_SetLine2(ptr.Pointer(), C.double(x1), C.double(y1), C.double(x2), C.double(y2))
	}
}

func (ptr *QGraphicsLineItem) SetPen(pen gui.QPen_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLineItem_SetPen(ptr.Pointer(), gui.PointerFromQPen(pen))
	}
}

//export callbackQGraphicsLineItem_DestroyQGraphicsLineItem
func callbackQGraphicsLineItem_DestroyQGraphicsLineItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsLineItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsLineItemFromPointer(ptr).DestroyQGraphicsLineItemDefault()
	}
}

func (ptr *QGraphicsLineItem) ConnectDestroyQGraphicsLineItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsLineItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsLineItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsLineItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLineItem) DisconnectDestroyQGraphicsLineItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsLineItem")
	}
}

func (ptr *QGraphicsLineItem) DestroyQGraphicsLineItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsLineItem_DestroyQGraphicsLineItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsLineItem) DestroyQGraphicsLineItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsLineItem_DestroyQGraphicsLineItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsLineItem) Line() *core.QLineF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQLineFFromPointer(C.QGraphicsLineItem_Line(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QLineF).DestroyQLineF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLineItem) Pen() *gui.QPen {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPenFromPointer(C.QGraphicsLineItem_Pen(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPen).DestroyQPen)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsLineItem_BoundingRect
func callbackQGraphicsLineItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsLineItemFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsLineItem) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLineItem) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsLineItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsLineItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLineItem) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsLineItem_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

type QGraphicsLinearLayout struct {
	QGraphicsLayout
}

type QGraphicsLinearLayout_ITF interface {
	QGraphicsLayout_ITF
	QGraphicsLinearLayout_PTR() *QGraphicsLinearLayout
}

func (ptr *QGraphicsLinearLayout) QGraphicsLinearLayout_PTR() *QGraphicsLinearLayout {
	return ptr
}

func (ptr *QGraphicsLinearLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsLayout_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsLinearLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsLayout_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsLinearLayout(ptr QGraphicsLinearLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsLinearLayout_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsLinearLayoutFromPointer(ptr unsafe.Pointer) (n *QGraphicsLinearLayout) {
	n = new(QGraphicsLinearLayout)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsLinearLayout(parent QGraphicsLayoutItem_ITF) *QGraphicsLinearLayout {
	return NewQGraphicsLinearLayoutFromPointer(C.QGraphicsLinearLayout_NewQGraphicsLinearLayout(PointerFromQGraphicsLayoutItem(parent)))
}

func NewQGraphicsLinearLayout2(orientation core.Qt__Orientation, parent QGraphicsLayoutItem_ITF) *QGraphicsLinearLayout {
	return NewQGraphicsLinearLayoutFromPointer(C.QGraphicsLinearLayout_NewQGraphicsLinearLayout2(C.longlong(orientation), PointerFromQGraphicsLayoutItem(parent)))
}

func (ptr *QGraphicsLinearLayout) AddItem(item QGraphicsLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_AddItem(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item))
	}
}

func (ptr *QGraphicsLinearLayout) AddStretch(stretch int) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_AddStretch(ptr.Pointer(), C.int(int32(stretch)))
	}
}

func (ptr *QGraphicsLinearLayout) InsertItem(index int, item QGraphicsLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_InsertItem(ptr.Pointer(), C.int(int32(index)), PointerFromQGraphicsLayoutItem(item))
	}
}

func (ptr *QGraphicsLinearLayout) InsertStretch(index int, stretch int) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_InsertStretch(ptr.Pointer(), C.int(int32(index)), C.int(int32(stretch)))
	}
}

//export callbackQGraphicsLinearLayout_RemoveAt
func callbackQGraphicsLinearLayout_RemoveAt(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "removeAt"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQGraphicsLinearLayoutFromPointer(ptr).RemoveAtDefault(int(int32(index)))
	}
}

func (ptr *QGraphicsLinearLayout) ConnectRemoveAt(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "removeAt"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "removeAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "removeAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLinearLayout) DisconnectRemoveAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "removeAt")
	}
}

func (ptr *QGraphicsLinearLayout) RemoveAt(index int) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_RemoveAt(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QGraphicsLinearLayout) RemoveAtDefault(index int) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_RemoveAtDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QGraphicsLinearLayout) RemoveItem(item QGraphicsLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_RemoveItem(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item))
	}
}

func (ptr *QGraphicsLinearLayout) SetAlignment(item QGraphicsLayoutItem_ITF, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_SetAlignment(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item), C.longlong(alignment))
	}
}

func (ptr *QGraphicsLinearLayout) SetItemSpacing(index int, spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_SetItemSpacing(ptr.Pointer(), C.int(int32(index)), C.double(spacing))
	}
}

func (ptr *QGraphicsLinearLayout) SetOrientation(orientation core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_SetOrientation(ptr.Pointer(), C.longlong(orientation))
	}
}

func (ptr *QGraphicsLinearLayout) SetSpacing(spacing float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_SetSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QGraphicsLinearLayout) SetStretchFactor(item QGraphicsLayoutItem_ITF, stretch int) {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_SetStretchFactor(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item), C.int(int32(stretch)))
	}
}

//export callbackQGraphicsLinearLayout_DestroyQGraphicsLinearLayout
func callbackQGraphicsLinearLayout_DestroyQGraphicsLinearLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsLinearLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsLinearLayoutFromPointer(ptr).DestroyQGraphicsLinearLayoutDefault()
	}
}

func (ptr *QGraphicsLinearLayout) ConnectDestroyQGraphicsLinearLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsLinearLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsLinearLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsLinearLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLinearLayout) DisconnectDestroyQGraphicsLinearLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsLinearLayout")
	}
}

func (ptr *QGraphicsLinearLayout) DestroyQGraphicsLinearLayout() {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_DestroyQGraphicsLinearLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsLinearLayout) DestroyQGraphicsLinearLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsLinearLayout_DestroyQGraphicsLinearLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsLinearLayout_ItemAt
func callbackQGraphicsLinearLayout_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemAt"); signal != nil {
		return PointerFromQGraphicsLayoutItem((*(*func(int) *QGraphicsLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQGraphicsLayoutItem(NewQGraphicsLinearLayoutFromPointer(ptr).ItemAtDefault(int(int32(index))))
}

func (ptr *QGraphicsLinearLayout) ConnectItemAt(f func(index int) *QGraphicsLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemAt"); signal != nil {
			f := func(index int) *QGraphicsLayoutItem {
				(*(*func(int) *QGraphicsLayoutItem)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLinearLayout) DisconnectItemAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemAt")
	}
}

func (ptr *QGraphicsLinearLayout) ItemAt(index int) *QGraphicsLayoutItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsLayoutItemFromPointer(C.QGraphicsLinearLayout_ItemAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QGraphicsLinearLayout) ItemAtDefault(index int) *QGraphicsLayoutItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsLayoutItemFromPointer(C.QGraphicsLinearLayout_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

//export callbackQGraphicsLinearLayout_SizeHint
func callbackQGraphicsLinearLayout_SizeHint(ptr unsafe.Pointer, which C.longlong, constraint unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSizeF((*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
	}

	return core.PointerFromQSizeF(NewQGraphicsLinearLayoutFromPointer(ptr).SizeHintDefault(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
}

func (ptr *QGraphicsLinearLayout) ConnectSizeHint(f func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF {
				(*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(which, constraint)
				return f(which, constraint)
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLinearLayout) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QGraphicsLinearLayout) SizeHint(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsLinearLayout_SizeHint(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLinearLayout) SizeHintDefault(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsLinearLayout_SizeHintDefault(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsLinearLayout) Alignment(item QGraphicsLayoutItem_ITF) core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QGraphicsLinearLayout_Alignment(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item)))
	}
	return 0
}

func (ptr *QGraphicsLinearLayout) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QGraphicsLinearLayout_Orientation(ptr.Pointer()))
	}
	return 0
}

//export callbackQGraphicsLinearLayout_Count
func callbackQGraphicsLinearLayout_Count(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "count"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQGraphicsLinearLayoutFromPointer(ptr).CountDefault()))
}

func (ptr *QGraphicsLinearLayout) ConnectCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "count"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsLinearLayout) DisconnectCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "count")
	}
}

func (ptr *QGraphicsLinearLayout) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsLinearLayout_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsLinearLayout) CountDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsLinearLayout_CountDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsLinearLayout) StretchFactor(item QGraphicsLayoutItem_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsLinearLayout_StretchFactor(ptr.Pointer(), PointerFromQGraphicsLayoutItem(item))))
	}
	return 0
}

func (ptr *QGraphicsLinearLayout) ItemSpacing(index int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsLinearLayout_ItemSpacing(ptr.Pointer(), C.int(int32(index))))
	}
	return 0
}

func (ptr *QGraphicsLinearLayout) Spacing() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsLinearLayout_Spacing(ptr.Pointer()))
	}
	return 0
}

type QGraphicsObject struct {
	core.QObject
	QGraphicsItem
}

type QGraphicsObject_ITF interface {
	core.QObject_ITF
	QGraphicsItem_ITF
	QGraphicsObject_PTR() *QGraphicsObject
}

func (ptr *QGraphicsObject) QGraphicsObject_PTR() *QGraphicsObject {
	return ptr
}

func (ptr *QGraphicsObject) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsObject) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
		ptr.QGraphicsItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsObject(ptr QGraphicsObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsObject_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsObjectFromPointer(ptr unsafe.Pointer) (n *QGraphicsObject) {
	n = new(QGraphicsObject)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsObject(parent QGraphicsItem_ITF) *QGraphicsObject {
	tmpValue := NewQGraphicsObjectFromPointer(C.QGraphicsObject_NewQGraphicsObject(PointerFromQGraphicsItem(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QGraphicsObject_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsObject_QGraphicsObject_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QGraphicsObject) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsObject_QGraphicsObject_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQGraphicsObject_Event
func callbackQGraphicsObject_Event(ptr unsafe.Pointer, ev unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(ev)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsObjectFromPointer(ptr).EventDefault(core.NewQEventFromPointer(ev)))))
}

func (ptr *QGraphicsObject) ConnectEvent(f func(ev *core.QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "event"); signal != nil {
			f := func(ev *core.QEvent) bool {
				(*(*func(*core.QEvent) bool)(signal))(ev)
				return f(ev)
			}
			qt.ConnectSignal(ptr.Pointer(), "event", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "event", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "event")
	}
}

func (ptr *QGraphicsObject) Event(ev core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsObject_Event(ptr.Pointer(), core.PointerFromQEvent(ev))) != 0
	}
	return false
}

func (ptr *QGraphicsObject) EventDefault(ev core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsObject_EventDefault(ptr.Pointer(), core.PointerFromQEvent(ev))) != 0
	}
	return false
}

//export callbackQGraphicsObject_EnabledChanged
func callbackQGraphicsObject_EnabledChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "enabledChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsObject) ConnectEnabledChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "enabledChanged") {
			C.QGraphicsObject_ConnectEnabledChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "enabledChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "enabledChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "enabledChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectEnabledChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectEnabledChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "enabledChanged")
	}
}

func (ptr *QGraphicsObject) EnabledChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_EnabledChanged(ptr.Pointer())
	}
}

func (ptr *QGraphicsObject) GrabGesture(gesture core.Qt__GestureType, flags core.Qt__GestureFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_GrabGesture(ptr.Pointer(), C.longlong(gesture), C.longlong(flags))
	}
}

//export callbackQGraphicsObject_OpacityChanged
func callbackQGraphicsObject_OpacityChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "opacityChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsObject) ConnectOpacityChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "opacityChanged") {
			C.QGraphicsObject_ConnectOpacityChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "opacityChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "opacityChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "opacityChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectOpacityChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectOpacityChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "opacityChanged")
	}
}

func (ptr *QGraphicsObject) OpacityChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_OpacityChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsObject_ParentChanged
func callbackQGraphicsObject_ParentChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "parentChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsObject) ConnectParentChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "parentChanged") {
			C.QGraphicsObject_ConnectParentChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "parentChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "parentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "parentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectParentChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectParentChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "parentChanged")
	}
}

func (ptr *QGraphicsObject) ParentChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_ParentChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsObject_RotationChanged
func callbackQGraphicsObject_RotationChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "rotationChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsObject) ConnectRotationChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rotationChanged") {
			C.QGraphicsObject_ConnectRotationChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "rotationChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "rotationChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rotationChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectRotationChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectRotationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rotationChanged")
	}
}

func (ptr *QGraphicsObject) RotationChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_RotationChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsObject_ScaleChanged
func callbackQGraphicsObject_ScaleChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "scaleChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsObject) ConnectScaleChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "scaleChanged") {
			C.QGraphicsObject_ConnectScaleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "scaleChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "scaleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scaleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectScaleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "scaleChanged")
	}
}

func (ptr *QGraphicsObject) ScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_ScaleChanged(ptr.Pointer())
	}
}

func (ptr *QGraphicsObject) UngrabGesture(gesture core.Qt__GestureType) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_UngrabGesture(ptr.Pointer(), C.longlong(gesture))
	}
}

//export callbackQGraphicsObject_UpdateMicroFocus
func callbackQGraphicsObject_UpdateMicroFocus(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateMicroFocus"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsObjectFromPointer(ptr).UpdateMicroFocusDefault()
	}
}

func (ptr *QGraphicsObject) ConnectUpdateMicroFocus(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateMicroFocus"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "updateMicroFocus", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateMicroFocus", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectUpdateMicroFocus() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateMicroFocus")
	}
}

func (ptr *QGraphicsObject) UpdateMicroFocus() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_UpdateMicroFocus(ptr.Pointer())
	}
}

func (ptr *QGraphicsObject) UpdateMicroFocusDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_UpdateMicroFocusDefault(ptr.Pointer())
	}
}

//export callbackQGraphicsObject_VisibleChanged
func callbackQGraphicsObject_VisibleChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "visibleChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsObject) ConnectVisibleChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "visibleChanged") {
			C.QGraphicsObject_ConnectVisibleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "visibleChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "visibleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "visibleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectVisibleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectVisibleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "visibleChanged")
	}
}

func (ptr *QGraphicsObject) VisibleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_VisibleChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsObject_XChanged
func callbackQGraphicsObject_XChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "xChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsObject) ConnectXChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "xChanged") {
			C.QGraphicsObject_ConnectXChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "xChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "xChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "xChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectXChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectXChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "xChanged")
	}
}

func (ptr *QGraphicsObject) XChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_XChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsObject_YChanged
func callbackQGraphicsObject_YChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "yChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsObject) ConnectYChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "yChanged") {
			C.QGraphicsObject_ConnectYChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "yChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "yChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "yChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectYChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectYChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "yChanged")
	}
}

func (ptr *QGraphicsObject) YChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_YChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsObject_ZChanged
func callbackQGraphicsObject_ZChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "zChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsObject) ConnectZChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "zChanged") {
			C.QGraphicsObject_ConnectZChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "zChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "zChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "zChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectZChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectZChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "zChanged")
	}
}

func (ptr *QGraphicsObject) ZChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_ZChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsObject_DestroyQGraphicsObject
func callbackQGraphicsObject_DestroyQGraphicsObject(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsObject"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsObjectFromPointer(ptr).DestroyQGraphicsObjectDefault()
	}
}

func (ptr *QGraphicsObject) ConnectDestroyQGraphicsObject(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsObject"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsObject", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsObject", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectDestroyQGraphicsObject() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsObject")
	}
}

func (ptr *QGraphicsObject) DestroyQGraphicsObject() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DestroyQGraphicsObject(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsObject) DestroyQGraphicsObjectDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DestroyQGraphicsObjectDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsObject_MetaObject
func callbackQGraphicsObject_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQGraphicsObjectFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QGraphicsObject) ConnectMetaObject(f func() *core.QMetaObject) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "metaObject"); signal != nil {
			f := func() *core.QMetaObject {
				(*(*func() *core.QMetaObject)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "metaObject", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "metaObject", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsObject) DisconnectMetaObject() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "metaObject")
	}
}

func (ptr *QGraphicsObject) MetaObject() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QGraphicsObject_MetaObject(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsObject) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QGraphicsObject_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsObject) GraphicsEffect() *QGraphicsEffect {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsEffectFromPointer(C.QGraphicsObject_GraphicsEffect(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) SetGraphicsEffect(effect QGraphicsEffect_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetGraphicsEffect(ptr.Pointer(), PointerFromQGraphicsEffect(effect))
	}
}

func (ptr *QGraphicsObject) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsObject_IsEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsObject) SetEnabled(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsObject) Opacity() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsObject_Opacity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsObject) SetOpacity(opacity float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetOpacity(ptr.Pointer(), C.double(opacity))
	}
}

func (ptr *QGraphicsObject) Parent() *QGraphicsObject {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsObjectFromPointer(C.QGraphicsObject_Parent(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) SetParent(parent QGraphicsObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetParent(ptr.Pointer(), PointerFromQGraphicsObject(parent))
	}
}

func (ptr *QGraphicsObject) Pos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsObject_Pos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) SetPos(pos core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetPos(ptr.Pointer(), core.PointerFromQPointF(pos))
	}
}

func (ptr *QGraphicsObject) Rotation() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsObject_Rotation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsObject) SetRotation(rotation float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetRotation(ptr.Pointer(), C.double(rotation))
	}
}

func (ptr *QGraphicsObject) Scale() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsObject_Scale(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsObject) SetScale(scale float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetScale(ptr.Pointer(), C.double(scale))
	}
}

func (ptr *QGraphicsObject) TransformOriginPoint() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsObject_TransformOriginPoint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) SetTransformOriginPoint(transformOriginPoint core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetTransformOriginPoint(ptr.Pointer(), core.PointerFromQPointF(transformOriginPoint))
	}
}

func (ptr *QGraphicsObject) IsVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsObject_IsVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsObject) SetVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QGraphicsObject) X() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsObject_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsObject) SetX(x float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetX(ptr.Pointer(), C.double(x))
	}
}

func (ptr *QGraphicsObject) Y() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsObject_Y(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsObject) SetY(y float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetY(ptr.Pointer(), C.double(y))
	}
}

func (ptr *QGraphicsObject) ZValue() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsObject_ZValue(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsObject) SetZValue(z float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_SetZValue(ptr.Pointer(), C.double(z))
	}
}

func (ptr *QGraphicsObject) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QGraphicsObject___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QGraphicsObject) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QGraphicsObject___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QGraphicsObject) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsObject___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsObject) __findChildren_newList2() unsafe.Pointer {
	return C.QGraphicsObject___findChildren_newList2(ptr.Pointer())
}

func (ptr *QGraphicsObject) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsObject___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsObject) __findChildren_newList3() unsafe.Pointer {
	return C.QGraphicsObject___findChildren_newList3(ptr.Pointer())
}

func (ptr *QGraphicsObject) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsObject___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsObject) __findChildren_newList() unsafe.Pointer {
	return C.QGraphicsObject___findChildren_newList(ptr.Pointer())
}

func (ptr *QGraphicsObject) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsObject___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsObject) __children_newList() unsafe.Pointer {
	return C.QGraphicsObject___children_newList(ptr.Pointer())
}

//export callbackQGraphicsObject_EventFilter
func callbackQGraphicsObject_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsObjectFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsObject) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsObject_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QGraphicsObject) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsObject_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGraphicsObject_ChildEvent
func callbackQGraphicsObject_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQGraphicsObjectFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QGraphicsObject) ChildEvent(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QGraphicsObject) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQGraphicsObject_ConnectNotify
func callbackQGraphicsObject_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsObjectFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsObject) ConnectNotify(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

func (ptr *QGraphicsObject) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsObject_CustomEvent
func callbackQGraphicsObject_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsObjectFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsObject) CustomEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QGraphicsObject) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsObject_DeleteLater
func callbackQGraphicsObject_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsObjectFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QGraphicsObject) DeleteLater() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DeleteLater(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsObject) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsObject_Destroyed
func callbackQGraphicsObject_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQGraphicsObject_DisconnectNotify
func callbackQGraphicsObject_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsObjectFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsObject) DisconnectNotify(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

func (ptr *QGraphicsObject) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsObject_ObjectNameChanged
func callbackQGraphicsObject_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQGraphicsObject_TimerEvent
func callbackQGraphicsObject_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQGraphicsObjectFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QGraphicsObject) TimerEvent(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QGraphicsObject) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQGraphicsObject_Paint
func callbackQGraphicsObject_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsObjectFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsObject) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsObject) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsObject_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

//export callbackQGraphicsObject_BoundingRect
func callbackQGraphicsObject_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsObjectFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsObject) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsObject_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsObject) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsObject_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

type QGraphicsOpacityEffect struct {
	QGraphicsEffect
}

type QGraphicsOpacityEffect_ITF interface {
	QGraphicsEffect_ITF
	QGraphicsOpacityEffect_PTR() *QGraphicsOpacityEffect
}

func (ptr *QGraphicsOpacityEffect) QGraphicsOpacityEffect_PTR() *QGraphicsOpacityEffect {
	return ptr
}

func (ptr *QGraphicsOpacityEffect) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsEffect_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsOpacityEffect) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsEffect_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsOpacityEffect(ptr QGraphicsOpacityEffect_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsOpacityEffect_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsOpacityEffectFromPointer(ptr unsafe.Pointer) (n *QGraphicsOpacityEffect) {
	n = new(QGraphicsOpacityEffect)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsOpacityEffect(parent core.QObject_ITF) *QGraphicsOpacityEffect {
	tmpValue := NewQGraphicsOpacityEffectFromPointer(C.QGraphicsOpacityEffect_NewQGraphicsOpacityEffect(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQGraphicsOpacityEffect_Draw
func callbackQGraphicsOpacityEffect_Draw(ptr unsafe.Pointer, painter unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "draw"); signal != nil {
		(*(*func(*gui.QPainter))(signal))(gui.NewQPainterFromPointer(painter))
	} else {
		NewQGraphicsOpacityEffectFromPointer(ptr).DrawDefault(gui.NewQPainterFromPointer(painter))
	}
}

func (ptr *QGraphicsOpacityEffect) ConnectDraw(f func(painter *gui.QPainter)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "draw"); signal != nil {
			f := func(painter *gui.QPainter) {
				(*(*func(*gui.QPainter))(signal))(painter)
				f(painter)
			}
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsOpacityEffect) DisconnectDraw() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "draw")
	}
}

func (ptr *QGraphicsOpacityEffect) Draw(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_Draw(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

func (ptr *QGraphicsOpacityEffect) DrawDefault(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_DrawDefault(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

//export callbackQGraphicsOpacityEffect_OpacityChanged
func callbackQGraphicsOpacityEffect_OpacityChanged(ptr unsafe.Pointer, opacity C.double) {
	if signal := qt.GetSignal(ptr, "opacityChanged"); signal != nil {
		(*(*func(float64))(signal))(float64(opacity))
	}

}

func (ptr *QGraphicsOpacityEffect) ConnectOpacityChanged(f func(opacity float64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "opacityChanged") {
			C.QGraphicsOpacityEffect_ConnectOpacityChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "opacityChanged"); signal != nil {
			f := func(opacity float64) {
				(*(*func(float64))(signal))(opacity)
				f(opacity)
			}
			qt.ConnectSignal(ptr.Pointer(), "opacityChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "opacityChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsOpacityEffect) DisconnectOpacityChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_DisconnectOpacityChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "opacityChanged")
	}
}

func (ptr *QGraphicsOpacityEffect) OpacityChanged(opacity float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_OpacityChanged(ptr.Pointer(), C.double(opacity))
	}
}

//export callbackQGraphicsOpacityEffect_OpacityMaskChanged
func callbackQGraphicsOpacityEffect_OpacityMaskChanged(ptr unsafe.Pointer, mask unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "opacityMaskChanged"); signal != nil {
		(*(*func(*gui.QBrush))(signal))(gui.NewQBrushFromPointer(mask))
	}

}

func (ptr *QGraphicsOpacityEffect) ConnectOpacityMaskChanged(f func(mask *gui.QBrush)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "opacityMaskChanged") {
			C.QGraphicsOpacityEffect_ConnectOpacityMaskChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "opacityMaskChanged"); signal != nil {
			f := func(mask *gui.QBrush) {
				(*(*func(*gui.QBrush))(signal))(mask)
				f(mask)
			}
			qt.ConnectSignal(ptr.Pointer(), "opacityMaskChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "opacityMaskChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsOpacityEffect) DisconnectOpacityMaskChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_DisconnectOpacityMaskChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "opacityMaskChanged")
	}
}

func (ptr *QGraphicsOpacityEffect) OpacityMaskChanged(mask gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_OpacityMaskChanged(ptr.Pointer(), gui.PointerFromQBrush(mask))
	}
}

//export callbackQGraphicsOpacityEffect_SetOpacity
func callbackQGraphicsOpacityEffect_SetOpacity(ptr unsafe.Pointer, opacity C.double) {
	if signal := qt.GetSignal(ptr, "setOpacity"); signal != nil {
		(*(*func(float64))(signal))(float64(opacity))
	} else {
		NewQGraphicsOpacityEffectFromPointer(ptr).SetOpacityDefault(float64(opacity))
	}
}

func (ptr *QGraphicsOpacityEffect) ConnectSetOpacity(f func(opacity float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOpacity"); signal != nil {
			f := func(opacity float64) {
				(*(*func(float64))(signal))(opacity)
				f(opacity)
			}
			qt.ConnectSignal(ptr.Pointer(), "setOpacity", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOpacity", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsOpacityEffect) DisconnectSetOpacity() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOpacity")
	}
}

func (ptr *QGraphicsOpacityEffect) SetOpacity(opacity float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_SetOpacity(ptr.Pointer(), C.double(opacity))
	}
}

func (ptr *QGraphicsOpacityEffect) SetOpacityDefault(opacity float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_SetOpacityDefault(ptr.Pointer(), C.double(opacity))
	}
}

//export callbackQGraphicsOpacityEffect_SetOpacityMask
func callbackQGraphicsOpacityEffect_SetOpacityMask(ptr unsafe.Pointer, mask unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setOpacityMask"); signal != nil {
		(*(*func(*gui.QBrush))(signal))(gui.NewQBrushFromPointer(mask))
	} else {
		NewQGraphicsOpacityEffectFromPointer(ptr).SetOpacityMaskDefault(gui.NewQBrushFromPointer(mask))
	}
}

func (ptr *QGraphicsOpacityEffect) ConnectSetOpacityMask(f func(mask *gui.QBrush)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOpacityMask"); signal != nil {
			f := func(mask *gui.QBrush) {
				(*(*func(*gui.QBrush))(signal))(mask)
				f(mask)
			}
			qt.ConnectSignal(ptr.Pointer(), "setOpacityMask", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOpacityMask", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsOpacityEffect) DisconnectSetOpacityMask() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOpacityMask")
	}
}

func (ptr *QGraphicsOpacityEffect) SetOpacityMask(mask gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_SetOpacityMask(ptr.Pointer(), gui.PointerFromQBrush(mask))
	}
}

func (ptr *QGraphicsOpacityEffect) SetOpacityMaskDefault(mask gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_SetOpacityMaskDefault(ptr.Pointer(), gui.PointerFromQBrush(mask))
	}
}

//export callbackQGraphicsOpacityEffect_DestroyQGraphicsOpacityEffect
func callbackQGraphicsOpacityEffect_DestroyQGraphicsOpacityEffect(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsOpacityEffect"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsOpacityEffectFromPointer(ptr).DestroyQGraphicsOpacityEffectDefault()
	}
}

func (ptr *QGraphicsOpacityEffect) ConnectDestroyQGraphicsOpacityEffect(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsOpacityEffect"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsOpacityEffect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsOpacityEffect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsOpacityEffect) DisconnectDestroyQGraphicsOpacityEffect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsOpacityEffect")
	}
}

func (ptr *QGraphicsOpacityEffect) DestroyQGraphicsOpacityEffect() {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_DestroyQGraphicsOpacityEffect(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsOpacityEffect) DestroyQGraphicsOpacityEffectDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsOpacityEffect_DestroyQGraphicsOpacityEffectDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsOpacityEffect) OpacityMask() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QGraphicsOpacityEffect_OpacityMask(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsOpacityEffect) Opacity() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsOpacityEffect_Opacity(ptr.Pointer()))
	}
	return 0
}

type QGraphicsPathItem struct {
	QAbstractGraphicsShapeItem
}

type QGraphicsPathItem_ITF interface {
	QAbstractGraphicsShapeItem_ITF
	QGraphicsPathItem_PTR() *QGraphicsPathItem
}

func (ptr *QGraphicsPathItem) QGraphicsPathItem_PTR() *QGraphicsPathItem {
	return ptr
}

func (ptr *QGraphicsPathItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractGraphicsShapeItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsPathItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractGraphicsShapeItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsPathItem(ptr QGraphicsPathItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsPathItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsPathItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsPathItem) {
	n = new(QGraphicsPathItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsPathItem__anonymous
//QGraphicsPathItem::anonymous
type QGraphicsPathItem__anonymous int64

const (
	QGraphicsPathItem__Type QGraphicsPathItem__anonymous = QGraphicsPathItem__anonymous(2)
)

func NewQGraphicsPathItem(parent QGraphicsItem_ITF) *QGraphicsPathItem {
	return NewQGraphicsPathItemFromPointer(C.QGraphicsPathItem_NewQGraphicsPathItem(PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsPathItem2(path gui.QPainterPath_ITF, parent QGraphicsItem_ITF) *QGraphicsPathItem {
	return NewQGraphicsPathItemFromPointer(C.QGraphicsPathItem_NewQGraphicsPathItem2(gui.PointerFromQPainterPath(path), PointerFromQGraphicsItem(parent)))
}

//export callbackQGraphicsPathItem_Paint
func callbackQGraphicsPathItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsPathItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsPathItem) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsPathItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsPathItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPathItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsPathItem) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPathItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsPathItem) SetPath(path gui.QPainterPath_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPathItem_SetPath(ptr.Pointer(), gui.PointerFromQPainterPath(path))
	}
}

//export callbackQGraphicsPathItem_DestroyQGraphicsPathItem
func callbackQGraphicsPathItem_DestroyQGraphicsPathItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsPathItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsPathItemFromPointer(ptr).DestroyQGraphicsPathItemDefault()
	}
}

func (ptr *QGraphicsPathItem) ConnectDestroyQGraphicsPathItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsPathItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsPathItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsPathItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsPathItem) DisconnectDestroyQGraphicsPathItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsPathItem")
	}
}

func (ptr *QGraphicsPathItem) DestroyQGraphicsPathItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsPathItem_DestroyQGraphicsPathItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsPathItem) DestroyQGraphicsPathItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsPathItem_DestroyQGraphicsPathItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsPathItem) Path() *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsPathItem_Path(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsPathItem_BoundingRect
func callbackQGraphicsPathItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsPathItemFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsPathItem) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsPathItem) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsPathItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsPathItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsPathItem) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsPathItem_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

type QGraphicsPixmapItem struct {
	QGraphicsItem
}

type QGraphicsPixmapItem_ITF interface {
	QGraphicsItem_ITF
	QGraphicsPixmapItem_PTR() *QGraphicsPixmapItem
}

func (ptr *QGraphicsPixmapItem) QGraphicsPixmapItem_PTR() *QGraphicsPixmapItem {
	return ptr
}

func (ptr *QGraphicsPixmapItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsPixmapItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsPixmapItem(ptr QGraphicsPixmapItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsPixmapItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsPixmapItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsPixmapItem) {
	n = new(QGraphicsPixmapItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsPixmapItem__ShapeMode
//QGraphicsPixmapItem::ShapeMode
type QGraphicsPixmapItem__ShapeMode int64

const (
	QGraphicsPixmapItem__MaskShape          QGraphicsPixmapItem__ShapeMode = QGraphicsPixmapItem__ShapeMode(0)
	QGraphicsPixmapItem__BoundingRectShape  QGraphicsPixmapItem__ShapeMode = QGraphicsPixmapItem__ShapeMode(1)
	QGraphicsPixmapItem__HeuristicMaskShape QGraphicsPixmapItem__ShapeMode = QGraphicsPixmapItem__ShapeMode(2)
)

//go:generate stringer -type=QGraphicsPixmapItem__anonymous
//QGraphicsPixmapItem::anonymous
type QGraphicsPixmapItem__anonymous int64

const (
	QGraphicsPixmapItem__Type QGraphicsPixmapItem__anonymous = QGraphicsPixmapItem__anonymous(7)
)

func NewQGraphicsPixmapItem(parent QGraphicsItem_ITF) *QGraphicsPixmapItem {
	return NewQGraphicsPixmapItemFromPointer(C.QGraphicsPixmapItem_NewQGraphicsPixmapItem(PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsPixmapItem2(pixmap gui.QPixmap_ITF, parent QGraphicsItem_ITF) *QGraphicsPixmapItem {
	return NewQGraphicsPixmapItemFromPointer(C.QGraphicsPixmapItem_NewQGraphicsPixmapItem2(gui.PointerFromQPixmap(pixmap), PointerFromQGraphicsItem(parent)))
}

//export callbackQGraphicsPixmapItem_Paint
func callbackQGraphicsPixmapItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsPixmapItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsPixmapItem) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsPixmapItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsPixmapItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPixmapItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsPixmapItem) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPixmapItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsPixmapItem) SetOffset(offset core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPixmapItem_SetOffset(ptr.Pointer(), core.PointerFromQPointF(offset))
	}
}

func (ptr *QGraphicsPixmapItem) SetOffset2(x float64, y float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsPixmapItem_SetOffset2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QGraphicsPixmapItem) SetPixmap(pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPixmapItem_SetPixmap(ptr.Pointer(), gui.PointerFromQPixmap(pixmap))
	}
}

func (ptr *QGraphicsPixmapItem) SetShapeMode(mode QGraphicsPixmapItem__ShapeMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsPixmapItem_SetShapeMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QGraphicsPixmapItem) SetTransformationMode(mode core.Qt__TransformationMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsPixmapItem_SetTransformationMode(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQGraphicsPixmapItem_DestroyQGraphicsPixmapItem
func callbackQGraphicsPixmapItem_DestroyQGraphicsPixmapItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsPixmapItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsPixmapItemFromPointer(ptr).DestroyQGraphicsPixmapItemDefault()
	}
}

func (ptr *QGraphicsPixmapItem) ConnectDestroyQGraphicsPixmapItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsPixmapItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsPixmapItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsPixmapItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsPixmapItem) DisconnectDestroyQGraphicsPixmapItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsPixmapItem")
	}
}

func (ptr *QGraphicsPixmapItem) DestroyQGraphicsPixmapItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsPixmapItem_DestroyQGraphicsPixmapItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsPixmapItem) DestroyQGraphicsPixmapItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsPixmapItem_DestroyQGraphicsPixmapItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsPixmapItem) ShapeMode() QGraphicsPixmapItem__ShapeMode {
	if ptr.Pointer() != nil {
		return QGraphicsPixmapItem__ShapeMode(C.QGraphicsPixmapItem_ShapeMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsPixmapItem) Pixmap() *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QGraphicsPixmapItem_Pixmap(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsPixmapItem) Offset() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsPixmapItem_Offset(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsPixmapItem_BoundingRect
func callbackQGraphicsPixmapItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsPixmapItemFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsPixmapItem) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsPixmapItem) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsPixmapItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsPixmapItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsPixmapItem) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsPixmapItem_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsPixmapItem) TransformationMode() core.Qt__TransformationMode {
	if ptr.Pointer() != nil {
		return core.Qt__TransformationMode(C.QGraphicsPixmapItem_TransformationMode(ptr.Pointer()))
	}
	return 0
}

type QGraphicsPolygonItem struct {
	QAbstractGraphicsShapeItem
}

type QGraphicsPolygonItem_ITF interface {
	QAbstractGraphicsShapeItem_ITF
	QGraphicsPolygonItem_PTR() *QGraphicsPolygonItem
}

func (ptr *QGraphicsPolygonItem) QGraphicsPolygonItem_PTR() *QGraphicsPolygonItem {
	return ptr
}

func (ptr *QGraphicsPolygonItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractGraphicsShapeItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsPolygonItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractGraphicsShapeItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsPolygonItem(ptr QGraphicsPolygonItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsPolygonItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsPolygonItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsPolygonItem) {
	n = new(QGraphicsPolygonItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsPolygonItem__anonymous
//QGraphicsPolygonItem::anonymous
type QGraphicsPolygonItem__anonymous int64

const (
	QGraphicsPolygonItem__Type QGraphicsPolygonItem__anonymous = QGraphicsPolygonItem__anonymous(5)
)

func NewQGraphicsPolygonItem(parent QGraphicsItem_ITF) *QGraphicsPolygonItem {
	return NewQGraphicsPolygonItemFromPointer(C.QGraphicsPolygonItem_NewQGraphicsPolygonItem(PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsPolygonItem2(polygon gui.QPolygonF_ITF, parent QGraphicsItem_ITF) *QGraphicsPolygonItem {
	return NewQGraphicsPolygonItemFromPointer(C.QGraphicsPolygonItem_NewQGraphicsPolygonItem2(gui.PointerFromQPolygonF(polygon), PointerFromQGraphicsItem(parent)))
}

//export callbackQGraphicsPolygonItem_Paint
func callbackQGraphicsPolygonItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsPolygonItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsPolygonItem) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsPolygonItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsPolygonItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPolygonItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsPolygonItem) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPolygonItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsPolygonItem) SetFillRule(rule core.Qt__FillRule) {
	if ptr.Pointer() != nil {
		C.QGraphicsPolygonItem_SetFillRule(ptr.Pointer(), C.longlong(rule))
	}
}

func (ptr *QGraphicsPolygonItem) SetPolygon(polygon gui.QPolygonF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsPolygonItem_SetPolygon(ptr.Pointer(), gui.PointerFromQPolygonF(polygon))
	}
}

//export callbackQGraphicsPolygonItem_DestroyQGraphicsPolygonItem
func callbackQGraphicsPolygonItem_DestroyQGraphicsPolygonItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsPolygonItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsPolygonItemFromPointer(ptr).DestroyQGraphicsPolygonItemDefault()
	}
}

func (ptr *QGraphicsPolygonItem) ConnectDestroyQGraphicsPolygonItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsPolygonItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsPolygonItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsPolygonItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsPolygonItem) DisconnectDestroyQGraphicsPolygonItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsPolygonItem")
	}
}

func (ptr *QGraphicsPolygonItem) DestroyQGraphicsPolygonItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsPolygonItem_DestroyQGraphicsPolygonItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsPolygonItem) DestroyQGraphicsPolygonItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsPolygonItem_DestroyQGraphicsPolygonItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsPolygonItem) Polygon() *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsPolygonItem_Polygon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsPolygonItem_BoundingRect
func callbackQGraphicsPolygonItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsPolygonItemFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsPolygonItem) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsPolygonItem) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsPolygonItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsPolygonItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsPolygonItem) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsPolygonItem_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsPolygonItem) FillRule() core.Qt__FillRule {
	if ptr.Pointer() != nil {
		return core.Qt__FillRule(C.QGraphicsPolygonItem_FillRule(ptr.Pointer()))
	}
	return 0
}

type QGraphicsProxyWidget struct {
	QGraphicsWidget
}

type QGraphicsProxyWidget_ITF interface {
	QGraphicsWidget_ITF
	QGraphicsProxyWidget_PTR() *QGraphicsProxyWidget
}

func (ptr *QGraphicsProxyWidget) QGraphicsProxyWidget_PTR() *QGraphicsProxyWidget {
	return ptr
}

func (ptr *QGraphicsProxyWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsProxyWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsWidget_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsProxyWidget(ptr QGraphicsProxyWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsProxyWidget_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsProxyWidgetFromPointer(ptr unsafe.Pointer) (n *QGraphicsProxyWidget) {
	n = new(QGraphicsProxyWidget)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsProxyWidget__anonymous
//QGraphicsProxyWidget::anonymous
type QGraphicsProxyWidget__anonymous int64

const (
	QGraphicsProxyWidget__Type QGraphicsProxyWidget__anonymous = QGraphicsProxyWidget__anonymous(12)
)

func (ptr *QGraphicsProxyWidget) CreateProxyForChildWidget(child QWidget_ITF) *QGraphicsProxyWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsProxyWidgetFromPointer(C.QGraphicsProxyWidget_CreateProxyForChildWidget(ptr.Pointer(), PointerFromQWidget(child)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsProxyWidget_NewProxyWidget
func callbackQGraphicsProxyWidget_NewProxyWidget(ptr unsafe.Pointer, child unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "newProxyWidget"); signal != nil {
		return PointerFromQGraphicsProxyWidget((*(*func(*QWidget) *QGraphicsProxyWidget)(signal))(NewQWidgetFromPointer(child)))
	}

	return PointerFromQGraphicsProxyWidget(NewQGraphicsProxyWidgetFromPointer(ptr).NewProxyWidgetDefault(NewQWidgetFromPointer(child)))
}

func (ptr *QGraphicsProxyWidget) ConnectNewProxyWidget(f func(child *QWidget) *QGraphicsProxyWidget) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "newProxyWidget"); signal != nil {
			f := func(child *QWidget) *QGraphicsProxyWidget {
				(*(*func(*QWidget) *QGraphicsProxyWidget)(signal))(child)
				return f(child)
			}
			qt.ConnectSignal(ptr.Pointer(), "newProxyWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "newProxyWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsProxyWidget) DisconnectNewProxyWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "newProxyWidget")
	}
}

func (ptr *QGraphicsProxyWidget) NewProxyWidget(child QWidget_ITF) *QGraphicsProxyWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsProxyWidgetFromPointer(C.QGraphicsProxyWidget_NewProxyWidget(ptr.Pointer(), PointerFromQWidget(child)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsProxyWidget) NewProxyWidgetDefault(child QWidget_ITF) *QGraphicsProxyWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsProxyWidgetFromPointer(C.QGraphicsProxyWidget_NewProxyWidgetDefault(ptr.Pointer(), PointerFromQWidget(child)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQGraphicsProxyWidget(parent QGraphicsItem_ITF, wFlags core.Qt__WindowType) *QGraphicsProxyWidget {
	tmpValue := NewQGraphicsProxyWidgetFromPointer(C.QGraphicsProxyWidget_NewQGraphicsProxyWidget(PointerFromQGraphicsItem(parent), C.longlong(wFlags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QGraphicsProxyWidget) SetWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsProxyWidget_SetWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQGraphicsProxyWidget_DestroyQGraphicsProxyWidget
func callbackQGraphicsProxyWidget_DestroyQGraphicsProxyWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsProxyWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsProxyWidgetFromPointer(ptr).DestroyQGraphicsProxyWidgetDefault()
	}
}

func (ptr *QGraphicsProxyWidget) ConnectDestroyQGraphicsProxyWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsProxyWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsProxyWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsProxyWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsProxyWidget) DisconnectDestroyQGraphicsProxyWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsProxyWidget")
	}
}

func (ptr *QGraphicsProxyWidget) DestroyQGraphicsProxyWidget() {
	if ptr.Pointer() != nil {
		C.QGraphicsProxyWidget_DestroyQGraphicsProxyWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsProxyWidget) DestroyQGraphicsProxyWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsProxyWidget_DestroyQGraphicsProxyWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsProxyWidget) SubWidgetRect(widget QWidget_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsProxyWidget_SubWidgetRect(ptr.Pointer(), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsProxyWidget) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QGraphicsProxyWidget_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

type QGraphicsRectItem struct {
	QAbstractGraphicsShapeItem
}

type QGraphicsRectItem_ITF interface {
	QAbstractGraphicsShapeItem_ITF
	QGraphicsRectItem_PTR() *QGraphicsRectItem
}

func (ptr *QGraphicsRectItem) QGraphicsRectItem_PTR() *QGraphicsRectItem {
	return ptr
}

func (ptr *QGraphicsRectItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractGraphicsShapeItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsRectItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractGraphicsShapeItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsRectItem(ptr QGraphicsRectItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsRectItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsRectItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsRectItem) {
	n = new(QGraphicsRectItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsRectItem__anonymous
//QGraphicsRectItem::anonymous
type QGraphicsRectItem__anonymous int64

const (
	QGraphicsRectItem__Type QGraphicsRectItem__anonymous = QGraphicsRectItem__anonymous(3)
)

func NewQGraphicsRectItem(parent QGraphicsItem_ITF) *QGraphicsRectItem {
	return NewQGraphicsRectItemFromPointer(C.QGraphicsRectItem_NewQGraphicsRectItem(PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsRectItem2(rect core.QRectF_ITF, parent QGraphicsItem_ITF) *QGraphicsRectItem {
	return NewQGraphicsRectItemFromPointer(C.QGraphicsRectItem_NewQGraphicsRectItem2(core.PointerFromQRectF(rect), PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsRectItem3(x float64, y float64, width float64, height float64, parent QGraphicsItem_ITF) *QGraphicsRectItem {
	return NewQGraphicsRectItemFromPointer(C.QGraphicsRectItem_NewQGraphicsRectItem3(C.double(x), C.double(y), C.double(width), C.double(height), PointerFromQGraphicsItem(parent)))
}

//export callbackQGraphicsRectItem_Paint
func callbackQGraphicsRectItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsRectItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsRectItem) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsRectItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsRectItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsRectItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsRectItem) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsRectItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsRectItem) SetRect(rectangle core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsRectItem_SetRect(ptr.Pointer(), core.PointerFromQRectF(rectangle))
	}
}

func (ptr *QGraphicsRectItem) SetRect2(x float64, y float64, width float64, height float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsRectItem_SetRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height))
	}
}

//export callbackQGraphicsRectItem_DestroyQGraphicsRectItem
func callbackQGraphicsRectItem_DestroyQGraphicsRectItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsRectItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsRectItemFromPointer(ptr).DestroyQGraphicsRectItemDefault()
	}
}

func (ptr *QGraphicsRectItem) ConnectDestroyQGraphicsRectItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsRectItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsRectItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsRectItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsRectItem) DisconnectDestroyQGraphicsRectItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsRectItem")
	}
}

func (ptr *QGraphicsRectItem) DestroyQGraphicsRectItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsRectItem_DestroyQGraphicsRectItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsRectItem) DestroyQGraphicsRectItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsRectItem_DestroyQGraphicsRectItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsRectItem_BoundingRect
func callbackQGraphicsRectItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsRectItemFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsRectItem) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsRectItem) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsRectItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsRectItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsRectItem) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsRectItem_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsRectItem) Rect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsRectItem_Rect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

type QGraphicsRotation struct {
	QGraphicsTransform
}

type QGraphicsRotation_ITF interface {
	QGraphicsTransform_ITF
	QGraphicsRotation_PTR() *QGraphicsRotation
}

func (ptr *QGraphicsRotation) QGraphicsRotation_PTR() *QGraphicsRotation {
	return ptr
}

func (ptr *QGraphicsRotation) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsTransform_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsRotation) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsTransform_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsRotation(ptr QGraphicsRotation_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsRotation_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsRotationFromPointer(ptr unsafe.Pointer) (n *QGraphicsRotation) {
	n = new(QGraphicsRotation)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsRotation(parent core.QObject_ITF) *QGraphicsRotation {
	tmpValue := NewQGraphicsRotationFromPointer(C.QGraphicsRotation_NewQGraphicsRotation(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQGraphicsRotation_AngleChanged
func callbackQGraphicsRotation_AngleChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "angleChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsRotation) ConnectAngleChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "angleChanged") {
			C.QGraphicsRotation_ConnectAngleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "angleChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "angleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "angleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsRotation) DisconnectAngleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_DisconnectAngleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "angleChanged")
	}
}

func (ptr *QGraphicsRotation) AngleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_AngleChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsRotation_AxisChanged
func callbackQGraphicsRotation_AxisChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "axisChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsRotation) ConnectAxisChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "axisChanged") {
			C.QGraphicsRotation_ConnectAxisChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "axisChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "axisChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "axisChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsRotation) DisconnectAxisChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_DisconnectAxisChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "axisChanged")
	}
}

func (ptr *QGraphicsRotation) AxisChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_AxisChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsRotation_OriginChanged
func callbackQGraphicsRotation_OriginChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "originChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsRotation) ConnectOriginChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "originChanged") {
			C.QGraphicsRotation_ConnectOriginChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "originChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "originChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "originChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsRotation) DisconnectOriginChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_DisconnectOriginChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "originChanged")
	}
}

func (ptr *QGraphicsRotation) OriginChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_OriginChanged(ptr.Pointer())
	}
}

func (ptr *QGraphicsRotation) SetAngle(vqr float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_SetAngle(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QGraphicsRotation) SetAxis2(axis core.Qt__Axis) {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_SetAxis2(ptr.Pointer(), C.longlong(axis))
	}
}

func (ptr *QGraphicsRotation) SetAxis(axis gui.QVector3D_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_SetAxis(ptr.Pointer(), gui.PointerFromQVector3D(axis))
	}
}

func (ptr *QGraphicsRotation) SetOrigin(point gui.QVector3D_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_SetOrigin(ptr.Pointer(), gui.PointerFromQVector3D(point))
	}
}

//export callbackQGraphicsRotation_DestroyQGraphicsRotation
func callbackQGraphicsRotation_DestroyQGraphicsRotation(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsRotation"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsRotationFromPointer(ptr).DestroyQGraphicsRotationDefault()
	}
}

func (ptr *QGraphicsRotation) ConnectDestroyQGraphicsRotation(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsRotation"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsRotation", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsRotation", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsRotation) DisconnectDestroyQGraphicsRotation() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsRotation")
	}
}

func (ptr *QGraphicsRotation) DestroyQGraphicsRotation() {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_DestroyQGraphicsRotation(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsRotation) DestroyQGraphicsRotationDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_DestroyQGraphicsRotationDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsRotation) Axis() *gui.QVector3D {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQVector3DFromPointer(C.QGraphicsRotation_Axis(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QVector3D).DestroyQVector3D)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsRotation) Origin() *gui.QVector3D {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQVector3DFromPointer(C.QGraphicsRotation_Origin(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QVector3D).DestroyQVector3D)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsRotation) Angle() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsRotation_Angle(ptr.Pointer()))
	}
	return 0
}

//export callbackQGraphicsRotation_ApplyTo
func callbackQGraphicsRotation_ApplyTo(ptr unsafe.Pointer, matrix unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "applyTo"); signal != nil {
		(*(*func(*gui.QMatrix4x4))(signal))(gui.NewQMatrix4x4FromPointer(matrix))
	} else {
		NewQGraphicsRotationFromPointer(ptr).ApplyToDefault(gui.NewQMatrix4x4FromPointer(matrix))
	}
}

func (ptr *QGraphicsRotation) ConnectApplyTo(f func(matrix *gui.QMatrix4x4)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "applyTo"); signal != nil {
			f := func(matrix *gui.QMatrix4x4) {
				(*(*func(*gui.QMatrix4x4))(signal))(matrix)
				f(matrix)
			}
			qt.ConnectSignal(ptr.Pointer(), "applyTo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "applyTo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsRotation) DisconnectApplyTo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "applyTo")
	}
}

func (ptr *QGraphicsRotation) ApplyTo(matrix gui.QMatrix4x4_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_ApplyTo(ptr.Pointer(), gui.PointerFromQMatrix4x4(matrix))
	}
}

func (ptr *QGraphicsRotation) ApplyToDefault(matrix gui.QMatrix4x4_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsRotation_ApplyToDefault(ptr.Pointer(), gui.PointerFromQMatrix4x4(matrix))
	}
}

type QGraphicsScale struct {
	QGraphicsTransform
}

type QGraphicsScale_ITF interface {
	QGraphicsTransform_ITF
	QGraphicsScale_PTR() *QGraphicsScale
}

func (ptr *QGraphicsScale) QGraphicsScale_PTR() *QGraphicsScale {
	return ptr
}

func (ptr *QGraphicsScale) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsTransform_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsScale) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsTransform_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsScale(ptr QGraphicsScale_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsScale_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsScaleFromPointer(ptr unsafe.Pointer) (n *QGraphicsScale) {
	n = new(QGraphicsScale)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsScale(parent core.QObject_ITF) *QGraphicsScale {
	tmpValue := NewQGraphicsScaleFromPointer(C.QGraphicsScale_NewQGraphicsScale(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQGraphicsScale_OriginChanged
func callbackQGraphicsScale_OriginChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "originChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsScale) ConnectOriginChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "originChanged") {
			C.QGraphicsScale_ConnectOriginChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "originChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "originChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "originChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScale) DisconnectOriginChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_DisconnectOriginChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "originChanged")
	}
}

func (ptr *QGraphicsScale) OriginChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_OriginChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsScale_ScaleChanged
func callbackQGraphicsScale_ScaleChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "scaleChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsScale) ConnectScaleChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "scaleChanged") {
			C.QGraphicsScale_ConnectScaleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "scaleChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "scaleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scaleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScale) DisconnectScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_DisconnectScaleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "scaleChanged")
	}
}

func (ptr *QGraphicsScale) ScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_ScaleChanged(ptr.Pointer())
	}
}

func (ptr *QGraphicsScale) SetOrigin(point gui.QVector3D_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_SetOrigin(ptr.Pointer(), gui.PointerFromQVector3D(point))
	}
}

func (ptr *QGraphicsScale) SetXScale(vqr float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_SetXScale(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QGraphicsScale) SetYScale(vqr float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_SetYScale(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QGraphicsScale) SetZScale(vqr float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_SetZScale(ptr.Pointer(), C.double(vqr))
	}
}

//export callbackQGraphicsScale_XScaleChanged
func callbackQGraphicsScale_XScaleChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "xScaleChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsScale) ConnectXScaleChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "xScaleChanged") {
			C.QGraphicsScale_ConnectXScaleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "xScaleChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "xScaleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "xScaleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScale) DisconnectXScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_DisconnectXScaleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "xScaleChanged")
	}
}

func (ptr *QGraphicsScale) XScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_XScaleChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsScale_YScaleChanged
func callbackQGraphicsScale_YScaleChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "yScaleChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsScale) ConnectYScaleChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "yScaleChanged") {
			C.QGraphicsScale_ConnectYScaleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "yScaleChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "yScaleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "yScaleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScale) DisconnectYScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_DisconnectYScaleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "yScaleChanged")
	}
}

func (ptr *QGraphicsScale) YScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_YScaleChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsScale_ZScaleChanged
func callbackQGraphicsScale_ZScaleChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "zScaleChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsScale) ConnectZScaleChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "zScaleChanged") {
			C.QGraphicsScale_ConnectZScaleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "zScaleChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "zScaleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "zScaleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScale) DisconnectZScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_DisconnectZScaleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "zScaleChanged")
	}
}

func (ptr *QGraphicsScale) ZScaleChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_ZScaleChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsScale_DestroyQGraphicsScale
func callbackQGraphicsScale_DestroyQGraphicsScale(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsScale"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsScaleFromPointer(ptr).DestroyQGraphicsScaleDefault()
	}
}

func (ptr *QGraphicsScale) ConnectDestroyQGraphicsScale(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsScale"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsScale", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsScale", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScale) DisconnectDestroyQGraphicsScale() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsScale")
	}
}

func (ptr *QGraphicsScale) DestroyQGraphicsScale() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_DestroyQGraphicsScale(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsScale) DestroyQGraphicsScaleDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_DestroyQGraphicsScaleDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsScale) Origin() *gui.QVector3D {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQVector3DFromPointer(C.QGraphicsScale_Origin(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QVector3D).DestroyQVector3D)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScale) XScale() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsScale_XScale(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsScale) YScale() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsScale_YScale(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsScale) ZScale() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsScale_ZScale(ptr.Pointer()))
	}
	return 0
}

//export callbackQGraphicsScale_ApplyTo
func callbackQGraphicsScale_ApplyTo(ptr unsafe.Pointer, matrix unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "applyTo"); signal != nil {
		(*(*func(*gui.QMatrix4x4))(signal))(gui.NewQMatrix4x4FromPointer(matrix))
	} else {
		NewQGraphicsScaleFromPointer(ptr).ApplyToDefault(gui.NewQMatrix4x4FromPointer(matrix))
	}
}

func (ptr *QGraphicsScale) ConnectApplyTo(f func(matrix *gui.QMatrix4x4)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "applyTo"); signal != nil {
			f := func(matrix *gui.QMatrix4x4) {
				(*(*func(*gui.QMatrix4x4))(signal))(matrix)
				f(matrix)
			}
			qt.ConnectSignal(ptr.Pointer(), "applyTo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "applyTo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScale) DisconnectApplyTo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "applyTo")
	}
}

func (ptr *QGraphicsScale) ApplyTo(matrix gui.QMatrix4x4_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_ApplyTo(ptr.Pointer(), gui.PointerFromQMatrix4x4(matrix))
	}
}

func (ptr *QGraphicsScale) ApplyToDefault(matrix gui.QMatrix4x4_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScale_ApplyToDefault(ptr.Pointer(), gui.PointerFromQMatrix4x4(matrix))
	}
}

type QGraphicsScene struct {
	core.QObject
}

type QGraphicsScene_ITF interface {
	core.QObject_ITF
	QGraphicsScene_PTR() *QGraphicsScene
}

func (ptr *QGraphicsScene) QGraphicsScene_PTR() *QGraphicsScene {
	return ptr
}

func (ptr *QGraphicsScene) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsScene) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsScene(ptr QGraphicsScene_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsScene_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneFromPointer(ptr unsafe.Pointer) (n *QGraphicsScene) {
	n = new(QGraphicsScene)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsScene__ItemIndexMethod
//QGraphicsScene::ItemIndexMethod
type QGraphicsScene__ItemIndexMethod int64

const (
	QGraphicsScene__BspTreeIndex QGraphicsScene__ItemIndexMethod = QGraphicsScene__ItemIndexMethod(0)
	QGraphicsScene__NoIndex      QGraphicsScene__ItemIndexMethod = QGraphicsScene__ItemIndexMethod(-1)
)

//go:generate stringer -type=QGraphicsScene__SceneLayer
//QGraphicsScene::SceneLayer
type QGraphicsScene__SceneLayer int64

const (
	QGraphicsScene__ItemLayer       QGraphicsScene__SceneLayer = QGraphicsScene__SceneLayer(0x1)
	QGraphicsScene__BackgroundLayer QGraphicsScene__SceneLayer = QGraphicsScene__SceneLayer(0x2)
	QGraphicsScene__ForegroundLayer QGraphicsScene__SceneLayer = QGraphicsScene__SceneLayer(0x4)
	QGraphicsScene__AllLayers       QGraphicsScene__SceneLayer = QGraphicsScene__SceneLayer(0xffff)
)

func (ptr *QGraphicsScene) AddEllipse(rect core.QRectF_ITF, pen gui.QPen_ITF, brush gui.QBrush_ITF) *QGraphicsEllipseItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsEllipseItemFromPointer(C.QGraphicsScene_AddEllipse(ptr.Pointer(), core.PointerFromQRectF(rect), gui.PointerFromQPen(pen), gui.PointerFromQBrush(brush)))
	}
	return nil
}

func (ptr *QGraphicsScene) AddEllipse2(x float64, y float64, w float64, h float64, pen gui.QPen_ITF, brush gui.QBrush_ITF) *QGraphicsEllipseItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsEllipseItemFromPointer(C.QGraphicsScene_AddEllipse2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h), gui.PointerFromQPen(pen), gui.PointerFromQBrush(brush)))
	}
	return nil
}

func (ptr *QGraphicsScene) CreateItemGroup(items []*QGraphicsItem) *QGraphicsItemGroup {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemGroupFromPointer(C.QGraphicsScene_CreateItemGroup(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQGraphicsSceneFromPointer(NewQGraphicsSceneFromPointer(nil).__createItemGroup_items_newList())
			for _, v := range items {
				tmpList.__createItemGroup_items_setList(v)
			}
			return tmpList.Pointer()
		}()))
	}
	return nil
}

func (ptr *QGraphicsScene) AddLine(line core.QLineF_ITF, pen gui.QPen_ITF) *QGraphicsLineItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsLineItemFromPointer(C.QGraphicsScene_AddLine(ptr.Pointer(), core.PointerFromQLineF(line), gui.PointerFromQPen(pen)))
	}
	return nil
}

func (ptr *QGraphicsScene) AddLine2(x1 float64, y1 float64, x2 float64, y2 float64, pen gui.QPen_ITF) *QGraphicsLineItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsLineItemFromPointer(C.QGraphicsScene_AddLine2(ptr.Pointer(), C.double(x1), C.double(y1), C.double(x2), C.double(y2), gui.PointerFromQPen(pen)))
	}
	return nil
}

func (ptr *QGraphicsScene) AddPath(path gui.QPainterPath_ITF, pen gui.QPen_ITF, brush gui.QBrush_ITF) *QGraphicsPathItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsPathItemFromPointer(C.QGraphicsScene_AddPath(ptr.Pointer(), gui.PointerFromQPainterPath(path), gui.PointerFromQPen(pen), gui.PointerFromQBrush(brush)))
	}
	return nil
}

func (ptr *QGraphicsScene) AddPixmap(pixmap gui.QPixmap_ITF) *QGraphicsPixmapItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsPixmapItemFromPointer(C.QGraphicsScene_AddPixmap(ptr.Pointer(), gui.PointerFromQPixmap(pixmap)))
	}
	return nil
}

func (ptr *QGraphicsScene) AddPolygon(polygon gui.QPolygonF_ITF, pen gui.QPen_ITF, brush gui.QBrush_ITF) *QGraphicsPolygonItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsPolygonItemFromPointer(C.QGraphicsScene_AddPolygon(ptr.Pointer(), gui.PointerFromQPolygonF(polygon), gui.PointerFromQPen(pen), gui.PointerFromQBrush(brush)))
	}
	return nil
}

func (ptr *QGraphicsScene) AddWidget(widget QWidget_ITF, wFlags core.Qt__WindowType) *QGraphicsProxyWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsProxyWidgetFromPointer(C.QGraphicsScene_AddWidget(ptr.Pointer(), PointerFromQWidget(widget), C.longlong(wFlags)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) AddRect(rect core.QRectF_ITF, pen gui.QPen_ITF, brush gui.QBrush_ITF) *QGraphicsRectItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsRectItemFromPointer(C.QGraphicsScene_AddRect(ptr.Pointer(), core.PointerFromQRectF(rect), gui.PointerFromQPen(pen), gui.PointerFromQBrush(brush)))
	}
	return nil
}

func (ptr *QGraphicsScene) AddRect2(x float64, y float64, w float64, h float64, pen gui.QPen_ITF, brush gui.QBrush_ITF) *QGraphicsRectItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsRectItemFromPointer(C.QGraphicsScene_AddRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h), gui.PointerFromQPen(pen), gui.PointerFromQBrush(brush)))
	}
	return nil
}

func NewQGraphicsScene(parent core.QObject_ITF) *QGraphicsScene {
	tmpValue := NewQGraphicsSceneFromPointer(C.QGraphicsScene_NewQGraphicsScene(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQGraphicsScene2(sceneRect core.QRectF_ITF, parent core.QObject_ITF) *QGraphicsScene {
	tmpValue := NewQGraphicsSceneFromPointer(C.QGraphicsScene_NewQGraphicsScene2(core.PointerFromQRectF(sceneRect), core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQGraphicsScene3(x float64, y float64, width float64, height float64, parent core.QObject_ITF) *QGraphicsScene {
	tmpValue := NewQGraphicsSceneFromPointer(C.QGraphicsScene_NewQGraphicsScene3(C.double(x), C.double(y), C.double(width), C.double(height), core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QGraphicsScene) AddSimpleText(text string, font gui.QFont_ITF) *QGraphicsSimpleTextItem {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return NewQGraphicsSimpleTextItemFromPointer(C.QGraphicsScene_AddSimpleText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, gui.PointerFromQFont(font)))
	}
	return nil
}

func (ptr *QGraphicsScene) AddText(text string, font gui.QFont_ITF) *QGraphicsTextItem {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQGraphicsTextItemFromPointer(C.QGraphicsScene_AddText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, gui.PointerFromQFont(font)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func QGraphicsScene_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsScene_QGraphicsScene_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QGraphicsScene) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsScene_QGraphicsScene_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQGraphicsScene_Event
func callbackQGraphicsScene_Event(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsSceneFromPointer(ptr).EventDefault(core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsScene) EventDefault(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_EventDefault(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGraphicsScene_EventFilter
func callbackQGraphicsScene_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsSceneFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsScene) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGraphicsScene_FocusNextPrevChild
func callbackQGraphicsScene_FocusNextPrevChild(ptr unsafe.Pointer, next C.char) C.char {
	if signal := qt.GetSignal(ptr, "focusNextPrevChild"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(bool) bool)(signal))(int8(next) != 0))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsSceneFromPointer(ptr).FocusNextPrevChildDefault(int8(next) != 0))))
}

func (ptr *QGraphicsScene) ConnectFocusNextPrevChild(f func(next bool) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "focusNextPrevChild"); signal != nil {
			f := func(next bool) bool {
				(*(*func(bool) bool)(signal))(next)
				return f(next)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusNextPrevChild", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusNextPrevChild", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectFocusNextPrevChild() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "focusNextPrevChild")
	}
}

func (ptr *QGraphicsScene) FocusNextPrevChild(next bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_FocusNextPrevChild(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next))))) != 0
	}
	return false
}

func (ptr *QGraphicsScene) FocusNextPrevChildDefault(next bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_FocusNextPrevChildDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next))))) != 0
	}
	return false
}

func (ptr *QGraphicsScene) SendEvent(item QGraphicsItem_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_SendEvent(ptr.Pointer(), PointerFromQGraphicsItem(item), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QGraphicsScene) AddItem(item QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_AddItem(ptr.Pointer(), PointerFromQGraphicsItem(item))
	}
}

//export callbackQGraphicsScene_Advance
func callbackQGraphicsScene_Advance(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "advance"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneFromPointer(ptr).AdvanceDefault()
	}
}

func (ptr *QGraphicsScene) ConnectAdvance(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "advance"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "advance", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "advance", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectAdvance() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "advance")
	}
}

func (ptr *QGraphicsScene) Advance() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_Advance(ptr.Pointer())
	}
}

func (ptr *QGraphicsScene) AdvanceDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_AdvanceDefault(ptr.Pointer())
	}
}

//export callbackQGraphicsScene_Changed
func callbackQGraphicsScene_Changed(ptr unsafe.Pointer, region C.struct_QtWidgets_PackedList) {
	if signal := qt.GetSignal(ptr, "changed"); signal != nil {
		(*(*func([]*core.QRectF))(signal))(func(l C.struct_QtWidgets_PackedList) []*core.QRectF {
			out := make([]*core.QRectF, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__changed_region_atList(i)
			}
			return out
		}(region))
	}

}

func (ptr *QGraphicsScene) ConnectChanged(f func(region []*core.QRectF)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "changed") {
			C.QGraphicsScene_ConnectChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "changed"); signal != nil {
			f := func(region []*core.QRectF) {
				(*(*func([]*core.QRectF))(signal))(region)
				f(region)
			}
			qt.ConnectSignal(ptr.Pointer(), "changed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "changed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DisconnectChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "changed")
	}
}

func (ptr *QGraphicsScene) Changed(region []*core.QRectF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_Changed(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQGraphicsSceneFromPointer(NewQGraphicsSceneFromPointer(nil).__changed_region_newList())
			for _, v := range region {
				tmpList.__changed_region_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQGraphicsScene_Clear
func callbackQGraphicsScene_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QGraphicsScene) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QGraphicsScene) Clear() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_Clear(ptr.Pointer())
	}
}

func (ptr *QGraphicsScene) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_ClearDefault(ptr.Pointer())
	}
}

func (ptr *QGraphicsScene) ClearFocus() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_ClearFocus(ptr.Pointer())
	}
}

//export callbackQGraphicsScene_ClearSelection
func callbackQGraphicsScene_ClearSelection(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clearSelection"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneFromPointer(ptr).ClearSelectionDefault()
	}
}

func (ptr *QGraphicsScene) ConnectClearSelection(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clearSelection"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clearSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clearSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectClearSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clearSelection")
	}
}

func (ptr *QGraphicsScene) ClearSelection() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_ClearSelection(ptr.Pointer())
	}
}

func (ptr *QGraphicsScene) ClearSelectionDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_ClearSelectionDefault(ptr.Pointer())
	}
}

//export callbackQGraphicsScene_ContextMenuEvent
func callbackQGraphicsScene_ContextMenuEvent(ptr unsafe.Pointer, contextMenuEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "contextMenuEvent"); signal != nil {
		(*(*func(*QGraphicsSceneContextMenuEvent))(signal))(NewQGraphicsSceneContextMenuEventFromPointer(contextMenuEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).ContextMenuEventDefault(NewQGraphicsSceneContextMenuEventFromPointer(contextMenuEvent))
	}
}

func (ptr *QGraphicsScene) ConnectContextMenuEvent(f func(contextMenuEvent *QGraphicsSceneContextMenuEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "contextMenuEvent"); signal != nil {
			f := func(contextMenuEvent *QGraphicsSceneContextMenuEvent) {
				(*(*func(*QGraphicsSceneContextMenuEvent))(signal))(contextMenuEvent)
				f(contextMenuEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "contextMenuEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "contextMenuEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectContextMenuEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "contextMenuEvent")
	}
}

func (ptr *QGraphicsScene) ContextMenuEvent(contextMenuEvent QGraphicsSceneContextMenuEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_ContextMenuEvent(ptr.Pointer(), PointerFromQGraphicsSceneContextMenuEvent(contextMenuEvent))
	}
}

func (ptr *QGraphicsScene) ContextMenuEventDefault(contextMenuEvent QGraphicsSceneContextMenuEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_ContextMenuEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneContextMenuEvent(contextMenuEvent))
	}
}

func (ptr *QGraphicsScene) DestroyItemGroup(group QGraphicsItemGroup_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DestroyItemGroup(ptr.Pointer(), PointerFromQGraphicsItemGroup(group))
	}
}

//export callbackQGraphicsScene_DragEnterEvent
func callbackQGraphicsScene_DragEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dragEnterEvent"); signal != nil {
		(*(*func(*QGraphicsSceneDragDropEvent))(signal))(NewQGraphicsSceneDragDropEventFromPointer(event))
	} else {
		NewQGraphicsSceneFromPointer(ptr).DragEnterEventDefault(NewQGraphicsSceneDragDropEventFromPointer(event))
	}
}

func (ptr *QGraphicsScene) ConnectDragEnterEvent(f func(event *QGraphicsSceneDragDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dragEnterEvent"); signal != nil {
			f := func(event *QGraphicsSceneDragDropEvent) {
				(*(*func(*QGraphicsSceneDragDropEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dragEnterEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dragEnterEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectDragEnterEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dragEnterEvent")
	}
}

func (ptr *QGraphicsScene) DragEnterEvent(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DragEnterEvent(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

func (ptr *QGraphicsScene) DragEnterEventDefault(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DragEnterEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

//export callbackQGraphicsScene_DragLeaveEvent
func callbackQGraphicsScene_DragLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dragLeaveEvent"); signal != nil {
		(*(*func(*QGraphicsSceneDragDropEvent))(signal))(NewQGraphicsSceneDragDropEventFromPointer(event))
	} else {
		NewQGraphicsSceneFromPointer(ptr).DragLeaveEventDefault(NewQGraphicsSceneDragDropEventFromPointer(event))
	}
}

func (ptr *QGraphicsScene) ConnectDragLeaveEvent(f func(event *QGraphicsSceneDragDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dragLeaveEvent"); signal != nil {
			f := func(event *QGraphicsSceneDragDropEvent) {
				(*(*func(*QGraphicsSceneDragDropEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dragLeaveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dragLeaveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectDragLeaveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dragLeaveEvent")
	}
}

func (ptr *QGraphicsScene) DragLeaveEvent(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DragLeaveEvent(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

func (ptr *QGraphicsScene) DragLeaveEventDefault(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DragLeaveEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

//export callbackQGraphicsScene_DragMoveEvent
func callbackQGraphicsScene_DragMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dragMoveEvent"); signal != nil {
		(*(*func(*QGraphicsSceneDragDropEvent))(signal))(NewQGraphicsSceneDragDropEventFromPointer(event))
	} else {
		NewQGraphicsSceneFromPointer(ptr).DragMoveEventDefault(NewQGraphicsSceneDragDropEventFromPointer(event))
	}
}

func (ptr *QGraphicsScene) ConnectDragMoveEvent(f func(event *QGraphicsSceneDragDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dragMoveEvent"); signal != nil {
			f := func(event *QGraphicsSceneDragDropEvent) {
				(*(*func(*QGraphicsSceneDragDropEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dragMoveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dragMoveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectDragMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dragMoveEvent")
	}
}

func (ptr *QGraphicsScene) DragMoveEvent(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DragMoveEvent(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

func (ptr *QGraphicsScene) DragMoveEventDefault(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DragMoveEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

//export callbackQGraphicsScene_DrawBackground
func callbackQGraphicsScene_DrawBackground(ptr unsafe.Pointer, painter unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawBackground"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRectF))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect))
	} else {
		NewQGraphicsSceneFromPointer(ptr).DrawBackgroundDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect))
	}
}

func (ptr *QGraphicsScene) ConnectDrawBackground(f func(painter *gui.QPainter, rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawBackground"); signal != nil {
			f := func(painter *gui.QPainter, rect *core.QRectF) {
				(*(*func(*gui.QPainter, *core.QRectF))(signal))(painter, rect)
				f(painter, rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawBackground", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawBackground", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectDrawBackground() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawBackground")
	}
}

func (ptr *QGraphicsScene) DrawBackground(painter gui.QPainter_ITF, rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DrawBackground(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsScene) DrawBackgroundDefault(painter gui.QPainter_ITF, rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DrawBackgroundDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(rect))
	}
}

//export callbackQGraphicsScene_DrawForeground
func callbackQGraphicsScene_DrawForeground(ptr unsafe.Pointer, painter unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawForeground"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRectF))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect))
	} else {
		NewQGraphicsSceneFromPointer(ptr).DrawForegroundDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect))
	}
}

func (ptr *QGraphicsScene) ConnectDrawForeground(f func(painter *gui.QPainter, rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawForeground"); signal != nil {
			f := func(painter *gui.QPainter, rect *core.QRectF) {
				(*(*func(*gui.QPainter, *core.QRectF))(signal))(painter, rect)
				f(painter, rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawForeground", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawForeground", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectDrawForeground() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawForeground")
	}
}

func (ptr *QGraphicsScene) DrawForeground(painter gui.QPainter_ITF, rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DrawForeground(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsScene) DrawForegroundDefault(painter gui.QPainter_ITF, rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DrawForegroundDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(rect))
	}
}

//export callbackQGraphicsScene_DropEvent
func callbackQGraphicsScene_DropEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dropEvent"); signal != nil {
		(*(*func(*QGraphicsSceneDragDropEvent))(signal))(NewQGraphicsSceneDragDropEventFromPointer(event))
	} else {
		NewQGraphicsSceneFromPointer(ptr).DropEventDefault(NewQGraphicsSceneDragDropEventFromPointer(event))
	}
}

func (ptr *QGraphicsScene) ConnectDropEvent(f func(event *QGraphicsSceneDragDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dropEvent"); signal != nil {
			f := func(event *QGraphicsSceneDragDropEvent) {
				(*(*func(*QGraphicsSceneDragDropEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dropEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dropEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectDropEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dropEvent")
	}
}

func (ptr *QGraphicsScene) DropEvent(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DropEvent(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

func (ptr *QGraphicsScene) DropEventDefault(event QGraphicsSceneDragDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DropEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneDragDropEvent(event))
	}
}

//export callbackQGraphicsScene_FocusInEvent
func callbackQGraphicsScene_FocusInEvent(ptr unsafe.Pointer, focusEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "focusInEvent"); signal != nil {
		(*(*func(*gui.QFocusEvent))(signal))(gui.NewQFocusEventFromPointer(focusEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).FocusInEventDefault(gui.NewQFocusEventFromPointer(focusEvent))
	}
}

func (ptr *QGraphicsScene) ConnectFocusInEvent(f func(focusEvent *gui.QFocusEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "focusInEvent"); signal != nil {
			f := func(focusEvent *gui.QFocusEvent) {
				(*(*func(*gui.QFocusEvent))(signal))(focusEvent)
				f(focusEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusInEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusInEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectFocusInEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "focusInEvent")
	}
}

func (ptr *QGraphicsScene) FocusInEvent(focusEvent gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_FocusInEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(focusEvent))
	}
}

func (ptr *QGraphicsScene) FocusInEventDefault(focusEvent gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_FocusInEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(focusEvent))
	}
}

//export callbackQGraphicsScene_FocusItemChanged
func callbackQGraphicsScene_FocusItemChanged(ptr unsafe.Pointer, newFocusItem unsafe.Pointer, oldFocusItem unsafe.Pointer, reason C.longlong) {
	if signal := qt.GetSignal(ptr, "focusItemChanged"); signal != nil {
		(*(*func(*QGraphicsItem, *QGraphicsItem, core.Qt__FocusReason))(signal))(NewQGraphicsItemFromPointer(newFocusItem), NewQGraphicsItemFromPointer(oldFocusItem), core.Qt__FocusReason(reason))
	}

}

func (ptr *QGraphicsScene) ConnectFocusItemChanged(f func(newFocusItem *QGraphicsItem, oldFocusItem *QGraphicsItem, reason core.Qt__FocusReason)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "focusItemChanged") {
			C.QGraphicsScene_ConnectFocusItemChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "focusItemChanged"); signal != nil {
			f := func(newFocusItem *QGraphicsItem, oldFocusItem *QGraphicsItem, reason core.Qt__FocusReason) {
				(*(*func(*QGraphicsItem, *QGraphicsItem, core.Qt__FocusReason))(signal))(newFocusItem, oldFocusItem, reason)
				f(newFocusItem, oldFocusItem, reason)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusItemChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusItemChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectFocusItemChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DisconnectFocusItemChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "focusItemChanged")
	}
}

func (ptr *QGraphicsScene) FocusItemChanged(newFocusItem QGraphicsItem_ITF, oldFocusItem QGraphicsItem_ITF, reason core.Qt__FocusReason) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_FocusItemChanged(ptr.Pointer(), PointerFromQGraphicsItem(newFocusItem), PointerFromQGraphicsItem(oldFocusItem), C.longlong(reason))
	}
}

//export callbackQGraphicsScene_FocusOutEvent
func callbackQGraphicsScene_FocusOutEvent(ptr unsafe.Pointer, focusEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "focusOutEvent"); signal != nil {
		(*(*func(*gui.QFocusEvent))(signal))(gui.NewQFocusEventFromPointer(focusEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).FocusOutEventDefault(gui.NewQFocusEventFromPointer(focusEvent))
	}
}

func (ptr *QGraphicsScene) ConnectFocusOutEvent(f func(focusEvent *gui.QFocusEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "focusOutEvent"); signal != nil {
			f := func(focusEvent *gui.QFocusEvent) {
				(*(*func(*gui.QFocusEvent))(signal))(focusEvent)
				f(focusEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusOutEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusOutEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectFocusOutEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "focusOutEvent")
	}
}

func (ptr *QGraphicsScene) FocusOutEvent(focusEvent gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_FocusOutEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(focusEvent))
	}
}

func (ptr *QGraphicsScene) FocusOutEventDefault(focusEvent gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_FocusOutEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(focusEvent))
	}
}

//export callbackQGraphicsScene_HelpEvent
func callbackQGraphicsScene_HelpEvent(ptr unsafe.Pointer, helpEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "helpEvent"); signal != nil {
		(*(*func(*QGraphicsSceneHelpEvent))(signal))(NewQGraphicsSceneHelpEventFromPointer(helpEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).HelpEventDefault(NewQGraphicsSceneHelpEventFromPointer(helpEvent))
	}
}

func (ptr *QGraphicsScene) ConnectHelpEvent(f func(helpEvent *QGraphicsSceneHelpEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "helpEvent"); signal != nil {
			f := func(helpEvent *QGraphicsSceneHelpEvent) {
				(*(*func(*QGraphicsSceneHelpEvent))(signal))(helpEvent)
				f(helpEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "helpEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "helpEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectHelpEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "helpEvent")
	}
}

func (ptr *QGraphicsScene) HelpEvent(helpEvent QGraphicsSceneHelpEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_HelpEvent(ptr.Pointer(), PointerFromQGraphicsSceneHelpEvent(helpEvent))
	}
}

func (ptr *QGraphicsScene) HelpEventDefault(helpEvent QGraphicsSceneHelpEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_HelpEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneHelpEvent(helpEvent))
	}
}

//export callbackQGraphicsScene_InputMethodEvent
func callbackQGraphicsScene_InputMethodEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "inputMethodEvent"); signal != nil {
		(*(*func(*gui.QInputMethodEvent))(signal))(gui.NewQInputMethodEventFromPointer(event))
	} else {
		NewQGraphicsSceneFromPointer(ptr).InputMethodEventDefault(gui.NewQInputMethodEventFromPointer(event))
	}
}

func (ptr *QGraphicsScene) ConnectInputMethodEvent(f func(event *gui.QInputMethodEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "inputMethodEvent"); signal != nil {
			f := func(event *gui.QInputMethodEvent) {
				(*(*func(*gui.QInputMethodEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "inputMethodEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "inputMethodEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectInputMethodEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "inputMethodEvent")
	}
}

func (ptr *QGraphicsScene) InputMethodEvent(event gui.QInputMethodEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_InputMethodEvent(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
	}
}

func (ptr *QGraphicsScene) InputMethodEventDefault(event gui.QInputMethodEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_InputMethodEventDefault(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
	}
}

//export callbackQGraphicsScene_Invalidate
func callbackQGraphicsScene_Invalidate(ptr unsafe.Pointer, rect unsafe.Pointer, layers C.longlong) {
	if signal := qt.GetSignal(ptr, "invalidate"); signal != nil {
		(*(*func(*core.QRectF, QGraphicsScene__SceneLayer))(signal))(core.NewQRectFFromPointer(rect), QGraphicsScene__SceneLayer(layers))
	} else {
		NewQGraphicsSceneFromPointer(ptr).InvalidateDefault(core.NewQRectFFromPointer(rect), QGraphicsScene__SceneLayer(layers))
	}
}

func (ptr *QGraphicsScene) ConnectInvalidate(f func(rect *core.QRectF, layers QGraphicsScene__SceneLayer)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "invalidate"); signal != nil {
			f := func(rect *core.QRectF, layers QGraphicsScene__SceneLayer) {
				(*(*func(*core.QRectF, QGraphicsScene__SceneLayer))(signal))(rect, layers)
				f(rect, layers)
			}
			qt.ConnectSignal(ptr.Pointer(), "invalidate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "invalidate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectInvalidate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "invalidate")
	}
}

func (ptr *QGraphicsScene) Invalidate(rect core.QRectF_ITF, layers QGraphicsScene__SceneLayer) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_Invalidate(ptr.Pointer(), core.PointerFromQRectF(rect), C.longlong(layers))
	}
}

func (ptr *QGraphicsScene) InvalidateDefault(rect core.QRectF_ITF, layers QGraphicsScene__SceneLayer) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_InvalidateDefault(ptr.Pointer(), core.PointerFromQRectF(rect), C.longlong(layers))
	}
}

func (ptr *QGraphicsScene) Invalidate2(x float64, y float64, w float64, h float64, layers QGraphicsScene__SceneLayer) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_Invalidate2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h), C.longlong(layers))
	}
}

//export callbackQGraphicsScene_KeyPressEvent
func callbackQGraphicsScene_KeyPressEvent(ptr unsafe.Pointer, keyEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "keyPressEvent"); signal != nil {
		(*(*func(*gui.QKeyEvent))(signal))(gui.NewQKeyEventFromPointer(keyEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).KeyPressEventDefault(gui.NewQKeyEventFromPointer(keyEvent))
	}
}

func (ptr *QGraphicsScene) ConnectKeyPressEvent(f func(keyEvent *gui.QKeyEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "keyPressEvent"); signal != nil {
			f := func(keyEvent *gui.QKeyEvent) {
				(*(*func(*gui.QKeyEvent))(signal))(keyEvent)
				f(keyEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "keyPressEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "keyPressEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectKeyPressEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "keyPressEvent")
	}
}

func (ptr *QGraphicsScene) KeyPressEvent(keyEvent gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_KeyPressEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(keyEvent))
	}
}

func (ptr *QGraphicsScene) KeyPressEventDefault(keyEvent gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_KeyPressEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(keyEvent))
	}
}

//export callbackQGraphicsScene_KeyReleaseEvent
func callbackQGraphicsScene_KeyReleaseEvent(ptr unsafe.Pointer, keyEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "keyReleaseEvent"); signal != nil {
		(*(*func(*gui.QKeyEvent))(signal))(gui.NewQKeyEventFromPointer(keyEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).KeyReleaseEventDefault(gui.NewQKeyEventFromPointer(keyEvent))
	}
}

func (ptr *QGraphicsScene) ConnectKeyReleaseEvent(f func(keyEvent *gui.QKeyEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "keyReleaseEvent"); signal != nil {
			f := func(keyEvent *gui.QKeyEvent) {
				(*(*func(*gui.QKeyEvent))(signal))(keyEvent)
				f(keyEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "keyReleaseEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "keyReleaseEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectKeyReleaseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "keyReleaseEvent")
	}
}

func (ptr *QGraphicsScene) KeyReleaseEvent(keyEvent gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_KeyReleaseEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(keyEvent))
	}
}

func (ptr *QGraphicsScene) KeyReleaseEventDefault(keyEvent gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_KeyReleaseEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(keyEvent))
	}
}

//export callbackQGraphicsScene_MouseDoubleClickEvent
func callbackQGraphicsScene_MouseDoubleClickEvent(ptr unsafe.Pointer, mouseEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mouseDoubleClickEvent"); signal != nil {
		(*(*func(*QGraphicsSceneMouseEvent))(signal))(NewQGraphicsSceneMouseEventFromPointer(mouseEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).MouseDoubleClickEventDefault(NewQGraphicsSceneMouseEventFromPointer(mouseEvent))
	}
}

func (ptr *QGraphicsScene) ConnectMouseDoubleClickEvent(f func(mouseEvent *QGraphicsSceneMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mouseDoubleClickEvent"); signal != nil {
			f := func(mouseEvent *QGraphicsSceneMouseEvent) {
				(*(*func(*QGraphicsSceneMouseEvent))(signal))(mouseEvent)
				f(mouseEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "mouseDoubleClickEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mouseDoubleClickEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectMouseDoubleClickEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mouseDoubleClickEvent")
	}
}

func (ptr *QGraphicsScene) MouseDoubleClickEvent(mouseEvent QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_MouseDoubleClickEvent(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(mouseEvent))
	}
}

func (ptr *QGraphicsScene) MouseDoubleClickEventDefault(mouseEvent QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_MouseDoubleClickEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(mouseEvent))
	}
}

//export callbackQGraphicsScene_MouseMoveEvent
func callbackQGraphicsScene_MouseMoveEvent(ptr unsafe.Pointer, mouseEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mouseMoveEvent"); signal != nil {
		(*(*func(*QGraphicsSceneMouseEvent))(signal))(NewQGraphicsSceneMouseEventFromPointer(mouseEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).MouseMoveEventDefault(NewQGraphicsSceneMouseEventFromPointer(mouseEvent))
	}
}

func (ptr *QGraphicsScene) ConnectMouseMoveEvent(f func(mouseEvent *QGraphicsSceneMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mouseMoveEvent"); signal != nil {
			f := func(mouseEvent *QGraphicsSceneMouseEvent) {
				(*(*func(*QGraphicsSceneMouseEvent))(signal))(mouseEvent)
				f(mouseEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "mouseMoveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mouseMoveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectMouseMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mouseMoveEvent")
	}
}

func (ptr *QGraphicsScene) MouseMoveEvent(mouseEvent QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_MouseMoveEvent(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(mouseEvent))
	}
}

func (ptr *QGraphicsScene) MouseMoveEventDefault(mouseEvent QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_MouseMoveEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(mouseEvent))
	}
}

//export callbackQGraphicsScene_MousePressEvent
func callbackQGraphicsScene_MousePressEvent(ptr unsafe.Pointer, mouseEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mousePressEvent"); signal != nil {
		(*(*func(*QGraphicsSceneMouseEvent))(signal))(NewQGraphicsSceneMouseEventFromPointer(mouseEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).MousePressEventDefault(NewQGraphicsSceneMouseEventFromPointer(mouseEvent))
	}
}

func (ptr *QGraphicsScene) ConnectMousePressEvent(f func(mouseEvent *QGraphicsSceneMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mousePressEvent"); signal != nil {
			f := func(mouseEvent *QGraphicsSceneMouseEvent) {
				(*(*func(*QGraphicsSceneMouseEvent))(signal))(mouseEvent)
				f(mouseEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "mousePressEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mousePressEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectMousePressEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mousePressEvent")
	}
}

func (ptr *QGraphicsScene) MousePressEvent(mouseEvent QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_MousePressEvent(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(mouseEvent))
	}
}

func (ptr *QGraphicsScene) MousePressEventDefault(mouseEvent QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_MousePressEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(mouseEvent))
	}
}

//export callbackQGraphicsScene_MouseReleaseEvent
func callbackQGraphicsScene_MouseReleaseEvent(ptr unsafe.Pointer, mouseEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mouseReleaseEvent"); signal != nil {
		(*(*func(*QGraphicsSceneMouseEvent))(signal))(NewQGraphicsSceneMouseEventFromPointer(mouseEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).MouseReleaseEventDefault(NewQGraphicsSceneMouseEventFromPointer(mouseEvent))
	}
}

func (ptr *QGraphicsScene) ConnectMouseReleaseEvent(f func(mouseEvent *QGraphicsSceneMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mouseReleaseEvent"); signal != nil {
			f := func(mouseEvent *QGraphicsSceneMouseEvent) {
				(*(*func(*QGraphicsSceneMouseEvent))(signal))(mouseEvent)
				f(mouseEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "mouseReleaseEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mouseReleaseEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectMouseReleaseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mouseReleaseEvent")
	}
}

func (ptr *QGraphicsScene) MouseReleaseEvent(mouseEvent QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_MouseReleaseEvent(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(mouseEvent))
	}
}

func (ptr *QGraphicsScene) MouseReleaseEventDefault(mouseEvent QGraphicsSceneMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_MouseReleaseEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneMouseEvent(mouseEvent))
	}
}

func (ptr *QGraphicsScene) RemoveItem(item QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_RemoveItem(ptr.Pointer(), PointerFromQGraphicsItem(item))
	}
}

func (ptr *QGraphicsScene) Render(painter gui.QPainter_ITF, target core.QRectF_ITF, source core.QRectF_ITF, aspectRatioMode core.Qt__AspectRatioMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_Render(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(target), core.PointerFromQRectF(source), C.longlong(aspectRatioMode))
	}
}

//export callbackQGraphicsScene_SceneRectChanged
func callbackQGraphicsScene_SceneRectChanged(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "sceneRectChanged"); signal != nil {
		(*(*func(*core.QRectF))(signal))(core.NewQRectFFromPointer(rect))
	}

}

func (ptr *QGraphicsScene) ConnectSceneRectChanged(f func(rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sceneRectChanged") {
			C.QGraphicsScene_ConnectSceneRectChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sceneRectChanged"); signal != nil {
			f := func(rect *core.QRectF) {
				(*(*func(*core.QRectF))(signal))(rect)
				f(rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "sceneRectChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sceneRectChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectSceneRectChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DisconnectSceneRectChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sceneRectChanged")
	}
}

func (ptr *QGraphicsScene) SceneRectChanged(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SceneRectChanged(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

//export callbackQGraphicsScene_SelectionChanged
func callbackQGraphicsScene_SelectionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsScene) ConnectSelectionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "selectionChanged") {
			C.QGraphicsScene_ConnectSelectionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "selectionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DisconnectSelectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "selectionChanged")
	}
}

func (ptr *QGraphicsScene) SelectionChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SelectionChanged(ptr.Pointer())
	}
}

func (ptr *QGraphicsScene) SetActivePanel(item QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetActivePanel(ptr.Pointer(), PointerFromQGraphicsItem(item))
	}
}

func (ptr *QGraphicsScene) SetActiveWindow(widget QGraphicsWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetActiveWindow(ptr.Pointer(), PointerFromQGraphicsWidget(widget))
	}
}

func (ptr *QGraphicsScene) SetBackgroundBrush(brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetBackgroundBrush(ptr.Pointer(), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QGraphicsScene) SetBspTreeDepth(depth int) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetBspTreeDepth(ptr.Pointer(), C.int(int32(depth)))
	}
}

func (ptr *QGraphicsScene) SetFocus(focusReason core.Qt__FocusReason) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetFocus(ptr.Pointer(), C.longlong(focusReason))
	}
}

func (ptr *QGraphicsScene) SetFocusItem(item QGraphicsItem_ITF, focusReason core.Qt__FocusReason) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetFocusItem(ptr.Pointer(), PointerFromQGraphicsItem(item), C.longlong(focusReason))
	}
}

func (ptr *QGraphicsScene) SetFocusOnTouch(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetFocusOnTouch(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsScene) SetFont(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetFont(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

func (ptr *QGraphicsScene) SetForegroundBrush(brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetForegroundBrush(ptr.Pointer(), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QGraphicsScene) SetItemIndexMethod(method QGraphicsScene__ItemIndexMethod) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetItemIndexMethod(ptr.Pointer(), C.longlong(method))
	}
}

func (ptr *QGraphicsScene) SetMinimumRenderSize(minSize float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetMinimumRenderSize(ptr.Pointer(), C.double(minSize))
	}
}

func (ptr *QGraphicsScene) SetPalette(palette gui.QPalette_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetPalette(ptr.Pointer(), gui.PointerFromQPalette(palette))
	}
}

func (ptr *QGraphicsScene) SetSceneRect(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetSceneRect(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsScene) SetSceneRect2(x float64, y float64, w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetSceneRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h))
	}
}

func (ptr *QGraphicsScene) SetSelectionArea2(path gui.QPainterPath_ITF, mode core.Qt__ItemSelectionMode, deviceTransform gui.QTransform_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetSelectionArea2(ptr.Pointer(), gui.PointerFromQPainterPath(path), C.longlong(mode), gui.PointerFromQTransform(deviceTransform))
	}
}

func (ptr *QGraphicsScene) SetSelectionArea3(path gui.QPainterPath_ITF, selectionOperation core.Qt__ItemSelectionOperation, mode core.Qt__ItemSelectionMode, deviceTransform gui.QTransform_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetSelectionArea3(ptr.Pointer(), gui.PointerFromQPainterPath(path), C.longlong(selectionOperation), C.longlong(mode), gui.PointerFromQTransform(deviceTransform))
	}
}

func (ptr *QGraphicsScene) SetSelectionArea(path gui.QPainterPath_ITF, deviceTransform gui.QTransform_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetSelectionArea(ptr.Pointer(), gui.PointerFromQPainterPath(path), gui.PointerFromQTransform(deviceTransform))
	}
}

func (ptr *QGraphicsScene) SetSortCacheEnabled(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetSortCacheEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsScene) SetStickyFocus(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetStickyFocus(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsScene) SetStyle(style QStyle_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_SetStyle(ptr.Pointer(), PointerFromQStyle(style))
	}
}

//export callbackQGraphicsScene_Update
func callbackQGraphicsScene_Update(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "update"); signal != nil {
		(*(*func(*core.QRectF))(signal))(core.NewQRectFFromPointer(rect))
	} else {
		NewQGraphicsSceneFromPointer(ptr).UpdateDefault(core.NewQRectFFromPointer(rect))
	}
}

func (ptr *QGraphicsScene) ConnectUpdate(f func(rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "update"); signal != nil {
			f := func(rect *core.QRectF) {
				(*(*func(*core.QRectF))(signal))(rect)
				f(rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "update", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "update", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectUpdate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "update")
	}
}

func (ptr *QGraphicsScene) Update(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_Update(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsScene) UpdateDefault(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_UpdateDefault(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsScene) Update2(x float64, y float64, w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_Update2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h))
	}
}

//export callbackQGraphicsScene_WheelEvent
func callbackQGraphicsScene_WheelEvent(ptr unsafe.Pointer, wheelEvent unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "wheelEvent"); signal != nil {
		(*(*func(*QGraphicsSceneWheelEvent))(signal))(NewQGraphicsSceneWheelEventFromPointer(wheelEvent))
	} else {
		NewQGraphicsSceneFromPointer(ptr).WheelEventDefault(NewQGraphicsSceneWheelEventFromPointer(wheelEvent))
	}
}

func (ptr *QGraphicsScene) ConnectWheelEvent(f func(wheelEvent *QGraphicsSceneWheelEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "wheelEvent"); signal != nil {
			f := func(wheelEvent *QGraphicsSceneWheelEvent) {
				(*(*func(*QGraphicsSceneWheelEvent))(signal))(wheelEvent)
				f(wheelEvent)
			}
			qt.ConnectSignal(ptr.Pointer(), "wheelEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "wheelEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectWheelEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "wheelEvent")
	}
}

func (ptr *QGraphicsScene) WheelEvent(wheelEvent QGraphicsSceneWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_WheelEvent(ptr.Pointer(), PointerFromQGraphicsSceneWheelEvent(wheelEvent))
	}
}

func (ptr *QGraphicsScene) WheelEventDefault(wheelEvent QGraphicsSceneWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_WheelEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneWheelEvent(wheelEvent))
	}
}

//export callbackQGraphicsScene_DestroyQGraphicsScene
func callbackQGraphicsScene_DestroyQGraphicsScene(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsScene"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneFromPointer(ptr).DestroyQGraphicsSceneDefault()
	}
}

func (ptr *QGraphicsScene) ConnectDestroyQGraphicsScene(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsScene"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsScene", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsScene", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectDestroyQGraphicsScene() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsScene")
	}
}

func (ptr *QGraphicsScene) DestroyQGraphicsScene() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DestroyQGraphicsScene(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsScene) DestroyQGraphicsSceneDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DestroyQGraphicsSceneDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsScene) BackgroundBrush() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QGraphicsScene_BackgroundBrush(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) ForegroundBrush() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QGraphicsScene_ForegroundBrush(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QGraphicsScene_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) ActivePanel() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene_ActivePanel(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsScene) FocusItem() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene_FocusItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsScene) ItemAt(position core.QPointF_ITF, deviceTransform gui.QTransform_ITF) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene_ItemAt(ptr.Pointer(), core.PointerFromQPointF(position), gui.PointerFromQTransform(deviceTransform)))
	}
	return nil
}

func (ptr *QGraphicsScene) ItemAt4(x float64, y float64, deviceTransform gui.QTransform_ITF) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene_ItemAt4(ptr.Pointer(), C.double(x), C.double(y), gui.PointerFromQTransform(deviceTransform)))
	}
	return nil
}

func (ptr *QGraphicsScene) MouseGrabberItem() *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene_MouseGrabberItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsScene) ItemIndexMethod() QGraphicsScene__ItemIndexMethod {
	if ptr.Pointer() != nil {
		return QGraphicsScene__ItemIndexMethod(C.QGraphicsScene_ItemIndexMethod(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsScene) ActiveWindow() *QGraphicsWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsWidgetFromPointer(C.QGraphicsScene_ActiveWindow(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) CollidingItems(item QGraphicsItem_ITF, mode core.Qt__ItemSelectionMode) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__collidingItems_atList(i)
			}
			return out
		}(C.QGraphicsScene_CollidingItems(ptr.Pointer(), PointerFromQGraphicsItem(item), C.longlong(mode)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsScene) Items(order core.Qt__SortOrder) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList(i)
			}
			return out
		}(C.QGraphicsScene_Items(ptr.Pointer(), C.longlong(order)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsScene) Items5(path gui.QPainterPath_ITF, mode core.Qt__ItemSelectionMode, order core.Qt__SortOrder, deviceTransform gui.QTransform_ITF) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList5(i)
			}
			return out
		}(C.QGraphicsScene_Items5(ptr.Pointer(), gui.PointerFromQPainterPath(path), C.longlong(mode), C.longlong(order), gui.PointerFromQTransform(deviceTransform)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsScene) Items2(pos core.QPointF_ITF, mode core.Qt__ItemSelectionMode, order core.Qt__SortOrder, deviceTransform gui.QTransform_ITF) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList2(i)
			}
			return out
		}(C.QGraphicsScene_Items2(ptr.Pointer(), core.PointerFromQPointF(pos), C.longlong(mode), C.longlong(order), gui.PointerFromQTransform(deviceTransform)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsScene) Items4(polygon gui.QPolygonF_ITF, mode core.Qt__ItemSelectionMode, order core.Qt__SortOrder, deviceTransform gui.QTransform_ITF) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList4(i)
			}
			return out
		}(C.QGraphicsScene_Items4(ptr.Pointer(), gui.PointerFromQPolygonF(polygon), C.longlong(mode), C.longlong(order), gui.PointerFromQTransform(deviceTransform)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsScene) Items3(rect core.QRectF_ITF, mode core.Qt__ItemSelectionMode, order core.Qt__SortOrder, deviceTransform gui.QTransform_ITF) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList3(i)
			}
			return out
		}(C.QGraphicsScene_Items3(ptr.Pointer(), core.PointerFromQRectF(rect), C.longlong(mode), C.longlong(order), gui.PointerFromQTransform(deviceTransform)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsScene) Items7(x float64, y float64, w float64, h float64, mode core.Qt__ItemSelectionMode, order core.Qt__SortOrder, deviceTransform gui.QTransform_ITF) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList7(i)
			}
			return out
		}(C.QGraphicsScene_Items7(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h), C.longlong(mode), C.longlong(order), gui.PointerFromQTransform(deviceTransform)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsScene) SelectedItems() []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedItems_atList(i)
			}
			return out
		}(C.QGraphicsScene_SelectedItems(ptr.Pointer()))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsScene) Views() []*QGraphicsView {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsView {
			out := make([]*QGraphicsView, int(l.len))
			tmpList := NewQGraphicsSceneFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__views_atList(i)
			}
			return out
		}(C.QGraphicsScene_Views(ptr.Pointer()))
	}
	return make([]*QGraphicsView, 0)
}

func (ptr *QGraphicsScene) SelectionArea() *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsScene_SelectionArea(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) Palette() *gui.QPalette {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPaletteFromPointer(C.QGraphicsScene_Palette(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) ItemsBoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsScene_ItemsBoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) SceneRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsScene_SceneRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) Style() *QStyle {
	if ptr.Pointer() != nil {
		tmpValue := NewQStyleFromPointer(C.QGraphicsScene_Style(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsScene_InputMethodQuery
func callbackQGraphicsScene_InputMethodQuery(ptr unsafe.Pointer, query C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "inputMethodQuery"); signal != nil {
		return core.PointerFromQVariant((*(*func(core.Qt__InputMethodQuery) *core.QVariant)(signal))(core.Qt__InputMethodQuery(query)))
	}

	return core.PointerFromQVariant(NewQGraphicsSceneFromPointer(ptr).InputMethodQueryDefault(core.Qt__InputMethodQuery(query)))
}

func (ptr *QGraphicsScene) ConnectInputMethodQuery(f func(query core.Qt__InputMethodQuery) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "inputMethodQuery"); signal != nil {
			f := func(query core.Qt__InputMethodQuery) *core.QVariant {
				(*(*func(core.Qt__InputMethodQuery) *core.QVariant)(signal))(query)
				return f(query)
			}
			qt.ConnectSignal(ptr.Pointer(), "inputMethodQuery", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "inputMethodQuery", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsScene) DisconnectInputMethodQuery() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "inputMethodQuery")
	}
}

func (ptr *QGraphicsScene) InputMethodQuery(query core.Qt__InputMethodQuery) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QGraphicsScene_InputMethodQuery(ptr.Pointer(), C.longlong(query)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) InputMethodQueryDefault(query core.Qt__InputMethodQuery) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QGraphicsScene_InputMethodQueryDefault(ptr.Pointer(), C.longlong(query)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) FocusOnTouch() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_FocusOnTouch(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsScene) HasFocus() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_HasFocus(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsScene) IsActive() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_IsActive(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsScene) IsSortCacheEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_IsSortCacheEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsScene) StickyFocus() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsScene_StickyFocus(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQGraphicsScene_MetaObject
func callbackQGraphicsScene_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQGraphicsSceneFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QGraphicsScene) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QGraphicsScene_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsScene) BspTreeDepth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsScene_BspTreeDepth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGraphicsScene) Height() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsScene_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsScene) MinimumRenderSize() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsScene_MinimumRenderSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsScene) Width() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsScene_Width(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsScene) __createItemGroup_items_atList(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene___createItemGroup_items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsScene) __createItemGroup_items_setList(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___createItemGroup_items_setList(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsScene) __createItemGroup_items_newList() unsafe.Pointer {
	return C.QGraphicsScene___createItemGroup_items_newList(ptr.Pointer())
}

func (ptr *QGraphicsScene) __changed_region_atList(i int) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsScene___changed_region_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) __changed_region_setList(i core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___changed_region_setList(ptr.Pointer(), core.PointerFromQRectF(i))
	}
}

func (ptr *QGraphicsScene) __changed_region_newList() unsafe.Pointer {
	return C.QGraphicsScene___changed_region_newList(ptr.Pointer())
}

func (ptr *QGraphicsScene) __collidingItems_atList(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene___collidingItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsScene) __collidingItems_setList(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___collidingItems_setList(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsScene) __collidingItems_newList() unsafe.Pointer {
	return C.QGraphicsScene___collidingItems_newList(ptr.Pointer())
}

func (ptr *QGraphicsScene) __items_atList(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene___items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsScene) __items_setList(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___items_setList(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsScene) __items_newList() unsafe.Pointer {
	return C.QGraphicsScene___items_newList(ptr.Pointer())
}

func (ptr *QGraphicsScene) __items_atList5(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene___items_atList5(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsScene) __items_setList5(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___items_setList5(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsScene) __items_newList5() unsafe.Pointer {
	return C.QGraphicsScene___items_newList5(ptr.Pointer())
}

func (ptr *QGraphicsScene) __items_atList2(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene___items_atList2(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsScene) __items_setList2(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___items_setList2(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsScene) __items_newList2() unsafe.Pointer {
	return C.QGraphicsScene___items_newList2(ptr.Pointer())
}

func (ptr *QGraphicsScene) __items_atList4(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene___items_atList4(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsScene) __items_setList4(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___items_setList4(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsScene) __items_newList4() unsafe.Pointer {
	return C.QGraphicsScene___items_newList4(ptr.Pointer())
}

func (ptr *QGraphicsScene) __items_atList3(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene___items_atList3(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsScene) __items_setList3(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___items_setList3(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsScene) __items_newList3() unsafe.Pointer {
	return C.QGraphicsScene___items_newList3(ptr.Pointer())
}

func (ptr *QGraphicsScene) __items_atList7(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene___items_atList7(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsScene) __items_setList7(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___items_setList7(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsScene) __items_newList7() unsafe.Pointer {
	return C.QGraphicsScene___items_newList7(ptr.Pointer())
}

func (ptr *QGraphicsScene) __selectedItems_atList(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsScene___selectedItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsScene) __selectedItems_setList(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___selectedItems_setList(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsScene) __selectedItems_newList() unsafe.Pointer {
	return C.QGraphicsScene___selectedItems_newList(ptr.Pointer())
}

func (ptr *QGraphicsScene) __views_atList(i int) *QGraphicsView {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsViewFromPointer(C.QGraphicsScene___views_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) __views_setList(i QGraphicsView_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___views_setList(ptr.Pointer(), PointerFromQGraphicsView(i))
	}
}

func (ptr *QGraphicsScene) __views_newList() unsafe.Pointer {
	return C.QGraphicsScene___views_newList(ptr.Pointer())
}

func (ptr *QGraphicsScene) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QGraphicsScene___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QGraphicsScene) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QGraphicsScene___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QGraphicsScene) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsScene___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsScene) __findChildren_newList2() unsafe.Pointer {
	return C.QGraphicsScene___findChildren_newList2(ptr.Pointer())
}

func (ptr *QGraphicsScene) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsScene___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsScene) __findChildren_newList3() unsafe.Pointer {
	return C.QGraphicsScene___findChildren_newList3(ptr.Pointer())
}

func (ptr *QGraphicsScene) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsScene___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsScene) __findChildren_newList() unsafe.Pointer {
	return C.QGraphicsScene___findChildren_newList(ptr.Pointer())
}

func (ptr *QGraphicsScene) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsScene___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsScene) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsScene) __children_newList() unsafe.Pointer {
	return C.QGraphicsScene___children_newList(ptr.Pointer())
}

//export callbackQGraphicsScene_ChildEvent
func callbackQGraphicsScene_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQGraphicsSceneFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QGraphicsScene) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQGraphicsScene_ConnectNotify
func callbackQGraphicsScene_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsSceneFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsScene) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsScene_CustomEvent
func callbackQGraphicsScene_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsSceneFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsScene) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsScene_DeleteLater
func callbackQGraphicsScene_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QGraphicsScene) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsScene_Destroyed
func callbackQGraphicsScene_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQGraphicsScene_DisconnectNotify
func callbackQGraphicsScene_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsSceneFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsScene) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsScene_ObjectNameChanged
func callbackQGraphicsScene_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQGraphicsScene_TimerEvent
func callbackQGraphicsScene_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQGraphicsSceneFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QGraphicsScene) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsScene_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QGraphicsSceneContextMenuEvent struct {
	QGraphicsSceneEvent
}

type QGraphicsSceneContextMenuEvent_ITF interface {
	QGraphicsSceneEvent_ITF
	QGraphicsSceneContextMenuEvent_PTR() *QGraphicsSceneContextMenuEvent
}

func (ptr *QGraphicsSceneContextMenuEvent) QGraphicsSceneContextMenuEvent_PTR() *QGraphicsSceneContextMenuEvent {
	return ptr
}

func (ptr *QGraphicsSceneContextMenuEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSceneContextMenuEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsSceneEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSceneContextMenuEvent(ptr QGraphicsSceneContextMenuEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneContextMenuEvent_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneContextMenuEventFromPointer(ptr unsafe.Pointer) (n *QGraphicsSceneContextMenuEvent) {
	n = new(QGraphicsSceneContextMenuEvent)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsSceneContextMenuEvent__Reason
//QGraphicsSceneContextMenuEvent::Reason
type QGraphicsSceneContextMenuEvent__Reason int64

const (
	QGraphicsSceneContextMenuEvent__Mouse    QGraphicsSceneContextMenuEvent__Reason = QGraphicsSceneContextMenuEvent__Reason(0)
	QGraphicsSceneContextMenuEvent__Keyboard QGraphicsSceneContextMenuEvent__Reason = QGraphicsSceneContextMenuEvent__Reason(1)
	QGraphicsSceneContextMenuEvent__Other    QGraphicsSceneContextMenuEvent__Reason = QGraphicsSceneContextMenuEvent__Reason(2)
)

//export callbackQGraphicsSceneContextMenuEvent_DestroyQGraphicsSceneContextMenuEvent
func callbackQGraphicsSceneContextMenuEvent_DestroyQGraphicsSceneContextMenuEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSceneContextMenuEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneContextMenuEventFromPointer(ptr).DestroyQGraphicsSceneContextMenuEventDefault()
	}
}

func (ptr *QGraphicsSceneContextMenuEvent) ConnectDestroyQGraphicsSceneContextMenuEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSceneContextMenuEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneContextMenuEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneContextMenuEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSceneContextMenuEvent) DisconnectDestroyQGraphicsSceneContextMenuEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSceneContextMenuEvent")
	}
}

func (ptr *QGraphicsSceneContextMenuEvent) DestroyQGraphicsSceneContextMenuEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneContextMenuEvent_DestroyQGraphicsSceneContextMenuEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneContextMenuEvent) DestroyQGraphicsSceneContextMenuEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneContextMenuEvent_DestroyQGraphicsSceneContextMenuEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneContextMenuEvent) Reason() QGraphicsSceneContextMenuEvent__Reason {
	if ptr.Pointer() != nil {
		return QGraphicsSceneContextMenuEvent__Reason(C.QGraphicsSceneContextMenuEvent_Reason(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneContextMenuEvent) ScreenPos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsSceneContextMenuEvent_ScreenPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneContextMenuEvent) Pos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneContextMenuEvent_Pos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneContextMenuEvent) ScenePos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneContextMenuEvent_ScenePos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneContextMenuEvent) Modifiers() core.Qt__KeyboardModifier {
	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QGraphicsSceneContextMenuEvent_Modifiers(ptr.Pointer()))
	}
	return 0
}

type QGraphicsSceneDragDropEvent struct {
	QGraphicsSceneEvent
}

type QGraphicsSceneDragDropEvent_ITF interface {
	QGraphicsSceneEvent_ITF
	QGraphicsSceneDragDropEvent_PTR() *QGraphicsSceneDragDropEvent
}

func (ptr *QGraphicsSceneDragDropEvent) QGraphicsSceneDragDropEvent_PTR() *QGraphicsSceneDragDropEvent {
	return ptr
}

func (ptr *QGraphicsSceneDragDropEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSceneDragDropEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsSceneEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSceneDragDropEvent(ptr QGraphicsSceneDragDropEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneDragDropEvent_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneDragDropEventFromPointer(ptr unsafe.Pointer) (n *QGraphicsSceneDragDropEvent) {
	n = new(QGraphicsSceneDragDropEvent)
	n.SetPointer(ptr)
	return
}
func (ptr *QGraphicsSceneDragDropEvent) AcceptProposedAction() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneDragDropEvent_AcceptProposedAction(ptr.Pointer())
	}
}

func (ptr *QGraphicsSceneDragDropEvent) SetDropAction(action core.Qt__DropAction) {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneDragDropEvent_SetDropAction(ptr.Pointer(), C.longlong(action))
	}
}

//export callbackQGraphicsSceneDragDropEvent_DestroyQGraphicsSceneDragDropEvent
func callbackQGraphicsSceneDragDropEvent_DestroyQGraphicsSceneDragDropEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSceneDragDropEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneDragDropEventFromPointer(ptr).DestroyQGraphicsSceneDragDropEventDefault()
	}
}

func (ptr *QGraphicsSceneDragDropEvent) ConnectDestroyQGraphicsSceneDragDropEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSceneDragDropEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneDragDropEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneDragDropEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSceneDragDropEvent) DisconnectDestroyQGraphicsSceneDragDropEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSceneDragDropEvent")
	}
}

func (ptr *QGraphicsSceneDragDropEvent) DestroyQGraphicsSceneDragDropEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneDragDropEvent_DestroyQGraphicsSceneDragDropEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneDragDropEvent) DestroyQGraphicsSceneDragDropEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneDragDropEvent_DestroyQGraphicsSceneDragDropEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneDragDropEvent) ScreenPos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsSceneDragDropEvent_ScreenPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneDragDropEvent) Pos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneDragDropEvent_Pos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneDragDropEvent) ScenePos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneDragDropEvent_ScenePos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneDragDropEvent) Source() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QGraphicsSceneDragDropEvent_Source(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneDragDropEvent) DropAction() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QGraphicsSceneDragDropEvent_DropAction(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneDragDropEvent) ProposedAction() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QGraphicsSceneDragDropEvent_ProposedAction(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneDragDropEvent) PossibleActions() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QGraphicsSceneDragDropEvent_PossibleActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneDragDropEvent) Modifiers() core.Qt__KeyboardModifier {
	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QGraphicsSceneDragDropEvent_Modifiers(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneDragDropEvent) Buttons() core.Qt__MouseButton {
	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QGraphicsSceneDragDropEvent_Buttons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneDragDropEvent) MimeData() *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QGraphicsSceneDragDropEvent_MimeData(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

type QGraphicsSceneEvent struct {
	core.QEvent
}

type QGraphicsSceneEvent_ITF interface {
	core.QEvent_ITF
	QGraphicsSceneEvent_PTR() *QGraphicsSceneEvent
}

func (ptr *QGraphicsSceneEvent) QGraphicsSceneEvent_PTR() *QGraphicsSceneEvent {
	return ptr
}

func (ptr *QGraphicsSceneEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSceneEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSceneEvent(ptr QGraphicsSceneEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneEvent_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneEventFromPointer(ptr unsafe.Pointer) (n *QGraphicsSceneEvent) {
	n = new(QGraphicsSceneEvent)
	n.SetPointer(ptr)
	return
}

//export callbackQGraphicsSceneEvent_DestroyQGraphicsSceneEvent
func callbackQGraphicsSceneEvent_DestroyQGraphicsSceneEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSceneEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneEventFromPointer(ptr).DestroyQGraphicsSceneEventDefault()
	}
}

func (ptr *QGraphicsSceneEvent) ConnectDestroyQGraphicsSceneEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSceneEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSceneEvent) DisconnectDestroyQGraphicsSceneEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSceneEvent")
	}
}

func (ptr *QGraphicsSceneEvent) DestroyQGraphicsSceneEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneEvent_DestroyQGraphicsSceneEvent(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QGraphicsSceneEvent) DestroyQGraphicsSceneEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneEvent_DestroyQGraphicsSceneEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QGraphicsSceneEvent) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QGraphicsSceneEvent_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

type QGraphicsSceneHelpEvent struct {
	QGraphicsSceneEvent
}

type QGraphicsSceneHelpEvent_ITF interface {
	QGraphicsSceneEvent_ITF
	QGraphicsSceneHelpEvent_PTR() *QGraphicsSceneHelpEvent
}

func (ptr *QGraphicsSceneHelpEvent) QGraphicsSceneHelpEvent_PTR() *QGraphicsSceneHelpEvent {
	return ptr
}

func (ptr *QGraphicsSceneHelpEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSceneHelpEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsSceneEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSceneHelpEvent(ptr QGraphicsSceneHelpEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneHelpEvent_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneHelpEventFromPointer(ptr unsafe.Pointer) (n *QGraphicsSceneHelpEvent) {
	n = new(QGraphicsSceneHelpEvent)
	n.SetPointer(ptr)
	return
}

//export callbackQGraphicsSceneHelpEvent_DestroyQGraphicsSceneHelpEvent
func callbackQGraphicsSceneHelpEvent_DestroyQGraphicsSceneHelpEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSceneHelpEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneHelpEventFromPointer(ptr).DestroyQGraphicsSceneHelpEventDefault()
	}
}

func (ptr *QGraphicsSceneHelpEvent) ConnectDestroyQGraphicsSceneHelpEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSceneHelpEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneHelpEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneHelpEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSceneHelpEvent) DisconnectDestroyQGraphicsSceneHelpEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSceneHelpEvent")
	}
}

func (ptr *QGraphicsSceneHelpEvent) DestroyQGraphicsSceneHelpEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneHelpEvent_DestroyQGraphicsSceneHelpEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneHelpEvent) DestroyQGraphicsSceneHelpEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneHelpEvent_DestroyQGraphicsSceneHelpEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneHelpEvent) ScreenPos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsSceneHelpEvent_ScreenPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneHelpEvent) ScenePos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneHelpEvent_ScenePos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

type QGraphicsSceneHoverEvent struct {
	QGraphicsSceneEvent
}

type QGraphicsSceneHoverEvent_ITF interface {
	QGraphicsSceneEvent_ITF
	QGraphicsSceneHoverEvent_PTR() *QGraphicsSceneHoverEvent
}

func (ptr *QGraphicsSceneHoverEvent) QGraphicsSceneHoverEvent_PTR() *QGraphicsSceneHoverEvent {
	return ptr
}

func (ptr *QGraphicsSceneHoverEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSceneHoverEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsSceneEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSceneHoverEvent(ptr QGraphicsSceneHoverEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneHoverEvent_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneHoverEventFromPointer(ptr unsafe.Pointer) (n *QGraphicsSceneHoverEvent) {
	n = new(QGraphicsSceneHoverEvent)
	n.SetPointer(ptr)
	return
}

//export callbackQGraphicsSceneHoverEvent_DestroyQGraphicsSceneHoverEvent
func callbackQGraphicsSceneHoverEvent_DestroyQGraphicsSceneHoverEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSceneHoverEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneHoverEventFromPointer(ptr).DestroyQGraphicsSceneHoverEventDefault()
	}
}

func (ptr *QGraphicsSceneHoverEvent) ConnectDestroyQGraphicsSceneHoverEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSceneHoverEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneHoverEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneHoverEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSceneHoverEvent) DisconnectDestroyQGraphicsSceneHoverEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSceneHoverEvent")
	}
}

func (ptr *QGraphicsSceneHoverEvent) DestroyQGraphicsSceneHoverEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneHoverEvent_DestroyQGraphicsSceneHoverEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneHoverEvent) DestroyQGraphicsSceneHoverEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneHoverEvent_DestroyQGraphicsSceneHoverEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneHoverEvent) LastScreenPos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsSceneHoverEvent_LastScreenPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneHoverEvent) ScreenPos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsSceneHoverEvent_ScreenPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneHoverEvent) LastPos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneHoverEvent_LastPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneHoverEvent) LastScenePos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneHoverEvent_LastScenePos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneHoverEvent) Pos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneHoverEvent_Pos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneHoverEvent) ScenePos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneHoverEvent_ScenePos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneHoverEvent) Modifiers() core.Qt__KeyboardModifier {
	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QGraphicsSceneHoverEvent_Modifiers(ptr.Pointer()))
	}
	return 0
}

type QGraphicsSceneMouseEvent struct {
	QGraphicsSceneEvent
}

type QGraphicsSceneMouseEvent_ITF interface {
	QGraphicsSceneEvent_ITF
	QGraphicsSceneMouseEvent_PTR() *QGraphicsSceneMouseEvent
}

func (ptr *QGraphicsSceneMouseEvent) QGraphicsSceneMouseEvent_PTR() *QGraphicsSceneMouseEvent {
	return ptr
}

func (ptr *QGraphicsSceneMouseEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsSceneEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSceneMouseEvent(ptr QGraphicsSceneMouseEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneMouseEvent_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneMouseEventFromPointer(ptr unsafe.Pointer) (n *QGraphicsSceneMouseEvent) {
	n = new(QGraphicsSceneMouseEvent)
	n.SetPointer(ptr)
	return
}

//export callbackQGraphicsSceneMouseEvent_DestroyQGraphicsSceneMouseEvent
func callbackQGraphicsSceneMouseEvent_DestroyQGraphicsSceneMouseEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSceneMouseEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneMouseEventFromPointer(ptr).DestroyQGraphicsSceneMouseEventDefault()
	}
}

func (ptr *QGraphicsSceneMouseEvent) ConnectDestroyQGraphicsSceneMouseEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSceneMouseEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneMouseEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneMouseEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSceneMouseEvent) DisconnectDestroyQGraphicsSceneMouseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSceneMouseEvent")
	}
}

func (ptr *QGraphicsSceneMouseEvent) DestroyQGraphicsSceneMouseEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneMouseEvent_DestroyQGraphicsSceneMouseEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneMouseEvent) DestroyQGraphicsSceneMouseEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneMouseEvent_DestroyQGraphicsSceneMouseEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneMouseEvent) ButtonDownScreenPos(button core.Qt__MouseButton) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsSceneMouseEvent_ButtonDownScreenPos(ptr.Pointer(), C.longlong(button)))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) LastScreenPos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsSceneMouseEvent_LastScreenPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) ScreenPos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsSceneMouseEvent_ScreenPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) ButtonDownPos(button core.Qt__MouseButton) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneMouseEvent_ButtonDownPos(ptr.Pointer(), C.longlong(button)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) ButtonDownScenePos(button core.Qt__MouseButton) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneMouseEvent_ButtonDownScenePos(ptr.Pointer(), C.longlong(button)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) LastPos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneMouseEvent_LastPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) LastScenePos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneMouseEvent_LastScenePos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) Pos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneMouseEvent_Pos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) ScenePos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneMouseEvent_ScenePos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMouseEvent) Modifiers() core.Qt__KeyboardModifier {
	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QGraphicsSceneMouseEvent_Modifiers(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneMouseEvent) Button() core.Qt__MouseButton {
	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QGraphicsSceneMouseEvent_Button(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneMouseEvent) Buttons() core.Qt__MouseButton {
	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QGraphicsSceneMouseEvent_Buttons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneMouseEvent) Flags() core.Qt__MouseEventFlag {
	if ptr.Pointer() != nil {
		return core.Qt__MouseEventFlag(C.QGraphicsSceneMouseEvent_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneMouseEvent) Source() core.Qt__MouseEventSource {
	if ptr.Pointer() != nil {
		return core.Qt__MouseEventSource(C.QGraphicsSceneMouseEvent_Source(ptr.Pointer()))
	}
	return 0
}

type QGraphicsSceneMoveEvent struct {
	QGraphicsSceneEvent
}

type QGraphicsSceneMoveEvent_ITF interface {
	QGraphicsSceneEvent_ITF
	QGraphicsSceneMoveEvent_PTR() *QGraphicsSceneMoveEvent
}

func (ptr *QGraphicsSceneMoveEvent) QGraphicsSceneMoveEvent_PTR() *QGraphicsSceneMoveEvent {
	return ptr
}

func (ptr *QGraphicsSceneMoveEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSceneMoveEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsSceneEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSceneMoveEvent(ptr QGraphicsSceneMoveEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneMoveEvent_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneMoveEventFromPointer(ptr unsafe.Pointer) (n *QGraphicsSceneMoveEvent) {
	n = new(QGraphicsSceneMoveEvent)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsSceneMoveEvent() *QGraphicsSceneMoveEvent {
	tmpValue := NewQGraphicsSceneMoveEventFromPointer(C.QGraphicsSceneMoveEvent_NewQGraphicsSceneMoveEvent())
	runtime.SetFinalizer(tmpValue, (*QGraphicsSceneMoveEvent).DestroyQGraphicsSceneMoveEvent)
	return tmpValue
}

//export callbackQGraphicsSceneMoveEvent_DestroyQGraphicsSceneMoveEvent
func callbackQGraphicsSceneMoveEvent_DestroyQGraphicsSceneMoveEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSceneMoveEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneMoveEventFromPointer(ptr).DestroyQGraphicsSceneMoveEventDefault()
	}
}

func (ptr *QGraphicsSceneMoveEvent) ConnectDestroyQGraphicsSceneMoveEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSceneMoveEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneMoveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneMoveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSceneMoveEvent) DisconnectDestroyQGraphicsSceneMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSceneMoveEvent")
	}
}

func (ptr *QGraphicsSceneMoveEvent) DestroyQGraphicsSceneMoveEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneMoveEvent_DestroyQGraphicsSceneMoveEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneMoveEvent) DestroyQGraphicsSceneMoveEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneMoveEvent_DestroyQGraphicsSceneMoveEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneMoveEvent) NewPos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneMoveEvent_NewPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneMoveEvent) OldPos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneMoveEvent_OldPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

type QGraphicsSceneResizeEvent struct {
	QGraphicsSceneEvent
}

type QGraphicsSceneResizeEvent_ITF interface {
	QGraphicsSceneEvent_ITF
	QGraphicsSceneResizeEvent_PTR() *QGraphicsSceneResizeEvent
}

func (ptr *QGraphicsSceneResizeEvent) QGraphicsSceneResizeEvent_PTR() *QGraphicsSceneResizeEvent {
	return ptr
}

func (ptr *QGraphicsSceneResizeEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSceneResizeEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsSceneEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSceneResizeEvent(ptr QGraphicsSceneResizeEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneResizeEvent_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneResizeEventFromPointer(ptr unsafe.Pointer) (n *QGraphicsSceneResizeEvent) {
	n = new(QGraphicsSceneResizeEvent)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsSceneResizeEvent() *QGraphicsSceneResizeEvent {
	tmpValue := NewQGraphicsSceneResizeEventFromPointer(C.QGraphicsSceneResizeEvent_NewQGraphicsSceneResizeEvent())
	runtime.SetFinalizer(tmpValue, (*QGraphicsSceneResizeEvent).DestroyQGraphicsSceneResizeEvent)
	return tmpValue
}

//export callbackQGraphicsSceneResizeEvent_DestroyQGraphicsSceneResizeEvent
func callbackQGraphicsSceneResizeEvent_DestroyQGraphicsSceneResizeEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSceneResizeEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneResizeEventFromPointer(ptr).DestroyQGraphicsSceneResizeEventDefault()
	}
}

func (ptr *QGraphicsSceneResizeEvent) ConnectDestroyQGraphicsSceneResizeEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSceneResizeEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneResizeEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneResizeEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSceneResizeEvent) DisconnectDestroyQGraphicsSceneResizeEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSceneResizeEvent")
	}
}

func (ptr *QGraphicsSceneResizeEvent) DestroyQGraphicsSceneResizeEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneResizeEvent_DestroyQGraphicsSceneResizeEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneResizeEvent) DestroyQGraphicsSceneResizeEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneResizeEvent_DestroyQGraphicsSceneResizeEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneResizeEvent) NewSize() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsSceneResizeEvent_NewSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneResizeEvent) OldSize() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsSceneResizeEvent_OldSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

type QGraphicsSceneWheelEvent struct {
	QGraphicsSceneEvent
}

type QGraphicsSceneWheelEvent_ITF interface {
	QGraphicsSceneEvent_ITF
	QGraphicsSceneWheelEvent_PTR() *QGraphicsSceneWheelEvent
}

func (ptr *QGraphicsSceneWheelEvent) QGraphicsSceneWheelEvent_PTR() *QGraphicsSceneWheelEvent {
	return ptr
}

func (ptr *QGraphicsSceneWheelEvent) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneEvent_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSceneWheelEvent) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsSceneEvent_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSceneWheelEvent(ptr QGraphicsSceneWheelEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSceneWheelEvent_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSceneWheelEventFromPointer(ptr unsafe.Pointer) (n *QGraphicsSceneWheelEvent) {
	n = new(QGraphicsSceneWheelEvent)
	n.SetPointer(ptr)
	return
}

//export callbackQGraphicsSceneWheelEvent_DestroyQGraphicsSceneWheelEvent
func callbackQGraphicsSceneWheelEvent_DestroyQGraphicsSceneWheelEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSceneWheelEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSceneWheelEventFromPointer(ptr).DestroyQGraphicsSceneWheelEventDefault()
	}
}

func (ptr *QGraphicsSceneWheelEvent) ConnectDestroyQGraphicsSceneWheelEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSceneWheelEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneWheelEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSceneWheelEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSceneWheelEvent) DisconnectDestroyQGraphicsSceneWheelEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSceneWheelEvent")
	}
}

func (ptr *QGraphicsSceneWheelEvent) DestroyQGraphicsSceneWheelEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneWheelEvent_DestroyQGraphicsSceneWheelEvent(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneWheelEvent) DestroyQGraphicsSceneWheelEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSceneWheelEvent_DestroyQGraphicsSceneWheelEventDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSceneWheelEvent) ScreenPos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsSceneWheelEvent_ScreenPos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneWheelEvent) Pos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneWheelEvent_Pos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneWheelEvent) ScenePos() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsSceneWheelEvent_ScenePos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSceneWheelEvent) Modifiers() core.Qt__KeyboardModifier {
	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QGraphicsSceneWheelEvent_Modifiers(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneWheelEvent) Buttons() core.Qt__MouseButton {
	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QGraphicsSceneWheelEvent_Buttons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneWheelEvent) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QGraphicsSceneWheelEvent_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsSceneWheelEvent) Delta() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsSceneWheelEvent_Delta(ptr.Pointer())))
	}
	return 0
}

type QGraphicsSimpleTextItem struct {
	QAbstractGraphicsShapeItem
}

type QGraphicsSimpleTextItem_ITF interface {
	QAbstractGraphicsShapeItem_ITF
	QGraphicsSimpleTextItem_PTR() *QGraphicsSimpleTextItem
}

func (ptr *QGraphicsSimpleTextItem) QGraphicsSimpleTextItem_PTR() *QGraphicsSimpleTextItem {
	return ptr
}

func (ptr *QGraphicsSimpleTextItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractGraphicsShapeItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsSimpleTextItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractGraphicsShapeItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsSimpleTextItem(ptr QGraphicsSimpleTextItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsSimpleTextItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsSimpleTextItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsSimpleTextItem) {
	n = new(QGraphicsSimpleTextItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsSimpleTextItem__anonymous
//QGraphicsSimpleTextItem::anonymous
type QGraphicsSimpleTextItem__anonymous int64

const (
	QGraphicsSimpleTextItem__Type QGraphicsSimpleTextItem__anonymous = QGraphicsSimpleTextItem__anonymous(9)
)

func NewQGraphicsSimpleTextItem(parent QGraphicsItem_ITF) *QGraphicsSimpleTextItem {
	return NewQGraphicsSimpleTextItemFromPointer(C.QGraphicsSimpleTextItem_NewQGraphicsSimpleTextItem(PointerFromQGraphicsItem(parent)))
}

func NewQGraphicsSimpleTextItem2(text string, parent QGraphicsItem_ITF) *QGraphicsSimpleTextItem {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return NewQGraphicsSimpleTextItemFromPointer(C.QGraphicsSimpleTextItem_NewQGraphicsSimpleTextItem2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQGraphicsItem(parent)))
}

//export callbackQGraphicsSimpleTextItem_Paint
func callbackQGraphicsSimpleTextItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsSimpleTextItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsSimpleTextItem) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSimpleTextItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsSimpleTextItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsSimpleTextItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsSimpleTextItem) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsSimpleTextItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsSimpleTextItem) SetFont(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsSimpleTextItem_SetFont(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

func (ptr *QGraphicsSimpleTextItem) SetText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QGraphicsSimpleTextItem_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQGraphicsSimpleTextItem_DestroyQGraphicsSimpleTextItem
func callbackQGraphicsSimpleTextItem_DestroyQGraphicsSimpleTextItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsSimpleTextItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsSimpleTextItemFromPointer(ptr).DestroyQGraphicsSimpleTextItemDefault()
	}
}

func (ptr *QGraphicsSimpleTextItem) ConnectDestroyQGraphicsSimpleTextItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsSimpleTextItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSimpleTextItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsSimpleTextItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSimpleTextItem) DisconnectDestroyQGraphicsSimpleTextItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsSimpleTextItem")
	}
}

func (ptr *QGraphicsSimpleTextItem) DestroyQGraphicsSimpleTextItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsSimpleTextItem_DestroyQGraphicsSimpleTextItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSimpleTextItem) DestroyQGraphicsSimpleTextItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsSimpleTextItem_DestroyQGraphicsSimpleTextItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsSimpleTextItem) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QGraphicsSimpleTextItem_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsSimpleTextItem_BoundingRect
func callbackQGraphicsSimpleTextItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsSimpleTextItemFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsSimpleTextItem) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsSimpleTextItem) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsSimpleTextItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsSimpleTextItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSimpleTextItem) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsSimpleTextItem_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsSimpleTextItem) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QGraphicsSimpleTextItem_Text(ptr.Pointer()))
	}
	return ""
}

type QGraphicsTextItem struct {
	QGraphicsObject
}

type QGraphicsTextItem_ITF interface {
	QGraphicsObject_ITF
	QGraphicsTextItem_PTR() *QGraphicsTextItem
}

func (ptr *QGraphicsTextItem) QGraphicsTextItem_PTR() *QGraphicsTextItem {
	return ptr
}

func (ptr *QGraphicsTextItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsTextItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsObject_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsTextItem(ptr QGraphicsTextItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsTextItem_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsTextItemFromPointer(ptr unsafe.Pointer) (n *QGraphicsTextItem) {
	n = new(QGraphicsTextItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsTextItem__anonymous
//QGraphicsTextItem::anonymous
type QGraphicsTextItem__anonymous int64

const (
	QGraphicsTextItem__Type QGraphicsTextItem__anonymous = QGraphicsTextItem__anonymous(8)
)

func NewQGraphicsTextItem(parent QGraphicsItem_ITF) *QGraphicsTextItem {
	tmpValue := NewQGraphicsTextItemFromPointer(C.QGraphicsTextItem_NewQGraphicsTextItem(PointerFromQGraphicsItem(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQGraphicsTextItem2(text string, parent QGraphicsItem_ITF) *QGraphicsTextItem {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQGraphicsTextItemFromPointer(C.QGraphicsTextItem_NewQGraphicsTextItem2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQGraphicsItem(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QGraphicsTextItem) AdjustSize() {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_AdjustSize(ptr.Pointer())
	}
}

//export callbackQGraphicsTextItem_LinkActivated
func callbackQGraphicsTextItem_LinkActivated(ptr unsafe.Pointer, link C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "linkActivated"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(link))
	}

}

func (ptr *QGraphicsTextItem) ConnectLinkActivated(f func(link string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "linkActivated") {
			C.QGraphicsTextItem_ConnectLinkActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "linkActivated"); signal != nil {
			f := func(link string) {
				(*(*func(string))(signal))(link)
				f(link)
			}
			qt.ConnectSignal(ptr.Pointer(), "linkActivated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "linkActivated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsTextItem) DisconnectLinkActivated() {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_DisconnectLinkActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "linkActivated")
	}
}

func (ptr *QGraphicsTextItem) LinkActivated(link string) {
	if ptr.Pointer() != nil {
		var linkC *C.char
		if link != "" {
			linkC = C.CString(link)
			defer C.free(unsafe.Pointer(linkC))
		}
		C.QGraphicsTextItem_LinkActivated(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: linkC, len: C.longlong(len(link))})
	}
}

//export callbackQGraphicsTextItem_LinkHovered
func callbackQGraphicsTextItem_LinkHovered(ptr unsafe.Pointer, link C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "linkHovered"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(link))
	}

}

func (ptr *QGraphicsTextItem) ConnectLinkHovered(f func(link string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "linkHovered") {
			C.QGraphicsTextItem_ConnectLinkHovered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "linkHovered"); signal != nil {
			f := func(link string) {
				(*(*func(string))(signal))(link)
				f(link)
			}
			qt.ConnectSignal(ptr.Pointer(), "linkHovered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "linkHovered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsTextItem) DisconnectLinkHovered() {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_DisconnectLinkHovered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "linkHovered")
	}
}

func (ptr *QGraphicsTextItem) LinkHovered(link string) {
	if ptr.Pointer() != nil {
		var linkC *C.char
		if link != "" {
			linkC = C.CString(link)
			defer C.free(unsafe.Pointer(linkC))
		}
		C.QGraphicsTextItem_LinkHovered(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: linkC, len: C.longlong(len(link))})
	}
}

//export callbackQGraphicsTextItem_Paint
func callbackQGraphicsTextItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsTextItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsTextItem) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsTextItem) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsTextItem) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsTextItem) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsTextItem) SetDefaultTextColor(col gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_SetDefaultTextColor(ptr.Pointer(), gui.PointerFromQColor(col))
	}
}

func (ptr *QGraphicsTextItem) SetDocument(document gui.QTextDocument_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_SetDocument(ptr.Pointer(), gui.PointerFromQTextDocument(document))
	}
}

func (ptr *QGraphicsTextItem) SetFont(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_SetFont(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

func (ptr *QGraphicsTextItem) SetHtml(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QGraphicsTextItem_SetHtml(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QGraphicsTextItem) SetOpenExternalLinks(open bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_SetOpenExternalLinks(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(open))))
	}
}

func (ptr *QGraphicsTextItem) SetPlainText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QGraphicsTextItem_SetPlainText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QGraphicsTextItem) SetTabChangesFocus(b bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_SetTabChangesFocus(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QGraphicsTextItem) SetTextCursor(cursor gui.QTextCursor_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_SetTextCursor(ptr.Pointer(), gui.PointerFromQTextCursor(cursor))
	}
}

func (ptr *QGraphicsTextItem) SetTextInteractionFlags(flags core.Qt__TextInteractionFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_SetTextInteractionFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QGraphicsTextItem) SetTextWidth(width float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_SetTextWidth(ptr.Pointer(), C.double(width))
	}
}

//export callbackQGraphicsTextItem_DestroyQGraphicsTextItem
func callbackQGraphicsTextItem_DestroyQGraphicsTextItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsTextItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsTextItemFromPointer(ptr).DestroyQGraphicsTextItemDefault()
	}
}

func (ptr *QGraphicsTextItem) ConnectDestroyQGraphicsTextItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsTextItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsTextItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsTextItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsTextItem) DisconnectDestroyQGraphicsTextItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsTextItem")
	}
}

func (ptr *QGraphicsTextItem) DestroyQGraphicsTextItem() {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_DestroyQGraphicsTextItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsTextItem) DestroyQGraphicsTextItemDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsTextItem_DestroyQGraphicsTextItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsTextItem) DefaultTextColor() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QGraphicsTextItem_DefaultTextColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTextItem) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QGraphicsTextItem_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsTextItem_BoundingRect
func callbackQGraphicsTextItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsTextItemFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsTextItem) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsTextItem) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsTextItem) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsTextItem_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTextItem) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsTextItem_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTextItem) ToHtml() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QGraphicsTextItem_ToHtml(ptr.Pointer()))
	}
	return ""
}

func (ptr *QGraphicsTextItem) ToPlainText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QGraphicsTextItem_ToPlainText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QGraphicsTextItem) TextCursor() *gui.QTextCursor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCursorFromPointer(C.QGraphicsTextItem_TextCursor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCursor).DestroyQTextCursor)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTextItem) Document() *gui.QTextDocument {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextDocumentFromPointer(C.QGraphicsTextItem_Document(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTextItem) TextInteractionFlags() core.Qt__TextInteractionFlag {
	if ptr.Pointer() != nil {
		return core.Qt__TextInteractionFlag(C.QGraphicsTextItem_TextInteractionFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsTextItem) OpenExternalLinks() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsTextItem_OpenExternalLinks(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsTextItem) TabChangesFocus() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsTextItem_TabChangesFocus(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsTextItem) TextWidth() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QGraphicsTextItem_TextWidth(ptr.Pointer()))
	}
	return 0
}

type QGraphicsTransform struct {
	core.QObject
}

type QGraphicsTransform_ITF interface {
	core.QObject_ITF
	QGraphicsTransform_PTR() *QGraphicsTransform
}

func (ptr *QGraphicsTransform) QGraphicsTransform_PTR() *QGraphicsTransform {
	return ptr
}

func (ptr *QGraphicsTransform) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsTransform) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsTransform(ptr QGraphicsTransform_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsTransform_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsTransformFromPointer(ptr unsafe.Pointer) (n *QGraphicsTransform) {
	n = new(QGraphicsTransform)
	n.SetPointer(ptr)
	return
}
func NewQGraphicsTransform(parent core.QObject_ITF) *QGraphicsTransform {
	tmpValue := NewQGraphicsTransformFromPointer(C.QGraphicsTransform_NewQGraphicsTransform(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QGraphicsTransform_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsTransform_QGraphicsTransform_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QGraphicsTransform) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QGraphicsTransform_QGraphicsTransform_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQGraphicsTransform_Update
func callbackQGraphicsTransform_Update(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "update"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsTransformFromPointer(ptr).UpdateDefault()
	}
}

func (ptr *QGraphicsTransform) ConnectUpdate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "update"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "update", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "update", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsTransform) DisconnectUpdate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "update")
	}
}

func (ptr *QGraphicsTransform) Update() {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_Update(ptr.Pointer())
	}
}

func (ptr *QGraphicsTransform) UpdateDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_UpdateDefault(ptr.Pointer())
	}
}

//export callbackQGraphicsTransform_DestroyQGraphicsTransform
func callbackQGraphicsTransform_DestroyQGraphicsTransform(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsTransform"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsTransformFromPointer(ptr).DestroyQGraphicsTransformDefault()
	}
}

func (ptr *QGraphicsTransform) ConnectDestroyQGraphicsTransform(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsTransform"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsTransform", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsTransform", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsTransform) DisconnectDestroyQGraphicsTransform() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsTransform")
	}
}

func (ptr *QGraphicsTransform) DestroyQGraphicsTransform() {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_DestroyQGraphicsTransform(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsTransform) DestroyQGraphicsTransformDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_DestroyQGraphicsTransformDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsTransform_MetaObject
func callbackQGraphicsTransform_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQGraphicsTransformFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QGraphicsTransform) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QGraphicsTransform_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQGraphicsTransform_ApplyTo
func callbackQGraphicsTransform_ApplyTo(ptr unsafe.Pointer, matrix unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "applyTo"); signal != nil {
		(*(*func(*gui.QMatrix4x4))(signal))(gui.NewQMatrix4x4FromPointer(matrix))
	}

}

func (ptr *QGraphicsTransform) ConnectApplyTo(f func(matrix *gui.QMatrix4x4)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "applyTo"); signal != nil {
			f := func(matrix *gui.QMatrix4x4) {
				(*(*func(*gui.QMatrix4x4))(signal))(matrix)
				f(matrix)
			}
			qt.ConnectSignal(ptr.Pointer(), "applyTo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "applyTo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsTransform) DisconnectApplyTo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "applyTo")
	}
}

func (ptr *QGraphicsTransform) ApplyTo(matrix gui.QMatrix4x4_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_ApplyTo(ptr.Pointer(), gui.PointerFromQMatrix4x4(matrix))
	}
}

func (ptr *QGraphicsTransform) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QGraphicsTransform___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTransform) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QGraphicsTransform) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QGraphicsTransform___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QGraphicsTransform) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsTransform___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTransform) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsTransform) __findChildren_newList2() unsafe.Pointer {
	return C.QGraphicsTransform___findChildren_newList2(ptr.Pointer())
}

func (ptr *QGraphicsTransform) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsTransform___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTransform) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsTransform) __findChildren_newList3() unsafe.Pointer {
	return C.QGraphicsTransform___findChildren_newList3(ptr.Pointer())
}

func (ptr *QGraphicsTransform) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsTransform___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTransform) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsTransform) __findChildren_newList() unsafe.Pointer {
	return C.QGraphicsTransform___findChildren_newList(ptr.Pointer())
}

func (ptr *QGraphicsTransform) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QGraphicsTransform___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsTransform) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QGraphicsTransform) __children_newList() unsafe.Pointer {
	return C.QGraphicsTransform___children_newList(ptr.Pointer())
}

//export callbackQGraphicsTransform_Event
func callbackQGraphicsTransform_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsTransformFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QGraphicsTransform) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsTransform_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQGraphicsTransform_EventFilter
func callbackQGraphicsTransform_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsTransformFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsTransform) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsTransform_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQGraphicsTransform_ChildEvent
func callbackQGraphicsTransform_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQGraphicsTransformFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QGraphicsTransform) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQGraphicsTransform_ConnectNotify
func callbackQGraphicsTransform_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsTransformFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsTransform) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsTransform_CustomEvent
func callbackQGraphicsTransform_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsTransformFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsTransform) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsTransform_DeleteLater
func callbackQGraphicsTransform_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsTransformFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QGraphicsTransform) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGraphicsTransform_Destroyed
func callbackQGraphicsTransform_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQGraphicsTransform_DisconnectNotify
func callbackQGraphicsTransform_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQGraphicsTransformFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QGraphicsTransform) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQGraphicsTransform_ObjectNameChanged
func callbackQGraphicsTransform_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQGraphicsTransform_TimerEvent
func callbackQGraphicsTransform_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQGraphicsTransformFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QGraphicsTransform) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsTransform_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QGraphicsView struct {
	QAbstractScrollArea
}

type QGraphicsView_ITF interface {
	QAbstractScrollArea_ITF
	QGraphicsView_PTR() *QGraphicsView
}

func (ptr *QGraphicsView) QGraphicsView_PTR() *QGraphicsView {
	return ptr
}

func (ptr *QGraphicsView) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractScrollArea_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsView) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractScrollArea_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsView(ptr QGraphicsView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsView_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsViewFromPointer(ptr unsafe.Pointer) (n *QGraphicsView) {
	n = new(QGraphicsView)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsView__CacheModeFlag
//QGraphicsView::CacheModeFlag
type QGraphicsView__CacheModeFlag int64

const (
	QGraphicsView__CacheNone       QGraphicsView__CacheModeFlag = QGraphicsView__CacheModeFlag(0x0)
	QGraphicsView__CacheBackground QGraphicsView__CacheModeFlag = QGraphicsView__CacheModeFlag(0x1)
)

//go:generate stringer -type=QGraphicsView__DragMode
//QGraphicsView::DragMode
type QGraphicsView__DragMode int64

const (
	QGraphicsView__NoDrag         QGraphicsView__DragMode = QGraphicsView__DragMode(0)
	QGraphicsView__ScrollHandDrag QGraphicsView__DragMode = QGraphicsView__DragMode(1)
	QGraphicsView__RubberBandDrag QGraphicsView__DragMode = QGraphicsView__DragMode(2)
)

//go:generate stringer -type=QGraphicsView__OptimizationFlag
//QGraphicsView::OptimizationFlag
type QGraphicsView__OptimizationFlag int64

const (
	QGraphicsView__DontClipPainter           QGraphicsView__OptimizationFlag = QGraphicsView__OptimizationFlag(0x1)
	QGraphicsView__DontSavePainterState      QGraphicsView__OptimizationFlag = QGraphicsView__OptimizationFlag(0x2)
	QGraphicsView__DontAdjustForAntialiasing QGraphicsView__OptimizationFlag = QGraphicsView__OptimizationFlag(0x4)
	QGraphicsView__IndirectPainting          QGraphicsView__OptimizationFlag = QGraphicsView__OptimizationFlag(0x8)
)

//go:generate stringer -type=QGraphicsView__ViewportAnchor
//QGraphicsView::ViewportAnchor
type QGraphicsView__ViewportAnchor int64

const (
	QGraphicsView__NoAnchor         QGraphicsView__ViewportAnchor = QGraphicsView__ViewportAnchor(0)
	QGraphicsView__AnchorViewCenter QGraphicsView__ViewportAnchor = QGraphicsView__ViewportAnchor(1)
	QGraphicsView__AnchorUnderMouse QGraphicsView__ViewportAnchor = QGraphicsView__ViewportAnchor(2)
)

//go:generate stringer -type=QGraphicsView__ViewportUpdateMode
//QGraphicsView::ViewportUpdateMode
type QGraphicsView__ViewportUpdateMode int64

const (
	QGraphicsView__FullViewportUpdate         QGraphicsView__ViewportUpdateMode = QGraphicsView__ViewportUpdateMode(0)
	QGraphicsView__MinimalViewportUpdate      QGraphicsView__ViewportUpdateMode = QGraphicsView__ViewportUpdateMode(1)
	QGraphicsView__SmartViewportUpdate        QGraphicsView__ViewportUpdateMode = QGraphicsView__ViewportUpdateMode(2)
	QGraphicsView__NoViewportUpdate           QGraphicsView__ViewportUpdateMode = QGraphicsView__ViewportUpdateMode(3)
	QGraphicsView__BoundingRectViewportUpdate QGraphicsView__ViewportUpdateMode = QGraphicsView__ViewportUpdateMode(4)
)

func NewQGraphicsView2(scene QGraphicsScene_ITF, parent QWidget_ITF) *QGraphicsView {
	tmpValue := NewQGraphicsViewFromPointer(C.QGraphicsView_NewQGraphicsView2(PointerFromQGraphicsScene(scene), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQGraphicsView(parent QWidget_ITF) *QGraphicsView {
	tmpValue := NewQGraphicsViewFromPointer(C.QGraphicsView_NewQGraphicsView(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QGraphicsView) CenterOn3(item QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_CenterOn3(ptr.Pointer(), PointerFromQGraphicsItem(item))
	}
}

func (ptr *QGraphicsView) CenterOn(pos core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_CenterOn(ptr.Pointer(), core.PointerFromQPointF(pos))
	}
}

func (ptr *QGraphicsView) CenterOn2(x float64, y float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_CenterOn2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

//export callbackQGraphicsView_DrawBackground
func callbackQGraphicsView_DrawBackground(ptr unsafe.Pointer, painter unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawBackground"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRectF))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect))
	} else {
		NewQGraphicsViewFromPointer(ptr).DrawBackgroundDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect))
	}
}

func (ptr *QGraphicsView) ConnectDrawBackground(f func(painter *gui.QPainter, rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawBackground"); signal != nil {
			f := func(painter *gui.QPainter, rect *core.QRectF) {
				(*(*func(*gui.QPainter, *core.QRectF))(signal))(painter, rect)
				f(painter, rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawBackground", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawBackground", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsView) DisconnectDrawBackground() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawBackground")
	}
}

func (ptr *QGraphicsView) DrawBackground(painter gui.QPainter_ITF, rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_DrawBackground(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsView) DrawBackgroundDefault(painter gui.QPainter_ITF, rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_DrawBackgroundDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(rect))
	}
}

//export callbackQGraphicsView_DrawForeground
func callbackQGraphicsView_DrawForeground(ptr unsafe.Pointer, painter unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawForeground"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRectF))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect))
	} else {
		NewQGraphicsViewFromPointer(ptr).DrawForegroundDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect))
	}
}

func (ptr *QGraphicsView) ConnectDrawForeground(f func(painter *gui.QPainter, rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawForeground"); signal != nil {
			f := func(painter *gui.QPainter, rect *core.QRectF) {
				(*(*func(*gui.QPainter, *core.QRectF))(signal))(painter, rect)
				f(painter, rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawForeground", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawForeground", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsView) DisconnectDrawForeground() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawForeground")
	}
}

func (ptr *QGraphicsView) DrawForeground(painter gui.QPainter_ITF, rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_DrawForeground(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsView) DrawForegroundDefault(painter gui.QPainter_ITF, rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_DrawForegroundDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsView) EnsureVisible3(item QGraphicsItem_ITF, xmargin int, ymargin int) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_EnsureVisible3(ptr.Pointer(), PointerFromQGraphicsItem(item), C.int(int32(xmargin)), C.int(int32(ymargin)))
	}
}

func (ptr *QGraphicsView) EnsureVisible(rect core.QRectF_ITF, xmargin int, ymargin int) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_EnsureVisible(ptr.Pointer(), core.PointerFromQRectF(rect), C.int(int32(xmargin)), C.int(int32(ymargin)))
	}
}

func (ptr *QGraphicsView) EnsureVisible2(x float64, y float64, w float64, h float64, xmargin int, ymargin int) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_EnsureVisible2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h), C.int(int32(xmargin)), C.int(int32(ymargin)))
	}
}

func (ptr *QGraphicsView) FitInView3(item QGraphicsItem_ITF, aspectRatioMode core.Qt__AspectRatioMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_FitInView3(ptr.Pointer(), PointerFromQGraphicsItem(item), C.longlong(aspectRatioMode))
	}
}

func (ptr *QGraphicsView) FitInView(rect core.QRectF_ITF, aspectRatioMode core.Qt__AspectRatioMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_FitInView(ptr.Pointer(), core.PointerFromQRectF(rect), C.longlong(aspectRatioMode))
	}
}

func (ptr *QGraphicsView) FitInView2(x float64, y float64, w float64, h float64, aspectRatioMode core.Qt__AspectRatioMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_FitInView2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h), C.longlong(aspectRatioMode))
	}
}

//export callbackQGraphicsView_InvalidateScene
func callbackQGraphicsView_InvalidateScene(ptr unsafe.Pointer, rect unsafe.Pointer, layers C.longlong) {
	if signal := qt.GetSignal(ptr, "invalidateScene"); signal != nil {
		(*(*func(*core.QRectF, QGraphicsScene__SceneLayer))(signal))(core.NewQRectFFromPointer(rect), QGraphicsScene__SceneLayer(layers))
	} else {
		NewQGraphicsViewFromPointer(ptr).InvalidateSceneDefault(core.NewQRectFFromPointer(rect), QGraphicsScene__SceneLayer(layers))
	}
}

func (ptr *QGraphicsView) ConnectInvalidateScene(f func(rect *core.QRectF, layers QGraphicsScene__SceneLayer)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "invalidateScene"); signal != nil {
			f := func(rect *core.QRectF, layers QGraphicsScene__SceneLayer) {
				(*(*func(*core.QRectF, QGraphicsScene__SceneLayer))(signal))(rect, layers)
				f(rect, layers)
			}
			qt.ConnectSignal(ptr.Pointer(), "invalidateScene", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "invalidateScene", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsView) DisconnectInvalidateScene() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "invalidateScene")
	}
}

func (ptr *QGraphicsView) InvalidateScene(rect core.QRectF_ITF, layers QGraphicsScene__SceneLayer) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_InvalidateScene(ptr.Pointer(), core.PointerFromQRectF(rect), C.longlong(layers))
	}
}

func (ptr *QGraphicsView) InvalidateSceneDefault(rect core.QRectF_ITF, layers QGraphicsScene__SceneLayer) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_InvalidateSceneDefault(ptr.Pointer(), core.PointerFromQRectF(rect), C.longlong(layers))
	}
}

func (ptr *QGraphicsView) Render(painter gui.QPainter_ITF, target core.QRectF_ITF, source core.QRect_ITF, aspectRatioMode core.Qt__AspectRatioMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_Render(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(target), core.PointerFromQRect(source), C.longlong(aspectRatioMode))
	}
}

func (ptr *QGraphicsView) ResetCachedContent() {
	if ptr.Pointer() != nil {
		C.QGraphicsView_ResetCachedContent(ptr.Pointer())
	}
}

func (ptr *QGraphicsView) ResetMatrix() {
	if ptr.Pointer() != nil {
		C.QGraphicsView_ResetMatrix(ptr.Pointer())
	}
}

func (ptr *QGraphicsView) ResetTransform() {
	if ptr.Pointer() != nil {
		C.QGraphicsView_ResetTransform(ptr.Pointer())
	}
}

func (ptr *QGraphicsView) Rotate(angle float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_Rotate(ptr.Pointer(), C.double(angle))
	}
}

//export callbackQGraphicsView_RubberBandChanged
func callbackQGraphicsView_RubberBandChanged(ptr unsafe.Pointer, rubberBandRect unsafe.Pointer, fromScenePoint unsafe.Pointer, toScenePoint unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "rubberBandChanged"); signal != nil {
		(*(*func(*core.QRect, *core.QPointF, *core.QPointF))(signal))(core.NewQRectFromPointer(rubberBandRect), core.NewQPointFFromPointer(fromScenePoint), core.NewQPointFFromPointer(toScenePoint))
	}

}

func (ptr *QGraphicsView) ConnectRubberBandChanged(f func(rubberBandRect *core.QRect, fromScenePoint *core.QPointF, toScenePoint *core.QPointF)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "rubberBandChanged") {
			C.QGraphicsView_ConnectRubberBandChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "rubberBandChanged"); signal != nil {
			f := func(rubberBandRect *core.QRect, fromScenePoint *core.QPointF, toScenePoint *core.QPointF) {
				(*(*func(*core.QRect, *core.QPointF, *core.QPointF))(signal))(rubberBandRect, fromScenePoint, toScenePoint)
				f(rubberBandRect, fromScenePoint, toScenePoint)
			}
			qt.ConnectSignal(ptr.Pointer(), "rubberBandChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rubberBandChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsView) DisconnectRubberBandChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsView_DisconnectRubberBandChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "rubberBandChanged")
	}
}

func (ptr *QGraphicsView) RubberBandChanged(rubberBandRect core.QRect_ITF, fromScenePoint core.QPointF_ITF, toScenePoint core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_RubberBandChanged(ptr.Pointer(), core.PointerFromQRect(rubberBandRect), core.PointerFromQPointF(fromScenePoint), core.PointerFromQPointF(toScenePoint))
	}
}

func (ptr *QGraphicsView) Scale(sx float64, sy float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_Scale(ptr.Pointer(), C.double(sx), C.double(sy))
	}
}

func (ptr *QGraphicsView) SetAlignment(alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetAlignment(ptr.Pointer(), C.longlong(alignment))
	}
}

func (ptr *QGraphicsView) SetBackgroundBrush(brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetBackgroundBrush(ptr.Pointer(), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QGraphicsView) SetCacheMode(mode QGraphicsView__CacheModeFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetCacheMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QGraphicsView) SetDragMode(mode QGraphicsView__DragMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetDragMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QGraphicsView) SetForegroundBrush(brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetForegroundBrush(ptr.Pointer(), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QGraphicsView) SetInteractive(allowed bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetInteractive(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(allowed))))
	}
}

func (ptr *QGraphicsView) SetMatrix(matrix gui.QMatrix_ITF, combine bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetMatrix(ptr.Pointer(), gui.PointerFromQMatrix(matrix), C.char(int8(qt.GoBoolToInt(combine))))
	}
}

func (ptr *QGraphicsView) SetOptimizationFlag(flag QGraphicsView__OptimizationFlag, enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetOptimizationFlag(ptr.Pointer(), C.longlong(flag), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsView) SetOptimizationFlags(flags QGraphicsView__OptimizationFlag) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetOptimizationFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QGraphicsView) SetRenderHint(hint gui.QPainter__RenderHint, enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetRenderHint(ptr.Pointer(), C.longlong(hint), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsView) SetRenderHints(hints gui.QPainter__RenderHint) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetRenderHints(ptr.Pointer(), C.longlong(hints))
	}
}

func (ptr *QGraphicsView) SetResizeAnchor(anchor QGraphicsView__ViewportAnchor) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetResizeAnchor(ptr.Pointer(), C.longlong(anchor))
	}
}

func (ptr *QGraphicsView) SetRubberBandSelectionMode(mode core.Qt__ItemSelectionMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetRubberBandSelectionMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QGraphicsView) SetScene(scene QGraphicsScene_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetScene(ptr.Pointer(), PointerFromQGraphicsScene(scene))
	}
}

func (ptr *QGraphicsView) SetSceneRect(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetSceneRect(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsView) SetSceneRect2(x float64, y float64, w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetSceneRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h))
	}
}

func (ptr *QGraphicsView) SetTransform(matrix gui.QTransform_ITF, combine bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetTransform(ptr.Pointer(), gui.PointerFromQTransform(matrix), C.char(int8(qt.GoBoolToInt(combine))))
	}
}

func (ptr *QGraphicsView) SetTransformationAnchor(anchor QGraphicsView__ViewportAnchor) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetTransformationAnchor(ptr.Pointer(), C.longlong(anchor))
	}
}

func (ptr *QGraphicsView) SetViewportUpdateMode(mode QGraphicsView__ViewportUpdateMode) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetViewportUpdateMode(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQGraphicsView_SetupViewport
func callbackQGraphicsView_SetupViewport(ptr unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setupViewport"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsViewFromPointer(ptr).SetupViewportDefault(NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsView) ConnectSetupViewport(f func(widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setupViewport"); signal != nil {
			f := func(widget *QWidget) {
				(*(*func(*QWidget))(signal))(widget)
				f(widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "setupViewport", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setupViewport", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsView) DisconnectSetupViewport() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setupViewport")
	}
}

func (ptr *QGraphicsView) SetupViewport(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetupViewport(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsView) SetupViewportDefault(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_SetupViewportDefault(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsView) Shear(sh float64, sv float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_Shear(ptr.Pointer(), C.double(sh), C.double(sv))
	}
}

func (ptr *QGraphicsView) Translate(dx float64, dy float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_Translate(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

//export callbackQGraphicsView_UpdateScene
func callbackQGraphicsView_UpdateScene(ptr unsafe.Pointer, rects C.struct_QtWidgets_PackedList) {
	if signal := qt.GetSignal(ptr, "updateScene"); signal != nil {
		(*(*func([]*core.QRectF))(signal))(func(l C.struct_QtWidgets_PackedList) []*core.QRectF {
			out := make([]*core.QRectF, int(l.len))
			tmpList := NewQGraphicsViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__updateScene_rects_atList(i)
			}
			return out
		}(rects))
	} else {
		NewQGraphicsViewFromPointer(ptr).UpdateSceneDefault(func(l C.struct_QtWidgets_PackedList) []*core.QRectF {
			out := make([]*core.QRectF, int(l.len))
			tmpList := NewQGraphicsViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__updateScene_rects_atList(i)
			}
			return out
		}(rects))
	}
}

func (ptr *QGraphicsView) ConnectUpdateScene(f func(rects []*core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateScene"); signal != nil {
			f := func(rects []*core.QRectF) {
				(*(*func([]*core.QRectF))(signal))(rects)
				f(rects)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateScene", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateScene", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsView) DisconnectUpdateScene() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateScene")
	}
}

func (ptr *QGraphicsView) UpdateScene(rects []*core.QRectF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_UpdateScene(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQGraphicsViewFromPointer(NewQGraphicsViewFromPointer(nil).__updateScene_rects_newList())
			for _, v := range rects {
				tmpList.__updateScene_rects_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QGraphicsView) UpdateSceneDefault(rects []*core.QRectF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_UpdateSceneDefault(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQGraphicsViewFromPointer(NewQGraphicsViewFromPointer(nil).__updateScene_rects_newList())
			for _, v := range rects {
				tmpList.__updateScene_rects_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQGraphicsView_UpdateSceneRect
func callbackQGraphicsView_UpdateSceneRect(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateSceneRect"); signal != nil {
		(*(*func(*core.QRectF))(signal))(core.NewQRectFFromPointer(rect))
	} else {
		NewQGraphicsViewFromPointer(ptr).UpdateSceneRectDefault(core.NewQRectFFromPointer(rect))
	}
}

func (ptr *QGraphicsView) ConnectUpdateSceneRect(f func(rect *core.QRectF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateSceneRect"); signal != nil {
			f := func(rect *core.QRectF) {
				(*(*func(*core.QRectF))(signal))(rect)
				f(rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateSceneRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateSceneRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsView) DisconnectUpdateSceneRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateSceneRect")
	}
}

func (ptr *QGraphicsView) UpdateSceneRect(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_UpdateSceneRect(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QGraphicsView) UpdateSceneRectDefault(rect core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView_UpdateSceneRectDefault(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

//export callbackQGraphicsView_DestroyQGraphicsView
func callbackQGraphicsView_DestroyQGraphicsView(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsView"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsViewFromPointer(ptr).DestroyQGraphicsViewDefault()
	}
}

func (ptr *QGraphicsView) ConnectDestroyQGraphicsView(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsView"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsView", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsView", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsView) DisconnectDestroyQGraphicsView() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsView")
	}
}

func (ptr *QGraphicsView) DestroyQGraphicsView() {
	if ptr.Pointer() != nil {
		C.QGraphicsView_DestroyQGraphicsView(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsView) DestroyQGraphicsViewDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsView_DestroyQGraphicsViewDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsView) BackgroundBrush() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QGraphicsView_BackgroundBrush(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) ForegroundBrush() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QGraphicsView_ForegroundBrush(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) ItemAt(pos core.QPoint_ITF) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsView_ItemAt(ptr.Pointer(), core.PointerFromQPoint(pos)))
	}
	return nil
}

func (ptr *QGraphicsView) ItemAt2(x int, y int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsView_ItemAt2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y))))
	}
	return nil
}

func (ptr *QGraphicsView) Scene() *QGraphicsScene {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsSceneFromPointer(C.QGraphicsView_Scene(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) CacheMode() QGraphicsView__CacheModeFlag {
	if ptr.Pointer() != nil {
		return QGraphicsView__CacheModeFlag(C.QGraphicsView_CacheMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsView) DragMode() QGraphicsView__DragMode {
	if ptr.Pointer() != nil {
		return QGraphicsView__DragMode(C.QGraphicsView_DragMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsView) OptimizationFlags() QGraphicsView__OptimizationFlag {
	if ptr.Pointer() != nil {
		return QGraphicsView__OptimizationFlag(C.QGraphicsView_OptimizationFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsView) ResizeAnchor() QGraphicsView__ViewportAnchor {
	if ptr.Pointer() != nil {
		return QGraphicsView__ViewportAnchor(C.QGraphicsView_ResizeAnchor(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsView) TransformationAnchor() QGraphicsView__ViewportAnchor {
	if ptr.Pointer() != nil {
		return QGraphicsView__ViewportAnchor(C.QGraphicsView_TransformationAnchor(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsView) ViewportUpdateMode() QGraphicsView__ViewportUpdateMode {
	if ptr.Pointer() != nil {
		return QGraphicsView__ViewportUpdateMode(C.QGraphicsView_ViewportUpdateMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsView) Items() []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList(i)
			}
			return out
		}(C.QGraphicsView_Items(ptr.Pointer()))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsView) Items7(path gui.QPainterPath_ITF, mode core.Qt__ItemSelectionMode) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList7(i)
			}
			return out
		}(C.QGraphicsView_Items7(ptr.Pointer(), gui.PointerFromQPainterPath(path), C.longlong(mode)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsView) Items2(pos core.QPoint_ITF) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList2(i)
			}
			return out
		}(C.QGraphicsView_Items2(ptr.Pointer(), core.PointerFromQPoint(pos)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsView) Items6(polygon gui.QPolygon_ITF, mode core.Qt__ItemSelectionMode) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList6(i)
			}
			return out
		}(C.QGraphicsView_Items6(ptr.Pointer(), gui.PointerFromQPolygon(polygon), C.longlong(mode)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsView) Items4(rect core.QRect_ITF, mode core.Qt__ItemSelectionMode) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList4(i)
			}
			return out
		}(C.QGraphicsView_Items4(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(mode)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsView) Items3(x int, y int) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList3(i)
			}
			return out
		}(C.QGraphicsView_Items3(ptr.Pointer(), C.int(int32(x)), C.int(int32(y))))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsView) Items5(x int, y int, w int, h int, mode core.Qt__ItemSelectionMode) []*QGraphicsItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QGraphicsItem {
			out := make([]*QGraphicsItem, int(l.len))
			tmpList := NewQGraphicsViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList5(i)
			}
			return out
		}(C.QGraphicsView_Items5(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)), C.int(int32(w)), C.int(int32(h)), C.longlong(mode)))
	}
	return make([]*QGraphicsItem, 0)
}

func (ptr *QGraphicsView) Matrix() *gui.QMatrix {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQMatrixFromPointer(C.QGraphicsView_Matrix(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QMatrix).DestroyQMatrix)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) RenderHints() gui.QPainter__RenderHint {
	if ptr.Pointer() != nil {
		return gui.QPainter__RenderHint(C.QGraphicsView_RenderHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsView) MapFromScene4(path gui.QPainterPath_ITF) *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsView_MapFromScene4(ptr.Pointer(), gui.PointerFromQPainterPath(path)))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapToScene4(path gui.QPainterPath_ITF) *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QGraphicsView_MapToScene4(ptr.Pointer(), gui.PointerFromQPainterPath(path)))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapFromScene(point core.QPointF_ITF) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsView_MapFromScene(ptr.Pointer(), core.PointerFromQPointF(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapFromScene5(x float64, y float64) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QGraphicsView_MapFromScene5(ptr.Pointer(), C.double(x), C.double(y)))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapToScene(point core.QPoint_ITF) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsView_MapToScene(ptr.Pointer(), core.PointerFromQPoint(point)))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapToScene5(x int, y int) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QGraphicsView_MapToScene5(ptr.Pointer(), C.int(int32(x)), C.int(int32(y))))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapFromScene3(polygon gui.QPolygonF_ITF) *gui.QPolygon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFromPointer(C.QGraphicsView_MapFromScene3(ptr.Pointer(), gui.PointerFromQPolygonF(polygon)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygon).DestroyQPolygon)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapFromScene2(rect core.QRectF_ITF) *gui.QPolygon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFromPointer(C.QGraphicsView_MapFromScene2(ptr.Pointer(), core.PointerFromQRectF(rect)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygon).DestroyQPolygon)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapFromScene6(x float64, y float64, w float64, h float64) *gui.QPolygon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFromPointer(C.QGraphicsView_MapFromScene6(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygon).DestroyQPolygon)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapToScene3(polygon gui.QPolygon_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsView_MapToScene3(ptr.Pointer(), gui.PointerFromQPolygon(polygon)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapToScene2(rect core.QRect_ITF) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsView_MapToScene2(ptr.Pointer(), core.PointerFromQRect(rect)))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) MapToScene6(x int, y int, w int, h int) *gui.QPolygonF {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPolygonFFromPointer(C.QGraphicsView_MapToScene6(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)), C.int(int32(w)), C.int(int32(h))))
		runtime.SetFinalizer(tmpValue, (*gui.QPolygonF).DestroyQPolygonF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) RubberBandRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QGraphicsView_RubberBandRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) SceneRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsView_SceneRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) Transform() *gui.QTransform {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTransformFromPointer(C.QGraphicsView_Transform(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTransform).DestroyQTransform)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) ViewportTransform() *gui.QTransform {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTransformFromPointer(C.QGraphicsView_ViewportTransform(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTransform).DestroyQTransform)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) Alignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QGraphicsView_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsView) RubberBandSelectionMode() core.Qt__ItemSelectionMode {
	if ptr.Pointer() != nil {
		return core.Qt__ItemSelectionMode(C.QGraphicsView_RubberBandSelectionMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsView) IsInteractive() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsView_IsInteractive(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsView) IsTransformed() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsView_IsTransformed(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsView) __updateScene_rects_atList(i int) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsView___updateScene_rects_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsView) __updateScene_rects_setList(i core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView___updateScene_rects_setList(ptr.Pointer(), core.PointerFromQRectF(i))
	}
}

func (ptr *QGraphicsView) __updateScene_rects_newList() unsafe.Pointer {
	return C.QGraphicsView___updateScene_rects_newList(ptr.Pointer())
}

func (ptr *QGraphicsView) __items_atList(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsView___items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsView) __items_setList(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView___items_setList(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsView) __items_newList() unsafe.Pointer {
	return C.QGraphicsView___items_newList(ptr.Pointer())
}

func (ptr *QGraphicsView) __items_atList7(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsView___items_atList7(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsView) __items_setList7(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView___items_setList7(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsView) __items_newList7() unsafe.Pointer {
	return C.QGraphicsView___items_newList7(ptr.Pointer())
}

func (ptr *QGraphicsView) __items_atList2(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsView___items_atList2(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsView) __items_setList2(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView___items_setList2(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsView) __items_newList2() unsafe.Pointer {
	return C.QGraphicsView___items_newList2(ptr.Pointer())
}

func (ptr *QGraphicsView) __items_atList6(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsView___items_atList6(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsView) __items_setList6(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView___items_setList6(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsView) __items_newList6() unsafe.Pointer {
	return C.QGraphicsView___items_newList6(ptr.Pointer())
}

func (ptr *QGraphicsView) __items_atList4(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsView___items_atList4(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsView) __items_setList4(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView___items_setList4(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsView) __items_newList4() unsafe.Pointer {
	return C.QGraphicsView___items_newList4(ptr.Pointer())
}

func (ptr *QGraphicsView) __items_atList3(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsView___items_atList3(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsView) __items_setList3(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView___items_setList3(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsView) __items_newList3() unsafe.Pointer {
	return C.QGraphicsView___items_newList3(ptr.Pointer())
}

func (ptr *QGraphicsView) __items_atList5(i int) *QGraphicsItem {
	if ptr.Pointer() != nil {
		return NewQGraphicsItemFromPointer(C.QGraphicsView___items_atList5(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QGraphicsView) __items_setList5(i QGraphicsItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsView___items_setList5(ptr.Pointer(), PointerFromQGraphicsItem(i))
	}
}

func (ptr *QGraphicsView) __items_newList5() unsafe.Pointer {
	return C.QGraphicsView___items_newList5(ptr.Pointer())
}

type QGraphicsWidget struct {
	QGraphicsObject
	QGraphicsLayoutItem
}

type QGraphicsWidget_ITF interface {
	QGraphicsObject_ITF
	QGraphicsLayoutItem_ITF
	QGraphicsWidget_PTR() *QGraphicsWidget
}

func (ptr *QGraphicsWidget) QGraphicsWidget_PTR() *QGraphicsWidget {
	return ptr
}

func (ptr *QGraphicsWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QGraphicsWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGraphicsObject_PTR().SetPointer(p)
		ptr.QGraphicsLayoutItem_PTR().SetPointer(p)
	}
}

func PointerFromQGraphicsWidget(ptr QGraphicsWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGraphicsWidget_PTR().Pointer()
	}
	return nil
}

func NewQGraphicsWidgetFromPointer(ptr unsafe.Pointer) (n *QGraphicsWidget) {
	n = new(QGraphicsWidget)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QGraphicsWidget__anonymous
//QGraphicsWidget::anonymous
type QGraphicsWidget__anonymous int64

const (
	QGraphicsWidget__Type QGraphicsWidget__anonymous = QGraphicsWidget__anonymous(11)
)

func NewQGraphicsWidget(parent QGraphicsItem_ITF, wFlags core.Qt__WindowType) *QGraphicsWidget {
	tmpValue := NewQGraphicsWidgetFromPointer(C.QGraphicsWidget_NewQGraphicsWidget(PointerFromQGraphicsItem(parent), C.longlong(wFlags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQGraphicsWidget_Close
func callbackQGraphicsWidget_Close(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "close"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsWidgetFromPointer(ptr).CloseDefault())))
}

func (ptr *QGraphicsWidget) ConnectClose(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "close"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "close", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "close", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectClose() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "close")
	}
}

func (ptr *QGraphicsWidget) Close() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsWidget_Close(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsWidget) CloseDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsWidget_CloseDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQGraphicsWidget_FocusNextPrevChild
func callbackQGraphicsWidget_FocusNextPrevChild(ptr unsafe.Pointer, next C.char) C.char {
	if signal := qt.GetSignal(ptr, "focusNextPrevChild"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(bool) bool)(signal))(int8(next) != 0))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsWidgetFromPointer(ptr).FocusNextPrevChildDefault(int8(next) != 0))))
}

func (ptr *QGraphicsWidget) ConnectFocusNextPrevChild(f func(next bool) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "focusNextPrevChild"); signal != nil {
			f := func(next bool) bool {
				(*(*func(bool) bool)(signal))(next)
				return f(next)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusNextPrevChild", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusNextPrevChild", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectFocusNextPrevChild() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "focusNextPrevChild")
	}
}

func (ptr *QGraphicsWidget) FocusNextPrevChild(next bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsWidget_FocusNextPrevChild(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next))))) != 0
	}
	return false
}

func (ptr *QGraphicsWidget) FocusNextPrevChildDefault(next bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsWidget_FocusNextPrevChildDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next))))) != 0
	}
	return false
}

//export callbackQGraphicsWidget_WindowFrameEvent
func callbackQGraphicsWidget_WindowFrameEvent(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "windowFrameEvent"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQGraphicsWidgetFromPointer(ptr).WindowFrameEventDefault(core.NewQEventFromPointer(event)))))
}

func (ptr *QGraphicsWidget) ConnectWindowFrameEvent(f func(event *core.QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "windowFrameEvent"); signal != nil {
			f := func(event *core.QEvent) bool {
				(*(*func(*core.QEvent) bool)(signal))(event)
				return f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "windowFrameEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "windowFrameEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectWindowFrameEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "windowFrameEvent")
	}
}

func (ptr *QGraphicsWidget) WindowFrameEvent(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsWidget_WindowFrameEvent(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QGraphicsWidget) WindowFrameEventDefault(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsWidget_WindowFrameEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QGraphicsWidget) GrabShortcut(sequence gui.QKeySequence_ITF, context core.Qt__ShortcutContext) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGraphicsWidget_GrabShortcut(ptr.Pointer(), gui.PointerFromQKeySequence(sequence), C.longlong(context))))
	}
	return 0
}

func (ptr *QGraphicsWidget) AddAction(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_AddAction(ptr.Pointer(), PointerFromQAction(action))
	}
}

func (ptr *QGraphicsWidget) AddActions(actions []*QAction) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_AddActions(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQGraphicsWidgetFromPointer(NewQGraphicsWidgetFromPointer(nil).__addActions_actions_newList())
			for _, v := range actions {
				tmpList.__addActions_actions_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QGraphicsWidget) AdjustSize() {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_AdjustSize(ptr.Pointer())
	}
}

//export callbackQGraphicsWidget_ChangeEvent
func callbackQGraphicsWidget_ChangeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "changeEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).ChangeEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectChangeEvent(f func(event *core.QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "changeEvent"); signal != nil {
			f := func(event *core.QEvent) {
				(*(*func(*core.QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "changeEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "changeEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectChangeEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "changeEvent")
	}
}

func (ptr *QGraphicsWidget) ChangeEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_ChangeEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QGraphicsWidget) ChangeEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_ChangeEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsWidget_CloseEvent
func callbackQGraphicsWidget_CloseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "closeEvent"); signal != nil {
		(*(*func(*gui.QCloseEvent))(signal))(gui.NewQCloseEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).CloseEventDefault(gui.NewQCloseEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectCloseEvent(f func(event *gui.QCloseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "closeEvent"); signal != nil {
			f := func(event *gui.QCloseEvent) {
				(*(*func(*gui.QCloseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "closeEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "closeEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectCloseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "closeEvent")
	}
}

func (ptr *QGraphicsWidget) CloseEvent(event gui.QCloseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_CloseEvent(ptr.Pointer(), gui.PointerFromQCloseEvent(event))
	}
}

func (ptr *QGraphicsWidget) CloseEventDefault(event gui.QCloseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_CloseEventDefault(ptr.Pointer(), gui.PointerFromQCloseEvent(event))
	}
}

//export callbackQGraphicsWidget_GeometryChanged
func callbackQGraphicsWidget_GeometryChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "geometryChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QGraphicsWidget) ConnectGeometryChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "geometryChanged") {
			C.QGraphicsWidget_ConnectGeometryChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "geometryChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "geometryChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "geometryChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectGeometryChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_DisconnectGeometryChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "geometryChanged")
	}
}

func (ptr *QGraphicsWidget) GeometryChanged() {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_GeometryChanged(ptr.Pointer())
	}
}

//export callbackQGraphicsWidget_GrabKeyboardEvent
func callbackQGraphicsWidget_GrabKeyboardEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "grabKeyboardEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).GrabKeyboardEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectGrabKeyboardEvent(f func(event *core.QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "grabKeyboardEvent"); signal != nil {
			f := func(event *core.QEvent) {
				(*(*func(*core.QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "grabKeyboardEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "grabKeyboardEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectGrabKeyboardEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "grabKeyboardEvent")
	}
}

func (ptr *QGraphicsWidget) GrabKeyboardEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_GrabKeyboardEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QGraphicsWidget) GrabKeyboardEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_GrabKeyboardEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsWidget_GrabMouseEvent
func callbackQGraphicsWidget_GrabMouseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "grabMouseEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).GrabMouseEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectGrabMouseEvent(f func(event *core.QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "grabMouseEvent"); signal != nil {
			f := func(event *core.QEvent) {
				(*(*func(*core.QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "grabMouseEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "grabMouseEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectGrabMouseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "grabMouseEvent")
	}
}

func (ptr *QGraphicsWidget) GrabMouseEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_GrabMouseEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QGraphicsWidget) GrabMouseEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_GrabMouseEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsWidget_HideEvent
func callbackQGraphicsWidget_HideEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hideEvent"); signal != nil {
		(*(*func(*gui.QHideEvent))(signal))(gui.NewQHideEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).HideEventDefault(gui.NewQHideEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectHideEvent(f func(event *gui.QHideEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hideEvent"); signal != nil {
			f := func(event *gui.QHideEvent) {
				(*(*func(*gui.QHideEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "hideEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hideEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectHideEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hideEvent")
	}
}

func (ptr *QGraphicsWidget) HideEvent(event gui.QHideEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_HideEvent(ptr.Pointer(), gui.PointerFromQHideEvent(event))
	}
}

func (ptr *QGraphicsWidget) HideEventDefault(event gui.QHideEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_HideEventDefault(ptr.Pointer(), gui.PointerFromQHideEvent(event))
	}
}

func (ptr *QGraphicsWidget) InsertAction(before QAction_ITF, action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_InsertAction(ptr.Pointer(), PointerFromQAction(before), PointerFromQAction(action))
	}
}

func (ptr *QGraphicsWidget) InsertActions(before QAction_ITF, actions []*QAction) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_InsertActions(ptr.Pointer(), PointerFromQAction(before), func() unsafe.Pointer {
			tmpList := NewQGraphicsWidgetFromPointer(NewQGraphicsWidgetFromPointer(nil).__insertActions_actions_newList())
			for _, v := range actions {
				tmpList.__insertActions_actions_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQGraphicsWidget_MoveEvent
func callbackQGraphicsWidget_MoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "moveEvent"); signal != nil {
		(*(*func(*QGraphicsSceneMoveEvent))(signal))(NewQGraphicsSceneMoveEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).MoveEventDefault(NewQGraphicsSceneMoveEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectMoveEvent(f func(event *QGraphicsSceneMoveEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "moveEvent"); signal != nil {
			f := func(event *QGraphicsSceneMoveEvent) {
				(*(*func(*QGraphicsSceneMoveEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "moveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "moveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "moveEvent")
	}
}

func (ptr *QGraphicsWidget) MoveEvent(event QGraphicsSceneMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_MoveEvent(ptr.Pointer(), PointerFromQGraphicsSceneMoveEvent(event))
	}
}

func (ptr *QGraphicsWidget) MoveEventDefault(event QGraphicsSceneMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_MoveEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneMoveEvent(event))
	}
}

//export callbackQGraphicsWidget_Paint
func callbackQGraphicsWidget_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsWidget) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QGraphicsWidget) Paint(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsWidget) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

//export callbackQGraphicsWidget_PaintWindowFrame
func callbackQGraphicsWidget_PaintWindowFrame(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paintWindowFrame"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).PaintWindowFrameDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionGraphicsItemFromPointer(option), NewQWidgetFromPointer(widget))
	}
}

func (ptr *QGraphicsWidget) ConnectPaintWindowFrame(f func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paintWindowFrame"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionGraphicsItem, widget *QWidget) {
				(*(*func(*gui.QPainter, *QStyleOptionGraphicsItem, *QWidget))(signal))(painter, option, widget)
				f(painter, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "paintWindowFrame", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paintWindowFrame", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectPaintWindowFrame() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paintWindowFrame")
	}
}

func (ptr *QGraphicsWidget) PaintWindowFrame(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_PaintWindowFrame(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

func (ptr *QGraphicsWidget) PaintWindowFrameDefault(painter gui.QPainter_ITF, option QStyleOptionGraphicsItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_PaintWindowFrameDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionGraphicsItem(option), PointerFromQWidget(widget))
	}
}

//export callbackQGraphicsWidget_PolishEvent
func callbackQGraphicsWidget_PolishEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "polishEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsWidgetFromPointer(ptr).PolishEventDefault()
	}
}

func (ptr *QGraphicsWidget) ConnectPolishEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "polishEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "polishEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "polishEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectPolishEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "polishEvent")
	}
}

func (ptr *QGraphicsWidget) PolishEvent() {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_PolishEvent(ptr.Pointer())
	}
}

func (ptr *QGraphicsWidget) PolishEventDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_PolishEventDefault(ptr.Pointer())
	}
}

func (ptr *QGraphicsWidget) ReleaseShortcut(id int) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_ReleaseShortcut(ptr.Pointer(), C.int(int32(id)))
	}
}

func (ptr *QGraphicsWidget) RemoveAction(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_RemoveAction(ptr.Pointer(), PointerFromQAction(action))
	}
}

func (ptr *QGraphicsWidget) Resize(size core.QSizeF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_Resize(ptr.Pointer(), core.PointerFromQSizeF(size))
	}
}

func (ptr *QGraphicsWidget) Resize2(w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_Resize2(ptr.Pointer(), C.double(w), C.double(h))
	}
}

//export callbackQGraphicsWidget_ResizeEvent
func callbackQGraphicsWidget_ResizeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resizeEvent"); signal != nil {
		(*(*func(*QGraphicsSceneResizeEvent))(signal))(NewQGraphicsSceneResizeEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).ResizeEventDefault(NewQGraphicsSceneResizeEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectResizeEvent(f func(event *QGraphicsSceneResizeEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resizeEvent"); signal != nil {
			f := func(event *QGraphicsSceneResizeEvent) {
				(*(*func(*QGraphicsSceneResizeEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "resizeEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resizeEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectResizeEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resizeEvent")
	}
}

func (ptr *QGraphicsWidget) ResizeEvent(event QGraphicsSceneResizeEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_ResizeEvent(ptr.Pointer(), PointerFromQGraphicsSceneResizeEvent(event))
	}
}

func (ptr *QGraphicsWidget) ResizeEventDefault(event QGraphicsSceneResizeEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_ResizeEventDefault(ptr.Pointer(), PointerFromQGraphicsSceneResizeEvent(event))
	}
}

func (ptr *QGraphicsWidget) SetAttribute(attribute core.Qt__WidgetAttribute, on bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetAttribute(ptr.Pointer(), C.longlong(attribute), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QGraphicsWidget) SetAutoFillBackground(enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetAutoFillBackground(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsWidget) SetContentsMargins(left float64, top float64, right float64, bottom float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetContentsMargins(ptr.Pointer(), C.double(left), C.double(top), C.double(right), C.double(bottom))
	}
}

func (ptr *QGraphicsWidget) SetFocusPolicy(policy core.Qt__FocusPolicy) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetFocusPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QGraphicsWidget) SetFont(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetFont(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

func (ptr *QGraphicsWidget) SetGeometry2(x float64, y float64, w float64, h float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetGeometry2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h))
	}
}

func (ptr *QGraphicsWidget) SetLayout(layout QGraphicsLayout_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetLayout(ptr.Pointer(), PointerFromQGraphicsLayout(layout))
	}
}

func (ptr *QGraphicsWidget) SetLayoutDirection(direction core.Qt__LayoutDirection) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetLayoutDirection(ptr.Pointer(), C.longlong(direction))
	}
}

func (ptr *QGraphicsWidget) SetPalette(palette gui.QPalette_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetPalette(ptr.Pointer(), gui.PointerFromQPalette(palette))
	}
}

func (ptr *QGraphicsWidget) SetShortcutAutoRepeat(id int, enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetShortcutAutoRepeat(ptr.Pointer(), C.int(int32(id)), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsWidget) SetShortcutEnabled(id int, enabled bool) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetShortcutEnabled(ptr.Pointer(), C.int(int32(id)), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QGraphicsWidget) SetStyle(style QStyle_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetStyle(ptr.Pointer(), PointerFromQStyle(style))
	}
}

func QGraphicsWidget_SetTabOrder(first QGraphicsWidget_ITF, second QGraphicsWidget_ITF) {
	C.QGraphicsWidget_QGraphicsWidget_SetTabOrder(PointerFromQGraphicsWidget(first), PointerFromQGraphicsWidget(second))
}

func (ptr *QGraphicsWidget) SetTabOrder(first QGraphicsWidget_ITF, second QGraphicsWidget_ITF) {
	C.QGraphicsWidget_QGraphicsWidget_SetTabOrder(PointerFromQGraphicsWidget(first), PointerFromQGraphicsWidget(second))
}

func (ptr *QGraphicsWidget) SetWindowFlags(wFlags core.Qt__WindowType) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetWindowFlags(ptr.Pointer(), C.longlong(wFlags))
	}
}

func (ptr *QGraphicsWidget) SetWindowFrameMargins(left float64, top float64, right float64, bottom float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetWindowFrameMargins(ptr.Pointer(), C.double(left), C.double(top), C.double(right), C.double(bottom))
	}
}

func (ptr *QGraphicsWidget) SetWindowTitle(title string) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		C.QGraphicsWidget_SetWindowTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
	}
}

//export callbackQGraphicsWidget_ShowEvent
func callbackQGraphicsWidget_ShowEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showEvent"); signal != nil {
		(*(*func(*gui.QShowEvent))(signal))(gui.NewQShowEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).ShowEventDefault(gui.NewQShowEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectShowEvent(f func(event *gui.QShowEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showEvent"); signal != nil {
			f := func(event *gui.QShowEvent) {
				(*(*func(*gui.QShowEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "showEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectShowEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showEvent")
	}
}

func (ptr *QGraphicsWidget) ShowEvent(event gui.QShowEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_ShowEvent(ptr.Pointer(), gui.PointerFromQShowEvent(event))
	}
}

func (ptr *QGraphicsWidget) ShowEventDefault(event gui.QShowEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_ShowEventDefault(ptr.Pointer(), gui.PointerFromQShowEvent(event))
	}
}

//export callbackQGraphicsWidget_UngrabKeyboardEvent
func callbackQGraphicsWidget_UngrabKeyboardEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "ungrabKeyboardEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).UngrabKeyboardEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectUngrabKeyboardEvent(f func(event *core.QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "ungrabKeyboardEvent"); signal != nil {
			f := func(event *core.QEvent) {
				(*(*func(*core.QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "ungrabKeyboardEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "ungrabKeyboardEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectUngrabKeyboardEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "ungrabKeyboardEvent")
	}
}

func (ptr *QGraphicsWidget) UngrabKeyboardEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_UngrabKeyboardEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QGraphicsWidget) UngrabKeyboardEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_UngrabKeyboardEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQGraphicsWidget_UngrabMouseEvent
func callbackQGraphicsWidget_UngrabMouseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "ungrabMouseEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).UngrabMouseEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QGraphicsWidget) ConnectUngrabMouseEvent(f func(event *core.QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "ungrabMouseEvent"); signal != nil {
			f := func(event *core.QEvent) {
				(*(*func(*core.QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "ungrabMouseEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "ungrabMouseEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectUngrabMouseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "ungrabMouseEvent")
	}
}

func (ptr *QGraphicsWidget) UngrabMouseEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_UngrabMouseEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QGraphicsWidget) UngrabMouseEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_UngrabMouseEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QGraphicsWidget) UnsetLayoutDirection() {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_UnsetLayoutDirection(ptr.Pointer())
	}
}

func (ptr *QGraphicsWidget) UnsetWindowFrameMargins() {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_UnsetWindowFrameMargins(ptr.Pointer())
	}
}

//export callbackQGraphicsWidget_DestroyQGraphicsWidget
func callbackQGraphicsWidget_DestroyQGraphicsWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGraphicsWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGraphicsWidgetFromPointer(ptr).DestroyQGraphicsWidgetDefault()
	}
}

func (ptr *QGraphicsWidget) ConnectDestroyQGraphicsWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGraphicsWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGraphicsWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectDestroyQGraphicsWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGraphicsWidget")
	}
}

func (ptr *QGraphicsWidget) DestroyQGraphicsWidget() {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_DestroyQGraphicsWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsWidget) DestroyQGraphicsWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_DestroyQGraphicsWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGraphicsWidget) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QGraphicsWidget_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) Layout() *QGraphicsLayout {
	if ptr.Pointer() != nil {
		return NewQGraphicsLayoutFromPointer(C.QGraphicsWidget_Layout(ptr.Pointer()))
	}
	return nil
}

func (ptr *QGraphicsWidget) FocusWidget() *QGraphicsWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsWidgetFromPointer(C.QGraphicsWidget_FocusWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) Actions() []*QAction {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QAction {
			out := make([]*QAction, int(l.len))
			tmpList := NewQGraphicsWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__actions_atList(i)
			}
			return out
		}(C.QGraphicsWidget_Actions(ptr.Pointer()))
	}
	return make([]*QAction, 0)
}

func (ptr *QGraphicsWidget) Palette() *gui.QPalette {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPaletteFromPointer(C.QGraphicsWidget_Palette(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsWidget_BoundingRect
func callbackQGraphicsWidget_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "boundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func() *core.QRectF)(signal))())
	}

	return core.PointerFromQRectF(NewQGraphicsWidgetFromPointer(ptr).BoundingRectDefault())
}

func (ptr *QGraphicsWidget) ConnectBoundingRect(f func() *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "boundingRect"); signal != nil {
			f := func() *core.QRectF {
				(*(*func() *core.QRectF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "boundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "boundingRect")
	}
}

func (ptr *QGraphicsWidget) BoundingRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsWidget_BoundingRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) BoundingRectDefault() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsWidget_BoundingRectDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) Rect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsWidget_Rect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) WindowFrameGeometry() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsWidget_WindowFrameGeometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) WindowFrameRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsWidget_WindowFrameRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) Size() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsWidget_Size(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

//export callbackQGraphicsWidget_SizeHint
func callbackQGraphicsWidget_SizeHint(ptr unsafe.Pointer, which C.longlong, constraint unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSizeF((*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
	}

	return core.PointerFromQSizeF(NewQGraphicsWidgetFromPointer(ptr).SizeHintDefault(core.Qt__SizeHint(which), core.NewQSizeFFromPointer(constraint)))
}

func (ptr *QGraphicsWidget) ConnectSizeHint(f func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func(which core.Qt__SizeHint, constraint *core.QSizeF) *core.QSizeF {
				(*(*func(core.Qt__SizeHint, *core.QSizeF) *core.QSizeF)(signal))(which, constraint)
				return f(which, constraint)
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QGraphicsWidget) SizeHint(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsWidget_SizeHint(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) SizeHintDefault(which core.Qt__SizeHint, constraint core.QSizeF_ITF) *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsWidget_SizeHintDefault(ptr.Pointer(), C.longlong(which), core.PointerFromQSizeF(constraint)))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) WindowTitle() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QGraphicsWidget_WindowTitle(ptr.Pointer()))
	}
	return ""
}

func (ptr *QGraphicsWidget) Style() *QStyle {
	if ptr.Pointer() != nil {
		tmpValue := NewQStyleFromPointer(C.QGraphicsWidget_Style(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) FocusPolicy() core.Qt__FocusPolicy {
	if ptr.Pointer() != nil {
		return core.Qt__FocusPolicy(C.QGraphicsWidget_FocusPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsWidget) LayoutDirection() core.Qt__LayoutDirection {
	if ptr.Pointer() != nil {
		return core.Qt__LayoutDirection(C.QGraphicsWidget_LayoutDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsWidget) WindowFlags() core.Qt__WindowType {
	if ptr.Pointer() != nil {
		return core.Qt__WindowType(C.QGraphicsWidget_WindowFlags(ptr.Pointer()))
	}
	return 0
}

//export callbackQGraphicsWidget_WindowFrameSectionAt
func callbackQGraphicsWidget_WindowFrameSectionAt(ptr unsafe.Pointer, pos unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "windowFrameSectionAt"); signal != nil {
		return C.longlong((*(*func(*core.QPointF) core.Qt__WindowFrameSection)(signal))(core.NewQPointFFromPointer(pos)))
	}

	return C.longlong(NewQGraphicsWidgetFromPointer(ptr).WindowFrameSectionAtDefault(core.NewQPointFFromPointer(pos)))
}

func (ptr *QGraphicsWidget) ConnectWindowFrameSectionAt(f func(pos *core.QPointF) core.Qt__WindowFrameSection) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "windowFrameSectionAt"); signal != nil {
			f := func(pos *core.QPointF) core.Qt__WindowFrameSection {
				(*(*func(*core.QPointF) core.Qt__WindowFrameSection)(signal))(pos)
				return f(pos)
			}
			qt.ConnectSignal(ptr.Pointer(), "windowFrameSectionAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "windowFrameSectionAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectWindowFrameSectionAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "windowFrameSectionAt")
	}
}

func (ptr *QGraphicsWidget) WindowFrameSectionAt(pos core.QPointF_ITF) core.Qt__WindowFrameSection {
	if ptr.Pointer() != nil {
		return core.Qt__WindowFrameSection(C.QGraphicsWidget_WindowFrameSectionAt(ptr.Pointer(), core.PointerFromQPointF(pos)))
	}
	return 0
}

func (ptr *QGraphicsWidget) WindowFrameSectionAtDefault(pos core.QPointF_ITF) core.Qt__WindowFrameSection {
	if ptr.Pointer() != nil {
		return core.Qt__WindowFrameSection(C.QGraphicsWidget_WindowFrameSectionAtDefault(ptr.Pointer(), core.PointerFromQPointF(pos)))
	}
	return 0
}

func (ptr *QGraphicsWidget) WindowType() core.Qt__WindowType {
	if ptr.Pointer() != nil {
		return core.Qt__WindowType(C.QGraphicsWidget_WindowType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGraphicsWidget) AutoFillBackground() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsWidget_AutoFillBackground(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsWidget) IsActiveWindow() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsWidget_IsActiveWindow(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGraphicsWidget) TestAttribute(attribute core.Qt__WidgetAttribute) bool {
	if ptr.Pointer() != nil {
		return int8(C.QGraphicsWidget_TestAttribute(ptr.Pointer(), C.longlong(attribute))) != 0
	}
	return false
}

func (ptr *QGraphicsWidget) GetWindowFrameMargins(left float64, top float64, right float64, bottom float64) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_GetWindowFrameMargins(ptr.Pointer(), C.double(left), C.double(top), C.double(right), C.double(bottom))
	}
}

//export callbackQGraphicsWidget_InitStyleOption
func callbackQGraphicsWidget_InitStyleOption(ptr unsafe.Pointer, option unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "initStyleOption"); signal != nil {
		(*(*func(*QStyleOption))(signal))(NewQStyleOptionFromPointer(option))
	} else {
		NewQGraphicsWidgetFromPointer(ptr).InitStyleOptionDefault(NewQStyleOptionFromPointer(option))
	}
}

func (ptr *QGraphicsWidget) ConnectInitStyleOption(f func(option *QStyleOption)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "initStyleOption"); signal != nil {
			f := func(option *QStyleOption) {
				(*(*func(*QStyleOption))(signal))(option)
				f(option)
			}
			qt.ConnectSignal(ptr.Pointer(), "initStyleOption", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "initStyleOption", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGraphicsWidget) DisconnectInitStyleOption() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "initStyleOption")
	}
}

func (ptr *QGraphicsWidget) InitStyleOption(option QStyleOption_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_InitStyleOption(ptr.Pointer(), PointerFromQStyleOption(option))
	}
}

func (ptr *QGraphicsWidget) InitStyleOptionDefault(option QStyleOption_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_InitStyleOptionDefault(ptr.Pointer(), PointerFromQStyleOption(option))
	}
}

func (ptr *QGraphicsWidget) Geometry() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QGraphicsWidget_Geometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) MaximumSize() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsWidget_MaximumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) SetMaximumSize(maximumSize core.QSizeF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetMaximumSize(ptr.Pointer(), core.PointerFromQSizeF(maximumSize))
	}
}

func (ptr *QGraphicsWidget) MinimumSize() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsWidget_MinimumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) SetMinimumSize(minimumSize core.QSizeF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetMinimumSize(ptr.Pointer(), core.PointerFromQSizeF(minimumSize))
	}
}

func (ptr *QGraphicsWidget) PreferredSize() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QGraphicsWidget_PreferredSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) SetPreferredSize(preferredSize core.QSizeF_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetPreferredSize(ptr.Pointer(), core.PointerFromQSizeF(preferredSize))
	}
}

func (ptr *QGraphicsWidget) SizePolicy() *QSizePolicy {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizePolicyFromPointer(C.QGraphicsWidget_SizePolicy(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSizePolicy).DestroyQSizePolicy)
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) SetSizePolicy(sizePolicy QSizePolicy_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget_SetSizePolicy(ptr.Pointer(), PointerFromQSizePolicy(sizePolicy))
	}
}

func (ptr *QGraphicsWidget) __addActions_actions_atList(i int) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QGraphicsWidget___addActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) __addActions_actions_setList(i QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget___addActions_actions_setList(ptr.Pointer(), PointerFromQAction(i))
	}
}

func (ptr *QGraphicsWidget) __addActions_actions_newList() unsafe.Pointer {
	return C.QGraphicsWidget___addActions_actions_newList(ptr.Pointer())
}

func (ptr *QGraphicsWidget) __insertActions_actions_atList(i int) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QGraphicsWidget___insertActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) __insertActions_actions_setList(i QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget___insertActions_actions_setList(ptr.Pointer(), PointerFromQAction(i))
	}
}

func (ptr *QGraphicsWidget) __insertActions_actions_newList() unsafe.Pointer {
	return C.QGraphicsWidget___insertActions_actions_newList(ptr.Pointer())
}

func (ptr *QGraphicsWidget) __actions_atList(i int) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QGraphicsWidget___actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QGraphicsWidget) __actions_setList(i QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QGraphicsWidget___actions_setList(ptr.Pointer(), PointerFromQAction(i))
	}
}

func (ptr *QGraphicsWidget) __actions_newList() unsafe.Pointer {
	return C.QGraphicsWidget___actions_newList(ptr.Pointer())
}

type QGridLayout struct {
	QLayout
}

type QGridLayout_ITF interface {
	QLayout_ITF
	QGridLayout_PTR() *QGridLayout
}

func (ptr *QGridLayout) QGridLayout_PTR() *QGridLayout {
	return ptr
}

func (ptr *QGridLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QLayout_PTR().Pointer()
	}
	return nil
}

func (ptr *QGridLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QLayout_PTR().SetPointer(p)
	}
}

func PointerFromQGridLayout(ptr QGridLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGridLayout_PTR().Pointer()
	}
	return nil
}

func NewQGridLayoutFromPointer(ptr unsafe.Pointer) (n *QGridLayout) {
	n = new(QGridLayout)
	n.SetPointer(ptr)
	return
}
func NewQGridLayout2() *QGridLayout {
	tmpValue := NewQGridLayoutFromPointer(C.QGridLayout_NewQGridLayout2())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQGridLayout(parent QWidget_ITF) *QGridLayout {
	tmpValue := NewQGridLayoutFromPointer(C.QGridLayout_NewQGridLayout(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQGridLayout_TakeAt
func callbackQGridLayout_TakeAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "takeAt"); signal != nil {
		return PointerFromQLayoutItem((*(*func(int) *QLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQLayoutItem(NewQGridLayoutFromPointer(ptr).TakeAtDefault(int(int32(index))))
}

func (ptr *QGridLayout) ConnectTakeAt(f func(index int) *QLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "takeAt"); signal != nil {
			f := func(index int) *QLayoutItem {
				(*(*func(int) *QLayoutItem)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "takeAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "takeAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGridLayout) DisconnectTakeAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "takeAt")
	}
}

func (ptr *QGridLayout) TakeAt(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QGridLayout_TakeAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QGridLayout) TakeAtDefault(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QGridLayout_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

//export callbackQGridLayout_AddItem2
func callbackQGridLayout_AddItem2(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "addItem2"); signal != nil {
		(*(*func(*QLayoutItem))(signal))(NewQLayoutItemFromPointer(item))
	} else {
		NewQGridLayoutFromPointer(ptr).AddItem2Default(NewQLayoutItemFromPointer(item))
	}
}

func (ptr *QGridLayout) ConnectAddItem2(f func(item *QLayoutItem)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "addItem2"); signal != nil {
			f := func(item *QLayoutItem) {
				(*(*func(*QLayoutItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "addItem2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "addItem2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGridLayout) DisconnectAddItem2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "addItem2")
	}
}

func (ptr *QGridLayout) AddItem2(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGridLayout_AddItem2(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

func (ptr *QGridLayout) AddItem2Default(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QGridLayout_AddItem2Default(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

func (ptr *QGridLayout) AddItem(item QLayoutItem_ITF, row int, column int, rowSpan int, columnSpan int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGridLayout_AddItem(ptr.Pointer(), PointerFromQLayoutItem(item), C.int(int32(row)), C.int(int32(column)), C.int(int32(rowSpan)), C.int(int32(columnSpan)), C.longlong(alignment))
	}
}

func (ptr *QGridLayout) AddLayout(layout QLayout_ITF, row int, column int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGridLayout_AddLayout(ptr.Pointer(), PointerFromQLayout(layout), C.int(int32(row)), C.int(int32(column)), C.longlong(alignment))
	}
}

func (ptr *QGridLayout) AddLayout2(layout QLayout_ITF, row int, column int, rowSpan int, columnSpan int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGridLayout_AddLayout2(ptr.Pointer(), PointerFromQLayout(layout), C.int(int32(row)), C.int(int32(column)), C.int(int32(rowSpan)), C.int(int32(columnSpan)), C.longlong(alignment))
	}
}

func (ptr *QGridLayout) AddWidget3(widget QWidget_ITF, fromRow int, fromColumn int, rowSpan int, columnSpan int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGridLayout_AddWidget3(ptr.Pointer(), PointerFromQWidget(widget), C.int(int32(fromRow)), C.int(int32(fromColumn)), C.int(int32(rowSpan)), C.int(int32(columnSpan)), C.longlong(alignment))
	}
}

func (ptr *QGridLayout) AddWidget(widget QWidget_ITF, row int, column int, alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QGridLayout_AddWidget(ptr.Pointer(), PointerFromQWidget(widget), C.int(int32(row)), C.int(int32(column)), C.longlong(alignment))
	}
}

func (ptr *QGridLayout) SetColumnMinimumWidth(column int, minSize int) {
	if ptr.Pointer() != nil {
		C.QGridLayout_SetColumnMinimumWidth(ptr.Pointer(), C.int(int32(column)), C.int(int32(minSize)))
	}
}

func (ptr *QGridLayout) SetColumnStretch(column int, stretch int) {
	if ptr.Pointer() != nil {
		C.QGridLayout_SetColumnStretch(ptr.Pointer(), C.int(int32(column)), C.int(int32(stretch)))
	}
}

func (ptr *QGridLayout) SetHorizontalSpacing(spacing int) {
	if ptr.Pointer() != nil {
		C.QGridLayout_SetHorizontalSpacing(ptr.Pointer(), C.int(int32(spacing)))
	}
}

func (ptr *QGridLayout) SetOriginCorner(corner core.Qt__Corner) {
	if ptr.Pointer() != nil {
		C.QGridLayout_SetOriginCorner(ptr.Pointer(), C.longlong(corner))
	}
}

func (ptr *QGridLayout) SetRowMinimumHeight(row int, minSize int) {
	if ptr.Pointer() != nil {
		C.QGridLayout_SetRowMinimumHeight(ptr.Pointer(), C.int(int32(row)), C.int(int32(minSize)))
	}
}

func (ptr *QGridLayout) SetRowStretch(row int, stretch int) {
	if ptr.Pointer() != nil {
		C.QGridLayout_SetRowStretch(ptr.Pointer(), C.int(int32(row)), C.int(int32(stretch)))
	}
}

func (ptr *QGridLayout) SetVerticalSpacing(spacing int) {
	if ptr.Pointer() != nil {
		C.QGridLayout_SetVerticalSpacing(ptr.Pointer(), C.int(int32(spacing)))
	}
}

//export callbackQGridLayout_DestroyQGridLayout
func callbackQGridLayout_DestroyQGridLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGridLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGridLayoutFromPointer(ptr).DestroyQGridLayoutDefault()
	}
}

func (ptr *QGridLayout) ConnectDestroyQGridLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGridLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGridLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGridLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGridLayout) DisconnectDestroyQGridLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGridLayout")
	}
}

func (ptr *QGridLayout) DestroyQGridLayout() {
	if ptr.Pointer() != nil {
		C.QGridLayout_DestroyQGridLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGridLayout) DestroyQGridLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QGridLayout_DestroyQGridLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQGridLayout_ItemAt
func callbackQGridLayout_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemAt"); signal != nil {
		return PointerFromQLayoutItem((*(*func(int) *QLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQLayoutItem(NewQGridLayoutFromPointer(ptr).ItemAtDefault(int(int32(index))))
}

func (ptr *QGridLayout) ConnectItemAt(f func(index int) *QLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemAt"); signal != nil {
			f := func(index int) *QLayoutItem {
				(*(*func(int) *QLayoutItem)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGridLayout) DisconnectItemAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemAt")
	}
}

func (ptr *QGridLayout) ItemAt(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QGridLayout_ItemAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QGridLayout) ItemAtDefault(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QGridLayout_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QGridLayout) ItemAtPosition(row int, column int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QGridLayout_ItemAtPosition(ptr.Pointer(), C.int(int32(row)), C.int(int32(column))))
	}
	return nil
}

func (ptr *QGridLayout) CellRect(row int, column int) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QGridLayout_CellRect(ptr.Pointer(), C.int(int32(row)), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQGridLayout_SizeHint
func callbackQGridLayout_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQGridLayoutFromPointer(ptr).SizeHintDefault())
}

func (ptr *QGridLayout) ConnectSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGridLayout) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QGridLayout) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QGridLayout_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QGridLayout) SizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QGridLayout_SizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QGridLayout) OriginCorner() core.Qt__Corner {
	if ptr.Pointer() != nil {
		return core.Qt__Corner(C.QGridLayout_OriginCorner(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGridLayout) ColumnCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_ColumnCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGridLayout) ColumnMinimumWidth(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_ColumnMinimumWidth(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

func (ptr *QGridLayout) ColumnStretch(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_ColumnStretch(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

//export callbackQGridLayout_Count
func callbackQGridLayout_Count(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "count"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQGridLayoutFromPointer(ptr).CountDefault()))
}

func (ptr *QGridLayout) ConnectCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "count"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGridLayout) DisconnectCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "count")
	}
}

func (ptr *QGridLayout) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGridLayout) CountDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_CountDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGridLayout) HorizontalSpacing() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_HorizontalSpacing(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGridLayout) RowCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_RowCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGridLayout) RowMinimumHeight(row int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_RowMinimumHeight(ptr.Pointer(), C.int(int32(row)))))
	}
	return 0
}

func (ptr *QGridLayout) RowStretch(row int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_RowStretch(ptr.Pointer(), C.int(int32(row)))))
	}
	return 0
}

func (ptr *QGridLayout) VerticalSpacing() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QGridLayout_VerticalSpacing(ptr.Pointer())))
	}
	return 0
}

func (ptr *QGridLayout) GetItemPosition(index int, row int, column int, rowSpan int, columnSpan int) {
	if ptr.Pointer() != nil {
		C.QGridLayout_GetItemPosition(ptr.Pointer(), C.int(int32(index)), C.int(int32(row)), C.int(int32(column)), C.int(int32(rowSpan)), C.int(int32(columnSpan)))
	}
}

type QGroupBox struct {
	QWidget
}

type QGroupBox_ITF interface {
	QWidget_ITF
	QGroupBox_PTR() *QGroupBox
}

func (ptr *QGroupBox) QGroupBox_PTR() *QGroupBox {
	return ptr
}

func (ptr *QGroupBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QGroupBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQGroupBox(ptr QGroupBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGroupBox_PTR().Pointer()
	}
	return nil
}

func NewQGroupBoxFromPointer(ptr unsafe.Pointer) (n *QGroupBox) {
	n = new(QGroupBox)
	n.SetPointer(ptr)
	return
}
func NewQGroupBox(parent QWidget_ITF) *QGroupBox {
	tmpValue := NewQGroupBoxFromPointer(C.QGroupBox_NewQGroupBox(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQGroupBox2(title string, parent QWidget_ITF) *QGroupBox {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	tmpValue := NewQGroupBoxFromPointer(C.QGroupBox_NewQGroupBox2(C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQGroupBox_Clicked
func callbackQGroupBox_Clicked(ptr unsafe.Pointer, checked C.char) {
	if signal := qt.GetSignal(ptr, "clicked"); signal != nil {
		(*(*func(bool))(signal))(int8(checked) != 0)
	}

}

func (ptr *QGroupBox) ConnectClicked(f func(checked bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "clicked") {
			C.QGroupBox_ConnectClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "clicked"); signal != nil {
			f := func(checked bool) {
				(*(*func(bool))(signal))(checked)
				f(checked)
			}
			qt.ConnectSignal(ptr.Pointer(), "clicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGroupBox) DisconnectClicked() {
	if ptr.Pointer() != nil {
		C.QGroupBox_DisconnectClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "clicked")
	}
}

func (ptr *QGroupBox) Clicked(checked bool) {
	if ptr.Pointer() != nil {
		C.QGroupBox_Clicked(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(checked))))
	}
}

func (ptr *QGroupBox) SetAlignment(alignment int) {
	if ptr.Pointer() != nil {
		C.QGroupBox_SetAlignment(ptr.Pointer(), C.int(int32(alignment)))
	}
}

func (ptr *QGroupBox) SetCheckable(checkable bool) {
	if ptr.Pointer() != nil {
		C.QGroupBox_SetCheckable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(checkable))))
	}
}

//export callbackQGroupBox_SetChecked
func callbackQGroupBox_SetChecked(ptr unsafe.Pointer, checked C.char) {
	if signal := qt.GetSignal(ptr, "setChecked"); signal != nil {
		(*(*func(bool))(signal))(int8(checked) != 0)
	} else {
		NewQGroupBoxFromPointer(ptr).SetCheckedDefault(int8(checked) != 0)
	}
}

func (ptr *QGroupBox) ConnectSetChecked(f func(checked bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setChecked"); signal != nil {
			f := func(checked bool) {
				(*(*func(bool))(signal))(checked)
				f(checked)
			}
			qt.ConnectSignal(ptr.Pointer(), "setChecked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setChecked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGroupBox) DisconnectSetChecked() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setChecked")
	}
}

func (ptr *QGroupBox) SetChecked(checked bool) {
	if ptr.Pointer() != nil {
		C.QGroupBox_SetChecked(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(checked))))
	}
}

func (ptr *QGroupBox) SetCheckedDefault(checked bool) {
	if ptr.Pointer() != nil {
		C.QGroupBox_SetCheckedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(checked))))
	}
}

func (ptr *QGroupBox) SetFlat(flat bool) {
	if ptr.Pointer() != nil {
		C.QGroupBox_SetFlat(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(flat))))
	}
}

func (ptr *QGroupBox) SetTitle(title string) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		C.QGroupBox_SetTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
	}
}

//export callbackQGroupBox_Toggled
func callbackQGroupBox_Toggled(ptr unsafe.Pointer, on C.char) {
	if signal := qt.GetSignal(ptr, "toggled"); signal != nil {
		(*(*func(bool))(signal))(int8(on) != 0)
	}

}

func (ptr *QGroupBox) ConnectToggled(f func(on bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "toggled") {
			C.QGroupBox_ConnectToggled(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "toggled"); signal != nil {
			f := func(on bool) {
				(*(*func(bool))(signal))(on)
				f(on)
			}
			qt.ConnectSignal(ptr.Pointer(), "toggled", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "toggled", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGroupBox) DisconnectToggled() {
	if ptr.Pointer() != nil {
		C.QGroupBox_DisconnectToggled(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "toggled")
	}
}

func (ptr *QGroupBox) Toggled(on bool) {
	if ptr.Pointer() != nil {
		C.QGroupBox_Toggled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

//export callbackQGroupBox_DestroyQGroupBox
func callbackQGroupBox_DestroyQGroupBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QGroupBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQGroupBoxFromPointer(ptr).DestroyQGroupBoxDefault()
	}
}

func (ptr *QGroupBox) ConnectDestroyQGroupBox(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QGroupBox"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QGroupBox", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QGroupBox", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QGroupBox) DisconnectDestroyQGroupBox() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QGroupBox")
	}
}

func (ptr *QGroupBox) DestroyQGroupBox() {
	if ptr.Pointer() != nil {
		C.QGroupBox_DestroyQGroupBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGroupBox) DestroyQGroupBoxDefault() {
	if ptr.Pointer() != nil {
		C.QGroupBox_DestroyQGroupBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QGroupBox) Title() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QGroupBox_Title(ptr.Pointer()))
	}
	return ""
}

func (ptr *QGroupBox) Alignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QGroupBox_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGroupBox) IsCheckable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGroupBox_IsCheckable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGroupBox) IsChecked() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGroupBox_IsChecked(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGroupBox) IsFlat() bool {
	if ptr.Pointer() != nil {
		return int8(C.QGroupBox_IsFlat(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QGroupBox) InitStyleOption(option QStyleOptionGroupBox_ITF) {
	if ptr.Pointer() != nil {
		C.QGroupBox_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionGroupBox(option))
	}
}

type QHBoxLayout struct {
	QBoxLayout
}

type QHBoxLayout_ITF interface {
	QBoxLayout_ITF
	QHBoxLayout_PTR() *QHBoxLayout
}

func (ptr *QHBoxLayout) QHBoxLayout_PTR() *QHBoxLayout {
	return ptr
}

func (ptr *QHBoxLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QBoxLayout_PTR().Pointer()
	}
	return nil
}

func (ptr *QHBoxLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QBoxLayout_PTR().SetPointer(p)
	}
}

func PointerFromQHBoxLayout(ptr QHBoxLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHBoxLayout_PTR().Pointer()
	}
	return nil
}

func NewQHBoxLayoutFromPointer(ptr unsafe.Pointer) (n *QHBoxLayout) {
	n = new(QHBoxLayout)
	n.SetPointer(ptr)
	return
}
func NewQHBoxLayout() *QHBoxLayout {
	tmpValue := NewQHBoxLayoutFromPointer(C.QHBoxLayout_NewQHBoxLayout())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQHBoxLayout2(parent QWidget_ITF) *QHBoxLayout {
	tmpValue := NewQHBoxLayoutFromPointer(C.QHBoxLayout_NewQHBoxLayout2(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQHBoxLayout_DestroyQHBoxLayout
func callbackQHBoxLayout_DestroyQHBoxLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QHBoxLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQHBoxLayoutFromPointer(ptr).DestroyQHBoxLayoutDefault()
	}
}

func (ptr *QHBoxLayout) ConnectDestroyQHBoxLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QHBoxLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QHBoxLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QHBoxLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHBoxLayout) DisconnectDestroyQHBoxLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QHBoxLayout")
	}
}

func (ptr *QHBoxLayout) DestroyQHBoxLayout() {
	if ptr.Pointer() != nil {
		C.QHBoxLayout_DestroyQHBoxLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QHBoxLayout) DestroyQHBoxLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QHBoxLayout_DestroyQHBoxLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QHeaderView struct {
	QAbstractItemView
}

type QHeaderView_ITF interface {
	QAbstractItemView_ITF
	QHeaderView_PTR() *QHeaderView
}

func (ptr *QHeaderView) QHeaderView_PTR() *QHeaderView {
	return ptr
}

func (ptr *QHeaderView) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemView_PTR().Pointer()
	}
	return nil
}

func (ptr *QHeaderView) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractItemView_PTR().SetPointer(p)
	}
}

func PointerFromQHeaderView(ptr QHeaderView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHeaderView_PTR().Pointer()
	}
	return nil
}

func NewQHeaderViewFromPointer(ptr unsafe.Pointer) (n *QHeaderView) {
	n = new(QHeaderView)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QHeaderView__ResizeMode
//QHeaderView::ResizeMode
type QHeaderView__ResizeMode int64

const (
	QHeaderView__Interactive      QHeaderView__ResizeMode = QHeaderView__ResizeMode(0)
	QHeaderView__Stretch          QHeaderView__ResizeMode = QHeaderView__ResizeMode(1)
	QHeaderView__Fixed            QHeaderView__ResizeMode = QHeaderView__ResizeMode(2)
	QHeaderView__ResizeToContents QHeaderView__ResizeMode = QHeaderView__ResizeMode(3)
	QHeaderView__Custom           QHeaderView__ResizeMode = QHeaderView__ResizeMode(QHeaderView__Fixed)
)

func NewQHeaderView(orientation core.Qt__Orientation, parent QWidget_ITF) *QHeaderView {
	tmpValue := NewQHeaderViewFromPointer(C.QHeaderView_NewQHeaderView(C.longlong(orientation), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QHeaderView) RestoreState(state core.QByteArray_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_RestoreState(ptr.Pointer(), core.PointerFromQByteArray(state))) != 0
	}
	return false
}

//export callbackQHeaderView_CurrentChanged
func callbackQHeaderView_CurrentChanged(ptr unsafe.Pointer, current unsafe.Pointer, old unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(old))
	} else {
		NewQHeaderViewFromPointer(ptr).CurrentChangedDefault(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(old))
	}
}

func (ptr *QHeaderView) ConnectCurrentChanged(f func(current *core.QModelIndex, old *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(current *core.QModelIndex, old *core.QModelIndex) {
				(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(current, old)
				f(current, old)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QHeaderView) CurrentChanged(current core.QModelIndex_ITF, old core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QHeaderView_CurrentChanged(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(old))
	}
}

func (ptr *QHeaderView) CurrentChangedDefault(current core.QModelIndex_ITF, old core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QHeaderView_CurrentChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(old))
	}
}

//export callbackQHeaderView_GeometriesChanged
func callbackQHeaderView_GeometriesChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "geometriesChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QHeaderView) ConnectGeometriesChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "geometriesChanged") {
			C.QHeaderView_ConnectGeometriesChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "geometriesChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "geometriesChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "geometriesChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectGeometriesChanged() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectGeometriesChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "geometriesChanged")
	}
}

func (ptr *QHeaderView) GeometriesChanged() {
	if ptr.Pointer() != nil {
		C.QHeaderView_GeometriesChanged(ptr.Pointer())
	}
}

//export callbackQHeaderView_HeaderDataChanged
func callbackQHeaderView_HeaderDataChanged(ptr unsafe.Pointer, orientation C.longlong, logicalFirst C.int, logicalLast C.int) {
	if signal := qt.GetSignal(ptr, "headerDataChanged"); signal != nil {
		(*(*func(core.Qt__Orientation, int, int))(signal))(core.Qt__Orientation(orientation), int(int32(logicalFirst)), int(int32(logicalLast)))
	} else {
		NewQHeaderViewFromPointer(ptr).HeaderDataChangedDefault(core.Qt__Orientation(orientation), int(int32(logicalFirst)), int(int32(logicalLast)))
	}
}

func (ptr *QHeaderView) ConnectHeaderDataChanged(f func(orientation core.Qt__Orientation, logicalFirst int, logicalLast int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "headerDataChanged"); signal != nil {
			f := func(orientation core.Qt__Orientation, logicalFirst int, logicalLast int) {
				(*(*func(core.Qt__Orientation, int, int))(signal))(orientation, logicalFirst, logicalLast)
				f(orientation, logicalFirst, logicalLast)
			}
			qt.ConnectSignal(ptr.Pointer(), "headerDataChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "headerDataChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectHeaderDataChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "headerDataChanged")
	}
}

func (ptr *QHeaderView) HeaderDataChanged(orientation core.Qt__Orientation, logicalFirst int, logicalLast int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_HeaderDataChanged(ptr.Pointer(), C.longlong(orientation), C.int(int32(logicalFirst)), C.int(int32(logicalLast)))
	}
}

func (ptr *QHeaderView) HeaderDataChangedDefault(orientation core.Qt__Orientation, logicalFirst int, logicalLast int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_HeaderDataChangedDefault(ptr.Pointer(), C.longlong(orientation), C.int(int32(logicalFirst)), C.int(int32(logicalLast)))
	}
}

func (ptr *QHeaderView) HideSection(logicalIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_HideSection(ptr.Pointer(), C.int(int32(logicalIndex)))
	}
}

func (ptr *QHeaderView) MoveSection(from int, to int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_MoveSection(ptr.Pointer(), C.int(int32(from)), C.int(int32(to)))
	}
}

//export callbackQHeaderView_Reset
func callbackQHeaderView_Reset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "reset"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQHeaderViewFromPointer(ptr).ResetDefault()
	}
}

func (ptr *QHeaderView) ConnectReset(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "reset"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectReset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "reset")
	}
}

func (ptr *QHeaderView) Reset() {
	if ptr.Pointer() != nil {
		C.QHeaderView_Reset(ptr.Pointer())
	}
}

func (ptr *QHeaderView) ResetDefault() {
	if ptr.Pointer() != nil {
		C.QHeaderView_ResetDefault(ptr.Pointer())
	}
}

func (ptr *QHeaderView) ResetDefaultSectionSize() {
	if ptr.Pointer() != nil {
		C.QHeaderView_ResetDefaultSectionSize(ptr.Pointer())
	}
}

func (ptr *QHeaderView) ResizeSection(logicalIndex int, size int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_ResizeSection(ptr.Pointer(), C.int(int32(logicalIndex)), C.int(int32(size)))
	}
}

//export callbackQHeaderView_ResizeSections2
func callbackQHeaderView_ResizeSections2(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resizeSections2"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQHeaderViewFromPointer(ptr).ResizeSections2Default()
	}
}

func (ptr *QHeaderView) ConnectResizeSections2(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resizeSections2"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "resizeSections2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resizeSections2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectResizeSections2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resizeSections2")
	}
}

func (ptr *QHeaderView) ResizeSections2() {
	if ptr.Pointer() != nil {
		C.QHeaderView_ResizeSections2(ptr.Pointer())
	}
}

func (ptr *QHeaderView) ResizeSections2Default() {
	if ptr.Pointer() != nil {
		C.QHeaderView_ResizeSections2Default(ptr.Pointer())
	}
}

func (ptr *QHeaderView) ResizeSections(mode QHeaderView__ResizeMode) {
	if ptr.Pointer() != nil {
		C.QHeaderView_ResizeSections(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQHeaderView_SectionClicked
func callbackQHeaderView_SectionClicked(ptr unsafe.Pointer, logicalIndex C.int) {
	if signal := qt.GetSignal(ptr, "sectionClicked"); signal != nil {
		(*(*func(int))(signal))(int(int32(logicalIndex)))
	}

}

func (ptr *QHeaderView) ConnectSectionClicked(f func(logicalIndex int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sectionClicked") {
			C.QHeaderView_ConnectSectionClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sectionClicked"); signal != nil {
			f := func(logicalIndex int) {
				(*(*func(int))(signal))(logicalIndex)
				f(logicalIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionClicked() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectSectionClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sectionClicked")
	}
}

func (ptr *QHeaderView) SectionClicked(logicalIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionClicked(ptr.Pointer(), C.int(int32(logicalIndex)))
	}
}

//export callbackQHeaderView_SectionCountChanged
func callbackQHeaderView_SectionCountChanged(ptr unsafe.Pointer, oldCount C.int, newCount C.int) {
	if signal := qt.GetSignal(ptr, "sectionCountChanged"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(oldCount)), int(int32(newCount)))
	}

}

func (ptr *QHeaderView) ConnectSectionCountChanged(f func(oldCount int, newCount int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sectionCountChanged") {
			C.QHeaderView_ConnectSectionCountChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sectionCountChanged"); signal != nil {
			f := func(oldCount int, newCount int) {
				(*(*func(int, int))(signal))(oldCount, newCount)
				f(oldCount, newCount)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionCountChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionCountChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionCountChanged() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectSectionCountChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sectionCountChanged")
	}
}

func (ptr *QHeaderView) SectionCountChanged(oldCount int, newCount int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionCountChanged(ptr.Pointer(), C.int(int32(oldCount)), C.int(int32(newCount)))
	}
}

//export callbackQHeaderView_SectionDoubleClicked
func callbackQHeaderView_SectionDoubleClicked(ptr unsafe.Pointer, logicalIndex C.int) {
	if signal := qt.GetSignal(ptr, "sectionDoubleClicked"); signal != nil {
		(*(*func(int))(signal))(int(int32(logicalIndex)))
	}

}

func (ptr *QHeaderView) ConnectSectionDoubleClicked(f func(logicalIndex int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sectionDoubleClicked") {
			C.QHeaderView_ConnectSectionDoubleClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sectionDoubleClicked"); signal != nil {
			f := func(logicalIndex int) {
				(*(*func(int))(signal))(logicalIndex)
				f(logicalIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionDoubleClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionDoubleClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionDoubleClicked() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectSectionDoubleClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sectionDoubleClicked")
	}
}

func (ptr *QHeaderView) SectionDoubleClicked(logicalIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionDoubleClicked(ptr.Pointer(), C.int(int32(logicalIndex)))
	}
}

//export callbackQHeaderView_SectionEntered
func callbackQHeaderView_SectionEntered(ptr unsafe.Pointer, logicalIndex C.int) {
	if signal := qt.GetSignal(ptr, "sectionEntered"); signal != nil {
		(*(*func(int))(signal))(int(int32(logicalIndex)))
	}

}

func (ptr *QHeaderView) ConnectSectionEntered(f func(logicalIndex int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sectionEntered") {
			C.QHeaderView_ConnectSectionEntered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sectionEntered"); signal != nil {
			f := func(logicalIndex int) {
				(*(*func(int))(signal))(logicalIndex)
				f(logicalIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionEntered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionEntered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionEntered() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectSectionEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sectionEntered")
	}
}

func (ptr *QHeaderView) SectionEntered(logicalIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionEntered(ptr.Pointer(), C.int(int32(logicalIndex)))
	}
}

//export callbackQHeaderView_SectionHandleDoubleClicked
func callbackQHeaderView_SectionHandleDoubleClicked(ptr unsafe.Pointer, logicalIndex C.int) {
	if signal := qt.GetSignal(ptr, "sectionHandleDoubleClicked"); signal != nil {
		(*(*func(int))(signal))(int(int32(logicalIndex)))
	}

}

func (ptr *QHeaderView) ConnectSectionHandleDoubleClicked(f func(logicalIndex int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sectionHandleDoubleClicked") {
			C.QHeaderView_ConnectSectionHandleDoubleClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sectionHandleDoubleClicked"); signal != nil {
			f := func(logicalIndex int) {
				(*(*func(int))(signal))(logicalIndex)
				f(logicalIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionHandleDoubleClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionHandleDoubleClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionHandleDoubleClicked() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectSectionHandleDoubleClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sectionHandleDoubleClicked")
	}
}

func (ptr *QHeaderView) SectionHandleDoubleClicked(logicalIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionHandleDoubleClicked(ptr.Pointer(), C.int(int32(logicalIndex)))
	}
}

//export callbackQHeaderView_SectionMoved
func callbackQHeaderView_SectionMoved(ptr unsafe.Pointer, logicalIndex C.int, oldVisualIndex C.int, newVisualIndex C.int) {
	if signal := qt.GetSignal(ptr, "sectionMoved"); signal != nil {
		(*(*func(int, int, int))(signal))(int(int32(logicalIndex)), int(int32(oldVisualIndex)), int(int32(newVisualIndex)))
	}

}

func (ptr *QHeaderView) ConnectSectionMoved(f func(logicalIndex int, oldVisualIndex int, newVisualIndex int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sectionMoved") {
			C.QHeaderView_ConnectSectionMoved(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sectionMoved"); signal != nil {
			f := func(logicalIndex int, oldVisualIndex int, newVisualIndex int) {
				(*(*func(int, int, int))(signal))(logicalIndex, oldVisualIndex, newVisualIndex)
				f(logicalIndex, oldVisualIndex, newVisualIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionMoved() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectSectionMoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sectionMoved")
	}
}

func (ptr *QHeaderView) SectionMoved(logicalIndex int, oldVisualIndex int, newVisualIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionMoved(ptr.Pointer(), C.int(int32(logicalIndex)), C.int(int32(oldVisualIndex)), C.int(int32(newVisualIndex)))
	}
}

//export callbackQHeaderView_SectionPressed
func callbackQHeaderView_SectionPressed(ptr unsafe.Pointer, logicalIndex C.int) {
	if signal := qt.GetSignal(ptr, "sectionPressed"); signal != nil {
		(*(*func(int))(signal))(int(int32(logicalIndex)))
	}

}

func (ptr *QHeaderView) ConnectSectionPressed(f func(logicalIndex int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sectionPressed") {
			C.QHeaderView_ConnectSectionPressed(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sectionPressed"); signal != nil {
			f := func(logicalIndex int) {
				(*(*func(int))(signal))(logicalIndex)
				f(logicalIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionPressed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionPressed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionPressed() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectSectionPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sectionPressed")
	}
}

func (ptr *QHeaderView) SectionPressed(logicalIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionPressed(ptr.Pointer(), C.int(int32(logicalIndex)))
	}
}

//export callbackQHeaderView_SectionResized
func callbackQHeaderView_SectionResized(ptr unsafe.Pointer, logicalIndex C.int, oldSize C.int, newSize C.int) {
	if signal := qt.GetSignal(ptr, "sectionResized"); signal != nil {
		(*(*func(int, int, int))(signal))(int(int32(logicalIndex)), int(int32(oldSize)), int(int32(newSize)))
	}

}

func (ptr *QHeaderView) ConnectSectionResized(f func(logicalIndex int, oldSize int, newSize int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sectionResized") {
			C.QHeaderView_ConnectSectionResized(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sectionResized"); signal != nil {
			f := func(logicalIndex int, oldSize int, newSize int) {
				(*(*func(int, int, int))(signal))(logicalIndex, oldSize, newSize)
				f(logicalIndex, oldSize, newSize)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionResized", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionResized", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionResized() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectSectionResized(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sectionResized")
	}
}

func (ptr *QHeaderView) SectionResized(logicalIndex int, oldSize int, newSize int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionResized(ptr.Pointer(), C.int(int32(logicalIndex)), C.int(int32(oldSize)), C.int(int32(newSize)))
	}
}

//export callbackQHeaderView_SectionsAboutToBeRemoved
func callbackQHeaderView_SectionsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, logicalFirst C.int, logicalLast C.int) {
	if signal := qt.GetSignal(ptr, "sectionsAboutToBeRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(logicalFirst)), int(int32(logicalLast)))
	} else {
		NewQHeaderViewFromPointer(ptr).SectionsAboutToBeRemovedDefault(core.NewQModelIndexFromPointer(parent), int(int32(logicalFirst)), int(int32(logicalLast)))
	}
}

func (ptr *QHeaderView) ConnectSectionsAboutToBeRemoved(f func(parent *core.QModelIndex, logicalFirst int, logicalLast int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sectionsAboutToBeRemoved"); signal != nil {
			f := func(parent *core.QModelIndex, logicalFirst int, logicalLast int) {
				(*(*func(*core.QModelIndex, int, int))(signal))(parent, logicalFirst, logicalLast)
				f(parent, logicalFirst, logicalLast)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionsAboutToBeRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionsAboutToBeRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionsAboutToBeRemoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sectionsAboutToBeRemoved")
	}
}

func (ptr *QHeaderView) SectionsAboutToBeRemoved(parent core.QModelIndex_ITF, logicalFirst int, logicalLast int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionsAboutToBeRemoved(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(logicalFirst)), C.int(int32(logicalLast)))
	}
}

func (ptr *QHeaderView) SectionsAboutToBeRemovedDefault(parent core.QModelIndex_ITF, logicalFirst int, logicalLast int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionsAboutToBeRemovedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(logicalFirst)), C.int(int32(logicalLast)))
	}
}

//export callbackQHeaderView_SectionsInserted
func callbackQHeaderView_SectionsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, logicalFirst C.int, logicalLast C.int) {
	if signal := qt.GetSignal(ptr, "sectionsInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(logicalFirst)), int(int32(logicalLast)))
	} else {
		NewQHeaderViewFromPointer(ptr).SectionsInsertedDefault(core.NewQModelIndexFromPointer(parent), int(int32(logicalFirst)), int(int32(logicalLast)))
	}
}

func (ptr *QHeaderView) ConnectSectionsInserted(f func(parent *core.QModelIndex, logicalFirst int, logicalLast int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sectionsInserted"); signal != nil {
			f := func(parent *core.QModelIndex, logicalFirst int, logicalLast int) {
				(*(*func(*core.QModelIndex, int, int))(signal))(parent, logicalFirst, logicalLast)
				f(parent, logicalFirst, logicalLast)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionsInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionsInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionsInserted() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sectionsInserted")
	}
}

func (ptr *QHeaderView) SectionsInserted(parent core.QModelIndex_ITF, logicalFirst int, logicalLast int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionsInserted(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(logicalFirst)), C.int(int32(logicalLast)))
	}
}

func (ptr *QHeaderView) SectionsInsertedDefault(parent core.QModelIndex_ITF, logicalFirst int, logicalLast int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SectionsInsertedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(logicalFirst)), C.int(int32(logicalLast)))
	}
}

func (ptr *QHeaderView) SetCascadingSectionResizes(enable bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetCascadingSectionResizes(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QHeaderView) SetDefaultAlignment(alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetDefaultAlignment(ptr.Pointer(), C.longlong(alignment))
	}
}

func (ptr *QHeaderView) SetDefaultSectionSize(size int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetDefaultSectionSize(ptr.Pointer(), C.int(int32(size)))
	}
}

func (ptr *QHeaderView) SetFirstSectionMovable(movable bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetFirstSectionMovable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(movable))))
	}
}

func (ptr *QHeaderView) SetHighlightSections(highlight bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetHighlightSections(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(highlight))))
	}
}

func (ptr *QHeaderView) SetMaximumSectionSize(size int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetMaximumSectionSize(ptr.Pointer(), C.int(int32(size)))
	}
}

func (ptr *QHeaderView) SetMinimumSectionSize(size int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetMinimumSectionSize(ptr.Pointer(), C.int(int32(size)))
	}
}

//export callbackQHeaderView_SetOffset
func callbackQHeaderView_SetOffset(ptr unsafe.Pointer, offset C.int) {
	if signal := qt.GetSignal(ptr, "setOffset"); signal != nil {
		(*(*func(int))(signal))(int(int32(offset)))
	} else {
		NewQHeaderViewFromPointer(ptr).SetOffsetDefault(int(int32(offset)))
	}
}

func (ptr *QHeaderView) ConnectSetOffset(f func(offset int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOffset"); signal != nil {
			f := func(offset int) {
				(*(*func(int))(signal))(offset)
				f(offset)
			}
			qt.ConnectSignal(ptr.Pointer(), "setOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSetOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOffset")
	}
}

func (ptr *QHeaderView) SetOffset(offset int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetOffset(ptr.Pointer(), C.int(int32(offset)))
	}
}

func (ptr *QHeaderView) SetOffsetDefault(offset int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetOffsetDefault(ptr.Pointer(), C.int(int32(offset)))
	}
}

//export callbackQHeaderView_SetOffsetToLastSection
func callbackQHeaderView_SetOffsetToLastSection(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setOffsetToLastSection"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQHeaderViewFromPointer(ptr).SetOffsetToLastSectionDefault()
	}
}

func (ptr *QHeaderView) ConnectSetOffsetToLastSection(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOffsetToLastSection"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "setOffsetToLastSection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOffsetToLastSection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSetOffsetToLastSection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOffsetToLastSection")
	}
}

func (ptr *QHeaderView) SetOffsetToLastSection() {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetOffsetToLastSection(ptr.Pointer())
	}
}

func (ptr *QHeaderView) SetOffsetToLastSectionDefault() {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetOffsetToLastSectionDefault(ptr.Pointer())
	}
}

//export callbackQHeaderView_SetOffsetToSectionPosition
func callbackQHeaderView_SetOffsetToSectionPosition(ptr unsafe.Pointer, visualSectionNumber C.int) {
	if signal := qt.GetSignal(ptr, "setOffsetToSectionPosition"); signal != nil {
		(*(*func(int))(signal))(int(int32(visualSectionNumber)))
	} else {
		NewQHeaderViewFromPointer(ptr).SetOffsetToSectionPositionDefault(int(int32(visualSectionNumber)))
	}
}

func (ptr *QHeaderView) ConnectSetOffsetToSectionPosition(f func(visualSectionNumber int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOffsetToSectionPosition"); signal != nil {
			f := func(visualSectionNumber int) {
				(*(*func(int))(signal))(visualSectionNumber)
				f(visualSectionNumber)
			}
			qt.ConnectSignal(ptr.Pointer(), "setOffsetToSectionPosition", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOffsetToSectionPosition", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSetOffsetToSectionPosition() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOffsetToSectionPosition")
	}
}

func (ptr *QHeaderView) SetOffsetToSectionPosition(visualSectionNumber int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetOffsetToSectionPosition(ptr.Pointer(), C.int(int32(visualSectionNumber)))
	}
}

func (ptr *QHeaderView) SetOffsetToSectionPositionDefault(visualSectionNumber int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetOffsetToSectionPositionDefault(ptr.Pointer(), C.int(int32(visualSectionNumber)))
	}
}

func (ptr *QHeaderView) SetResizeContentsPrecision(precision int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetResizeContentsPrecision(ptr.Pointer(), C.int(int32(precision)))
	}
}

func (ptr *QHeaderView) SetSectionHidden(logicalIndex int, hide bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetSectionHidden(ptr.Pointer(), C.int(int32(logicalIndex)), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

func (ptr *QHeaderView) SetSectionResizeMode(mode QHeaderView__ResizeMode) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetSectionResizeMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QHeaderView) SetSectionResizeMode2(logicalIndex int, mode QHeaderView__ResizeMode) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetSectionResizeMode2(ptr.Pointer(), C.int(int32(logicalIndex)), C.longlong(mode))
	}
}

func (ptr *QHeaderView) SetSectionsClickable(clickable bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetSectionsClickable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(clickable))))
	}
}

func (ptr *QHeaderView) SetSectionsMovable(movable bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetSectionsMovable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(movable))))
	}
}

//export callbackQHeaderView_SetSelection
func callbackQHeaderView_SetSelection(ptr unsafe.Pointer, rect unsafe.Pointer, flags C.longlong) {
	if signal := qt.GetSignal(ptr, "setSelection"); signal != nil {
		(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(flags))
	} else {
		NewQHeaderViewFromPointer(ptr).SetSelectionDefault(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(flags))
	}
}

func (ptr *QHeaderView) ConnectSetSelection(f func(rect *core.QRect, flags core.QItemSelectionModel__SelectionFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setSelection"); signal != nil {
			f := func(rect *core.QRect, flags core.QItemSelectionModel__SelectionFlag) {
				(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(rect, flags)
				f(rect, flags)
			}
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSetSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setSelection")
	}
}

func (ptr *QHeaderView) SetSelection(rect core.QRect_ITF, flags core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetSelection(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(flags))
	}
}

func (ptr *QHeaderView) SetSelectionDefault(rect core.QRect_ITF, flags core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetSelectionDefault(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(flags))
	}
}

func (ptr *QHeaderView) SetSortIndicator(logicalIndex int, order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetSortIndicator(ptr.Pointer(), C.int(int32(logicalIndex)), C.longlong(order))
	}
}

func (ptr *QHeaderView) SetSortIndicatorShown(show bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetSortIndicatorShown(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(show))))
	}
}

func (ptr *QHeaderView) SetStretchLastSection(stretch bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetStretchLastSection(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(stretch))))
	}
}

//export callbackQHeaderView_SetVisible
func callbackQHeaderView_SetVisible(ptr unsafe.Pointer, v C.char) {
	if signal := qt.GetSignal(ptr, "setVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(v) != 0)
	} else {
		NewQHeaderViewFromPointer(ptr).SetVisibleDefault(int8(v) != 0)
	}
}

func (ptr *QHeaderView) ConnectSetVisible(f func(v bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setVisible"); signal != nil {
			f := func(v bool) {
				(*(*func(bool))(signal))(v)
				f(v)
			}
			qt.ConnectSignal(ptr.Pointer(), "setVisible", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setVisible", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSetVisible() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setVisible")
	}
}

func (ptr *QHeaderView) SetVisible(v bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(v))))
	}
}

func (ptr *QHeaderView) SetVisibleDefault(v bool) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(v))))
	}
}

func (ptr *QHeaderView) ShowSection(logicalIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_ShowSection(ptr.Pointer(), C.int(int32(logicalIndex)))
	}
}

//export callbackQHeaderView_SortIndicatorChanged
func callbackQHeaderView_SortIndicatorChanged(ptr unsafe.Pointer, logicalIndex C.int, order C.longlong) {
	if signal := qt.GetSignal(ptr, "sortIndicatorChanged"); signal != nil {
		(*(*func(int, core.Qt__SortOrder))(signal))(int(int32(logicalIndex)), core.Qt__SortOrder(order))
	}

}

func (ptr *QHeaderView) ConnectSortIndicatorChanged(f func(logicalIndex int, order core.Qt__SortOrder)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sortIndicatorChanged") {
			C.QHeaderView_ConnectSortIndicatorChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sortIndicatorChanged"); signal != nil {
			f := func(logicalIndex int, order core.Qt__SortOrder) {
				(*(*func(int, core.Qt__SortOrder))(signal))(logicalIndex, order)
				f(logicalIndex, order)
			}
			qt.ConnectSignal(ptr.Pointer(), "sortIndicatorChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sortIndicatorChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSortIndicatorChanged() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DisconnectSortIndicatorChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sortIndicatorChanged")
	}
}

func (ptr *QHeaderView) SortIndicatorChanged(logicalIndex int, order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SortIndicatorChanged(ptr.Pointer(), C.int(int32(logicalIndex)), C.longlong(order))
	}
}

func (ptr *QHeaderView) SwapSections(first int, second int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_SwapSections(ptr.Pointer(), C.int(int32(first)), C.int(int32(second)))
	}
}

//export callbackQHeaderView_DestroyQHeaderView
func callbackQHeaderView_DestroyQHeaderView(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QHeaderView"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQHeaderViewFromPointer(ptr).DestroyQHeaderViewDefault()
	}
}

func (ptr *QHeaderView) ConnectDestroyQHeaderView(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QHeaderView"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QHeaderView", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QHeaderView", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectDestroyQHeaderView() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QHeaderView")
	}
}

func (ptr *QHeaderView) DestroyQHeaderView() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DestroyQHeaderView(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QHeaderView) DestroyQHeaderViewDefault() {
	if ptr.Pointer() != nil {
		C.QHeaderView_DestroyQHeaderViewDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QHeaderView) SaveState() *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QHeaderView_SaveState(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QHeaderView) SectionResizeMode(logicalIndex int) QHeaderView__ResizeMode {
	if ptr.Pointer() != nil {
		return QHeaderView__ResizeMode(C.QHeaderView_SectionResizeMode(ptr.Pointer(), C.int(int32(logicalIndex))))
	}
	return 0
}

//export callbackQHeaderView_SectionSizeFromContents
func callbackQHeaderView_SectionSizeFromContents(ptr unsafe.Pointer, logicalIndex C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sectionSizeFromContents"); signal != nil {
		return core.PointerFromQSize((*(*func(int) *core.QSize)(signal))(int(int32(logicalIndex))))
	}

	return core.PointerFromQSize(NewQHeaderViewFromPointer(ptr).SectionSizeFromContentsDefault(int(int32(logicalIndex))))
}

func (ptr *QHeaderView) ConnectSectionSizeFromContents(f func(logicalIndex int) *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sectionSizeFromContents"); signal != nil {
			f := func(logicalIndex int) *core.QSize {
				(*(*func(int) *core.QSize)(signal))(logicalIndex)
				return f(logicalIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "sectionSizeFromContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sectionSizeFromContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectSectionSizeFromContents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sectionSizeFromContents")
	}
}

func (ptr *QHeaderView) SectionSizeFromContents(logicalIndex int) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QHeaderView_SectionSizeFromContents(ptr.Pointer(), C.int(int32(logicalIndex))))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QHeaderView) SectionSizeFromContentsDefault(logicalIndex int) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QHeaderView_SectionSizeFromContentsDefault(ptr.Pointer(), C.int(int32(logicalIndex))))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QHeaderView) DefaultAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QHeaderView_DefaultAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QHeaderView) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QHeaderView_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QHeaderView) SortIndicatorOrder() core.Qt__SortOrder {
	if ptr.Pointer() != nil {
		return core.Qt__SortOrder(C.QHeaderView_SortIndicatorOrder(ptr.Pointer()))
	}
	return 0
}

func (ptr *QHeaderView) CascadingSectionResizes() bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_CascadingSectionResizes(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QHeaderView) HighlightSections() bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_HighlightSections(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QHeaderView) IsFirstSectionMovable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_IsFirstSectionMovable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QHeaderView) IsSectionHidden(logicalIndex int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_IsSectionHidden(ptr.Pointer(), C.int(int32(logicalIndex)))) != 0
	}
	return false
}

func (ptr *QHeaderView) IsSortIndicatorShown() bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_IsSortIndicatorShown(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QHeaderView) SectionsClickable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_SectionsClickable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QHeaderView) SectionsHidden() bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_SectionsHidden(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QHeaderView) SectionsMovable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_SectionsMovable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QHeaderView) SectionsMoved() bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_SectionsMoved(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QHeaderView) StretchLastSection() bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_StretchLastSection(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QHeaderView) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) DefaultSectionSize() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_DefaultSectionSize(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) HiddenSectionCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_HiddenSectionCount(ptr.Pointer())))
	}
	return 0
}

//export callbackQHeaderView_HorizontalOffset
func callbackQHeaderView_HorizontalOffset(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "horizontalOffset"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQHeaderViewFromPointer(ptr).HorizontalOffsetDefault()))
}

func (ptr *QHeaderView) ConnectHorizontalOffset(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "horizontalOffset"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "horizontalOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "horizontalOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectHorizontalOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "horizontalOffset")
	}
}

func (ptr *QHeaderView) HorizontalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_HorizontalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) HorizontalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_HorizontalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) Length() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_Length(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) LogicalIndex(visualIndex int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_LogicalIndex(ptr.Pointer(), C.int(int32(visualIndex)))))
	}
	return 0
}

func (ptr *QHeaderView) LogicalIndexAt3(pos core.QPoint_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_LogicalIndexAt3(ptr.Pointer(), core.PointerFromQPoint(pos))))
	}
	return 0
}

func (ptr *QHeaderView) LogicalIndexAt(position int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_LogicalIndexAt(ptr.Pointer(), C.int(int32(position)))))
	}
	return 0
}

func (ptr *QHeaderView) LogicalIndexAt2(x int, y int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_LogicalIndexAt2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)))))
	}
	return 0
}

func (ptr *QHeaderView) MaximumSectionSize() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_MaximumSectionSize(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) MinimumSectionSize() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_MinimumSectionSize(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) Offset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_Offset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) ResizeContentsPrecision() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_ResizeContentsPrecision(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) SectionPosition(logicalIndex int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_SectionPosition(ptr.Pointer(), C.int(int32(logicalIndex)))))
	}
	return 0
}

func (ptr *QHeaderView) SectionSize(logicalIndex int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_SectionSize(ptr.Pointer(), C.int(int32(logicalIndex)))))
	}
	return 0
}

func (ptr *QHeaderView) SectionSizeHint(logicalIndex int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_SectionSizeHint(ptr.Pointer(), C.int(int32(logicalIndex)))))
	}
	return 0
}

func (ptr *QHeaderView) SectionViewportPosition(logicalIndex int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_SectionViewportPosition(ptr.Pointer(), C.int(int32(logicalIndex)))))
	}
	return 0
}

func (ptr *QHeaderView) SortIndicatorSection() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_SortIndicatorSection(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) StretchSectionCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_StretchSectionCount(ptr.Pointer())))
	}
	return 0
}

//export callbackQHeaderView_VerticalOffset
func callbackQHeaderView_VerticalOffset(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "verticalOffset"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQHeaderViewFromPointer(ptr).VerticalOffsetDefault()))
}

func (ptr *QHeaderView) ConnectVerticalOffset(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "verticalOffset"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "verticalOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "verticalOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectVerticalOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "verticalOffset")
	}
}

func (ptr *QHeaderView) VerticalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_VerticalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) VerticalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_VerticalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QHeaderView) VisualIndex(logicalIndex int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_VisualIndex(ptr.Pointer(), C.int(int32(logicalIndex)))))
	}
	return 0
}

func (ptr *QHeaderView) VisualIndexAt(position int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QHeaderView_VisualIndexAt(ptr.Pointer(), C.int(int32(position)))))
	}
	return 0
}

func (ptr *QHeaderView) InitStyleOption(option QStyleOptionHeader_ITF) {
	if ptr.Pointer() != nil {
		C.QHeaderView_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionHeader(option))
	}
}

//export callbackQHeaderView_PaintSection
func callbackQHeaderView_PaintSection(ptr unsafe.Pointer, painter unsafe.Pointer, rect unsafe.Pointer, logicalIndex C.int) {
	if signal := qt.GetSignal(ptr, "paintSection"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRect, int))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rect), int(int32(logicalIndex)))
	} else {
		NewQHeaderViewFromPointer(ptr).PaintSectionDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rect), int(int32(logicalIndex)))
	}
}

func (ptr *QHeaderView) ConnectPaintSection(f func(painter *gui.QPainter, rect *core.QRect, logicalIndex int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paintSection"); signal != nil {
			f := func(painter *gui.QPainter, rect *core.QRect, logicalIndex int) {
				(*(*func(*gui.QPainter, *core.QRect, int))(signal))(painter, rect, logicalIndex)
				f(painter, rect, logicalIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "paintSection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paintSection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QHeaderView) DisconnectPaintSection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paintSection")
	}
}

func (ptr *QHeaderView) PaintSection(painter gui.QPainter_ITF, rect core.QRect_ITF, logicalIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_PaintSection(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rect), C.int(int32(logicalIndex)))
	}
}

func (ptr *QHeaderView) PaintSectionDefault(painter gui.QPainter_ITF, rect core.QRect_ITF, logicalIndex int) {
	if ptr.Pointer() != nil {
		C.QHeaderView_PaintSectionDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rect), C.int(int32(logicalIndex)))
	}
}

//export callbackQHeaderView_MoveCursor
func callbackQHeaderView_MoveCursor(ptr unsafe.Pointer, cursorAction C.longlong, modifiers C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "moveCursor"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
	}

	return core.PointerFromQModelIndex(NewQHeaderViewFromPointer(ptr).MoveCursorDefault(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
}

func (ptr *QHeaderView) MoveCursor(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QHeaderView_MoveCursor(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QHeaderView) MoveCursorDefault(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QHeaderView_MoveCursorDefault(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQHeaderView_ScrollTo
func callbackQHeaderView_ScrollTo(ptr unsafe.Pointer, index unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "scrollTo"); signal != nil {
		(*(*func(*core.QModelIndex, QAbstractItemView__ScrollHint))(signal))(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	} else {
		NewQHeaderViewFromPointer(ptr).ScrollToDefault(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	}
}

func (ptr *QHeaderView) ScrollTo(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QHeaderView_ScrollTo(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

func (ptr *QHeaderView) ScrollToDefault(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QHeaderView_ScrollToDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

//export callbackQHeaderView_IndexAt
func callbackQHeaderView_IndexAt(ptr unsafe.Pointer, point unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "indexAt"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QPoint) *core.QModelIndex)(signal))(core.NewQPointFromPointer(point)))
	}

	return core.PointerFromQModelIndex(NewQHeaderViewFromPointer(ptr).IndexAtDefault(core.NewQPointFromPointer(point)))
}

func (ptr *QHeaderView) IndexAt(point core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QHeaderView_IndexAt(ptr.Pointer(), core.PointerFromQPoint(point)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QHeaderView) IndexAtDefault(point core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QHeaderView_IndexAtDefault(ptr.Pointer(), core.PointerFromQPoint(point)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQHeaderView_VisualRect
func callbackQHeaderView_VisualRect(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRect"); signal != nil {
		return core.PointerFromQRect((*(*func(*core.QModelIndex) *core.QRect)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQRect(NewQHeaderViewFromPointer(ptr).VisualRectDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QHeaderView) VisualRect(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QHeaderView_VisualRect(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QHeaderView) VisualRectDefault(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QHeaderView_VisualRectDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQHeaderView_VisualRegionForSelection
func callbackQHeaderView_VisualRegionForSelection(ptr unsafe.Pointer, selection unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRegionForSelection"); signal != nil {
		return gui.PointerFromQRegion((*(*func(*core.QItemSelection) *gui.QRegion)(signal))(core.NewQItemSelectionFromPointer(selection)))
	}

	return gui.PointerFromQRegion(NewQHeaderViewFromPointer(ptr).VisualRegionForSelectionDefault(core.NewQItemSelectionFromPointer(selection)))
}

func (ptr *QHeaderView) VisualRegionForSelection(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QHeaderView_VisualRegionForSelection(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QHeaderView) VisualRegionForSelectionDefault(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QHeaderView_VisualRegionForSelectionDefault(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

//export callbackQHeaderView_IsIndexHidden
func callbackQHeaderView_IsIndexHidden(ptr unsafe.Pointer, index unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isIndexHidden"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex) bool)(signal))(core.NewQModelIndexFromPointer(index)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQHeaderViewFromPointer(ptr).IsIndexHiddenDefault(core.NewQModelIndexFromPointer(index)))))
}

func (ptr *QHeaderView) IsIndexHidden(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_IsIndexHidden(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QHeaderView) IsIndexHiddenDefault(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QHeaderView_IsIndexHiddenDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

type QInputDialog struct {
	QDialog
}

type QInputDialog_ITF interface {
	QDialog_ITF
	QInputDialog_PTR() *QInputDialog
}

func (ptr *QInputDialog) QInputDialog_PTR() *QInputDialog {
	return ptr
}

func (ptr *QInputDialog) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QDialog_PTR().Pointer()
	}
	return nil
}

func (ptr *QInputDialog) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QDialog_PTR().SetPointer(p)
	}
}

func PointerFromQInputDialog(ptr QInputDialog_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QInputDialog_PTR().Pointer()
	}
	return nil
}

func NewQInputDialogFromPointer(ptr unsafe.Pointer) (n *QInputDialog) {
	n = new(QInputDialog)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QInputDialog__InputDialogOption
//QInputDialog::InputDialogOption
type QInputDialog__InputDialogOption int64

const (
	QInputDialog__NoButtons                    QInputDialog__InputDialogOption = QInputDialog__InputDialogOption(0x00000001)
	QInputDialog__UseListViewForComboBoxItems  QInputDialog__InputDialogOption = QInputDialog__InputDialogOption(0x00000002)
	QInputDialog__UsePlainTextEditForTextInput QInputDialog__InputDialogOption = QInputDialog__InputDialogOption(0x00000004)
)

//go:generate stringer -type=QInputDialog__InputMode
//QInputDialog::InputMode
type QInputDialog__InputMode int64

const (
	QInputDialog__TextInput   QInputDialog__InputMode = QInputDialog__InputMode(0)
	QInputDialog__IntInput    QInputDialog__InputMode = QInputDialog__InputMode(1)
	QInputDialog__DoubleInput QInputDialog__InputMode = QInputDialog__InputMode(2)
)

func NewQInputDialog(parent QWidget_ITF, flags core.Qt__WindowType) *QInputDialog {
	tmpValue := NewQInputDialogFromPointer(C.QInputDialog_NewQInputDialog(PointerFromQWidget(parent), C.longlong(flags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QInputDialog_GetItem(parent QWidget_ITF, title string, label string, items []string, current int, editable bool, ok *bool, flags core.Qt__WindowType, inputMethodHints core.Qt__InputMethodHint) string {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	itemsC := C.CString(strings.Join(items, "|"))
	defer C.free(unsafe.Pointer(itemsC))
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return cGoUnpackString(C.QInputDialog_QInputDialog_GetItem(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.struct_QtWidgets_PackedString{data: itemsC, len: C.longlong(len(strings.Join(items, "|")))}, C.int(int32(current)), C.char(int8(qt.GoBoolToInt(editable))), &okC, C.longlong(flags), C.longlong(inputMethodHints)))
}

func (ptr *QInputDialog) GetItem(parent QWidget_ITF, title string, label string, items []string, current int, editable bool, ok *bool, flags core.Qt__WindowType, inputMethodHints core.Qt__InputMethodHint) string {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	itemsC := C.CString(strings.Join(items, "|"))
	defer C.free(unsafe.Pointer(itemsC))
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return cGoUnpackString(C.QInputDialog_QInputDialog_GetItem(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.struct_QtWidgets_PackedString{data: itemsC, len: C.longlong(len(strings.Join(items, "|")))}, C.int(int32(current)), C.char(int8(qt.GoBoolToInt(editable))), &okC, C.longlong(flags), C.longlong(inputMethodHints)))
}

func QInputDialog_GetMultiLineText(parent QWidget_ITF, title string, label string, text string, ok *bool, flags core.Qt__WindowType, inputMethodHints core.Qt__InputMethodHint) string {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return cGoUnpackString(C.QInputDialog_QInputDialog_GetMultiLineText(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, &okC, C.longlong(flags), C.longlong(inputMethodHints)))
}

func (ptr *QInputDialog) GetMultiLineText(parent QWidget_ITF, title string, label string, text string, ok *bool, flags core.Qt__WindowType, inputMethodHints core.Qt__InputMethodHint) string {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return cGoUnpackString(C.QInputDialog_QInputDialog_GetMultiLineText(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, &okC, C.longlong(flags), C.longlong(inputMethodHints)))
}

func QInputDialog_GetText(parent QWidget_ITF, title string, label string, mode QLineEdit__EchoMode, text string, ok *bool, flags core.Qt__WindowType, inputMethodHints core.Qt__InputMethodHint) string {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return cGoUnpackString(C.QInputDialog_QInputDialog_GetText(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.longlong(mode), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, &okC, C.longlong(flags), C.longlong(inputMethodHints)))
}

func (ptr *QInputDialog) GetText(parent QWidget_ITF, title string, label string, mode QLineEdit__EchoMode, text string, ok *bool, flags core.Qt__WindowType, inputMethodHints core.Qt__InputMethodHint) string {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return cGoUnpackString(C.QInputDialog_QInputDialog_GetText(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.longlong(mode), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, &okC, C.longlong(flags), C.longlong(inputMethodHints)))
}

func QInputDialog_GetDouble(parent QWidget_ITF, title string, label string, value float64, min float64, max float64, decimals int, ok *bool, flags core.Qt__WindowType) float64 {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return float64(C.QInputDialog_QInputDialog_GetDouble(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.double(value), C.double(min), C.double(max), C.int(int32(decimals)), &okC, C.longlong(flags)))
}

func (ptr *QInputDialog) GetDouble(parent QWidget_ITF, title string, label string, value float64, min float64, max float64, decimals int, ok *bool, flags core.Qt__WindowType) float64 {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return float64(C.QInputDialog_QInputDialog_GetDouble(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.double(value), C.double(min), C.double(max), C.int(int32(decimals)), &okC, C.longlong(flags)))
}

func QInputDialog_GetDouble2(parent QWidget_ITF, title string, label string, value float64, min float64, max float64, decimals int, ok *bool, flags core.Qt__WindowType, step float64) float64 {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return float64(C.QInputDialog_QInputDialog_GetDouble2(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.double(value), C.double(min), C.double(max), C.int(int32(decimals)), &okC, C.longlong(flags), C.double(step)))
}

func (ptr *QInputDialog) GetDouble2(parent QWidget_ITF, title string, label string, value float64, min float64, max float64, decimals int, ok *bool, flags core.Qt__WindowType, step float64) float64 {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return float64(C.QInputDialog_QInputDialog_GetDouble2(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.double(value), C.double(min), C.double(max), C.int(int32(decimals)), &okC, C.longlong(flags), C.double(step)))
}

func QInputDialog_GetInt(parent QWidget_ITF, title string, label string, value int, min int, max int, step int, ok *bool, flags core.Qt__WindowType) int {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return int(int32(C.QInputDialog_QInputDialog_GetInt(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.int(int32(value)), C.int(int32(min)), C.int(int32(max)), C.int(int32(step)), &okC, C.longlong(flags))))
}

func (ptr *QInputDialog) GetInt(parent QWidget_ITF, title string, label string, value int, min int, max int, step int, ok *bool, flags core.Qt__WindowType) int {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var labelC *C.char
	if label != "" {
		labelC = C.CString(label)
		defer C.free(unsafe.Pointer(labelC))
	}
	var okC C.char
	if ok != nil {
		okC = C.char(int8(qt.GoBoolToInt(*ok)))
		defer func() { *ok = int8(okC) != 0 }()
	}
	return int(int32(C.QInputDialog_QInputDialog_GetInt(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))}, C.int(int32(value)), C.int(int32(min)), C.int(int32(max)), C.int(int32(step)), &okC, C.longlong(flags))))
}

//export callbackQInputDialog_Done
func callbackQInputDialog_Done(ptr unsafe.Pointer, result C.int) {
	if signal := qt.GetSignal(ptr, "done"); signal != nil {
		(*(*func(int))(signal))(int(int32(result)))
	} else {
		NewQInputDialogFromPointer(ptr).DoneDefault(int(int32(result)))
	}
}

func (ptr *QInputDialog) ConnectDone(f func(result int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "done"); signal != nil {
			f := func(result int) {
				(*(*func(int))(signal))(result)
				f(result)
			}
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QInputDialog) DisconnectDone() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "done")
	}
}

func (ptr *QInputDialog) Done(result int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_Done(ptr.Pointer(), C.int(int32(result)))
	}
}

func (ptr *QInputDialog) DoneDefault(result int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_DoneDefault(ptr.Pointer(), C.int(int32(result)))
	}
}

//export callbackQInputDialog_DoubleValueChanged
func callbackQInputDialog_DoubleValueChanged(ptr unsafe.Pointer, value C.double) {
	if signal := qt.GetSignal(ptr, "doubleValueChanged"); signal != nil {
		(*(*func(float64))(signal))(float64(value))
	}

}

func (ptr *QInputDialog) ConnectDoubleValueChanged(f func(value float64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "doubleValueChanged") {
			C.QInputDialog_ConnectDoubleValueChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "doubleValueChanged"); signal != nil {
			f := func(value float64) {
				(*(*func(float64))(signal))(value)
				f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "doubleValueChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "doubleValueChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QInputDialog) DisconnectDoubleValueChanged() {
	if ptr.Pointer() != nil {
		C.QInputDialog_DisconnectDoubleValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "doubleValueChanged")
	}
}

func (ptr *QInputDialog) DoubleValueChanged(value float64) {
	if ptr.Pointer() != nil {
		C.QInputDialog_DoubleValueChanged(ptr.Pointer(), C.double(value))
	}
}

//export callbackQInputDialog_DoubleValueSelected
func callbackQInputDialog_DoubleValueSelected(ptr unsafe.Pointer, value C.double) {
	if signal := qt.GetSignal(ptr, "doubleValueSelected"); signal != nil {
		(*(*func(float64))(signal))(float64(value))
	}

}

func (ptr *QInputDialog) ConnectDoubleValueSelected(f func(value float64)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "doubleValueSelected") {
			C.QInputDialog_ConnectDoubleValueSelected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "doubleValueSelected"); signal != nil {
			f := func(value float64) {
				(*(*func(float64))(signal))(value)
				f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "doubleValueSelected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "doubleValueSelected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QInputDialog) DisconnectDoubleValueSelected() {
	if ptr.Pointer() != nil {
		C.QInputDialog_DisconnectDoubleValueSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "doubleValueSelected")
	}
}

func (ptr *QInputDialog) DoubleValueSelected(value float64) {
	if ptr.Pointer() != nil {
		C.QInputDialog_DoubleValueSelected(ptr.Pointer(), C.double(value))
	}
}

//export callbackQInputDialog_IntValueChanged
func callbackQInputDialog_IntValueChanged(ptr unsafe.Pointer, value C.int) {
	if signal := qt.GetSignal(ptr, "intValueChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(value)))
	}

}

func (ptr *QInputDialog) ConnectIntValueChanged(f func(value int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "intValueChanged") {
			C.QInputDialog_ConnectIntValueChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "intValueChanged"); signal != nil {
			f := func(value int) {
				(*(*func(int))(signal))(value)
				f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "intValueChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "intValueChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QInputDialog) DisconnectIntValueChanged() {
	if ptr.Pointer() != nil {
		C.QInputDialog_DisconnectIntValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "intValueChanged")
	}
}

func (ptr *QInputDialog) IntValueChanged(value int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_IntValueChanged(ptr.Pointer(), C.int(int32(value)))
	}
}

//export callbackQInputDialog_IntValueSelected
func callbackQInputDialog_IntValueSelected(ptr unsafe.Pointer, value C.int) {
	if signal := qt.GetSignal(ptr, "intValueSelected"); signal != nil {
		(*(*func(int))(signal))(int(int32(value)))
	}

}

func (ptr *QInputDialog) ConnectIntValueSelected(f func(value int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "intValueSelected") {
			C.QInputDialog_ConnectIntValueSelected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "intValueSelected"); signal != nil {
			f := func(value int) {
				(*(*func(int))(signal))(value)
				f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "intValueSelected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "intValueSelected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QInputDialog) DisconnectIntValueSelected() {
	if ptr.Pointer() != nil {
		C.QInputDialog_DisconnectIntValueSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "intValueSelected")
	}
}

func (ptr *QInputDialog) IntValueSelected(value int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_IntValueSelected(ptr.Pointer(), C.int(int32(value)))
	}
}

func (ptr *QInputDialog) Open(receiver core.QObject_ITF, member string) {
	if ptr.Pointer() != nil {
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		C.QInputDialog_Open(ptr.Pointer(), core.PointerFromQObject(receiver), memberC)
	}
}

func (ptr *QInputDialog) SetCancelButtonText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QInputDialog_SetCancelButtonText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QInputDialog) SetComboBoxEditable(editable bool) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetComboBoxEditable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(editable))))
	}
}

func (ptr *QInputDialog) SetComboBoxItems(items []string) {
	if ptr.Pointer() != nil {
		itemsC := C.CString(strings.Join(items, "|"))
		defer C.free(unsafe.Pointer(itemsC))
		C.QInputDialog_SetComboBoxItems(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: itemsC, len: C.longlong(len(strings.Join(items, "|")))})
	}
}

func (ptr *QInputDialog) SetDoubleDecimals(decimals int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetDoubleDecimals(ptr.Pointer(), C.int(int32(decimals)))
	}
}

func (ptr *QInputDialog) SetDoubleMaximum(max float64) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetDoubleMaximum(ptr.Pointer(), C.double(max))
	}
}

func (ptr *QInputDialog) SetDoubleMinimum(min float64) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetDoubleMinimum(ptr.Pointer(), C.double(min))
	}
}

func (ptr *QInputDialog) SetDoubleRange(min float64, max float64) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetDoubleRange(ptr.Pointer(), C.double(min), C.double(max))
	}
}

func (ptr *QInputDialog) SetDoubleStep(step float64) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetDoubleStep(ptr.Pointer(), C.double(step))
	}
}

func (ptr *QInputDialog) SetDoubleValue(value float64) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetDoubleValue(ptr.Pointer(), C.double(value))
	}
}

func (ptr *QInputDialog) SetInputMode(mode QInputDialog__InputMode) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetInputMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QInputDialog) SetIntMaximum(max int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetIntMaximum(ptr.Pointer(), C.int(int32(max)))
	}
}

func (ptr *QInputDialog) SetIntMinimum(min int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetIntMinimum(ptr.Pointer(), C.int(int32(min)))
	}
}

func (ptr *QInputDialog) SetIntRange(min int, max int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetIntRange(ptr.Pointer(), C.int(int32(min)), C.int(int32(max)))
	}
}

func (ptr *QInputDialog) SetIntStep(step int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetIntStep(ptr.Pointer(), C.int(int32(step)))
	}
}

func (ptr *QInputDialog) SetIntValue(value int) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetIntValue(ptr.Pointer(), C.int(int32(value)))
	}
}

func (ptr *QInputDialog) SetLabelText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QInputDialog_SetLabelText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QInputDialog) SetOkButtonText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QInputDialog_SetOkButtonText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QInputDialog) SetOption(option QInputDialog__InputDialogOption, on bool) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetOption(ptr.Pointer(), C.longlong(option), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QInputDialog) SetOptions(options QInputDialog__InputDialogOption) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetOptions(ptr.Pointer(), C.longlong(options))
	}
}

func (ptr *QInputDialog) SetTextEchoMode(mode QLineEdit__EchoMode) {
	if ptr.Pointer() != nil {
		C.QInputDialog_SetTextEchoMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QInputDialog) SetTextValue(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QInputDialog_SetTextValue(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQInputDialog_TextValueChanged
func callbackQInputDialog_TextValueChanged(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "textValueChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QInputDialog) ConnectTextValueChanged(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "textValueChanged") {
			C.QInputDialog_ConnectTextValueChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "textValueChanged"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "textValueChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "textValueChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QInputDialog) DisconnectTextValueChanged() {
	if ptr.Pointer() != nil {
		C.QInputDialog_DisconnectTextValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "textValueChanged")
	}
}

func (ptr *QInputDialog) TextValueChanged(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QInputDialog_TextValueChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQInputDialog_TextValueSelected
func callbackQInputDialog_TextValueSelected(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "textValueSelected"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QInputDialog) ConnectTextValueSelected(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "textValueSelected") {
			C.QInputDialog_ConnectTextValueSelected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "textValueSelected"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "textValueSelected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "textValueSelected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QInputDialog) DisconnectTextValueSelected() {
	if ptr.Pointer() != nil {
		C.QInputDialog_DisconnectTextValueSelected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "textValueSelected")
	}
}

func (ptr *QInputDialog) TextValueSelected(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QInputDialog_TextValueSelected(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQInputDialog_DestroyQInputDialog
func callbackQInputDialog_DestroyQInputDialog(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QInputDialog"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQInputDialogFromPointer(ptr).DestroyQInputDialogDefault()
	}
}

func (ptr *QInputDialog) ConnectDestroyQInputDialog(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QInputDialog"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QInputDialog", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QInputDialog", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QInputDialog) DisconnectDestroyQInputDialog() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QInputDialog")
	}
}

func (ptr *QInputDialog) DestroyQInputDialog() {
	if ptr.Pointer() != nil {
		C.QInputDialog_DestroyQInputDialog(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QInputDialog) DestroyQInputDialogDefault() {
	if ptr.Pointer() != nil {
		C.QInputDialog_DestroyQInputDialogDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QInputDialog) Options() QInputDialog__InputDialogOption {
	if ptr.Pointer() != nil {
		return QInputDialog__InputDialogOption(C.QInputDialog_Options(ptr.Pointer()))
	}
	return 0
}

func (ptr *QInputDialog) InputMode() QInputDialog__InputMode {
	if ptr.Pointer() != nil {
		return QInputDialog__InputMode(C.QInputDialog_InputMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QInputDialog) TextEchoMode() QLineEdit__EchoMode {
	if ptr.Pointer() != nil {
		return QLineEdit__EchoMode(C.QInputDialog_TextEchoMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QInputDialog) CancelButtonText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QInputDialog_CancelButtonText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QInputDialog) LabelText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QInputDialog_LabelText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QInputDialog) OkButtonText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QInputDialog_OkButtonText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QInputDialog) TextValue() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QInputDialog_TextValue(ptr.Pointer()))
	}
	return ""
}

func (ptr *QInputDialog) ComboBoxItems() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QInputDialog_ComboBoxItems(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QInputDialog) IsComboBoxEditable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QInputDialog_IsComboBoxEditable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QInputDialog) TestOption(option QInputDialog__InputDialogOption) bool {
	if ptr.Pointer() != nil {
		return int8(C.QInputDialog_TestOption(ptr.Pointer(), C.longlong(option))) != 0
	}
	return false
}

func (ptr *QInputDialog) DoubleMaximum() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QInputDialog_DoubleMaximum(ptr.Pointer()))
	}
	return 0
}

func (ptr *QInputDialog) DoubleMinimum() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QInputDialog_DoubleMinimum(ptr.Pointer()))
	}
	return 0
}

func (ptr *QInputDialog) DoubleStep() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QInputDialog_DoubleStep(ptr.Pointer()))
	}
	return 0
}

func (ptr *QInputDialog) DoubleValue() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QInputDialog_DoubleValue(ptr.Pointer()))
	}
	return 0
}

func (ptr *QInputDialog) DoubleDecimals() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QInputDialog_DoubleDecimals(ptr.Pointer())))
	}
	return 0
}

func (ptr *QInputDialog) IntMaximum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QInputDialog_IntMaximum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QInputDialog) IntMinimum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QInputDialog_IntMinimum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QInputDialog) IntStep() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QInputDialog_IntStep(ptr.Pointer())))
	}
	return 0
}

func (ptr *QInputDialog) IntValue() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QInputDialog_IntValue(ptr.Pointer())))
	}
	return 0
}

type QItemDelegate struct {
	QAbstractItemDelegate
}

type QItemDelegate_ITF interface {
	QAbstractItemDelegate_ITF
	QItemDelegate_PTR() *QItemDelegate
}

func (ptr *QItemDelegate) QItemDelegate_PTR() *QItemDelegate {
	return ptr
}

func (ptr *QItemDelegate) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemDelegate_PTR().Pointer()
	}
	return nil
}

func (ptr *QItemDelegate) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractItemDelegate_PTR().SetPointer(p)
	}
}

func PointerFromQItemDelegate(ptr QItemDelegate_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemDelegate_PTR().Pointer()
	}
	return nil
}

func NewQItemDelegateFromPointer(ptr unsafe.Pointer) (n *QItemDelegate) {
	n = new(QItemDelegate)
	n.SetPointer(ptr)
	return
}
func NewQItemDelegate(parent core.QObject_ITF) *QItemDelegate {
	tmpValue := NewQItemDelegateFromPointer(C.QItemDelegate_NewQItemDelegate(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QItemDelegate) SetClipping(clip bool) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_SetClipping(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(clip))))
	}
}

func (ptr *QItemDelegate) SetItemEditorFactory(factory QItemEditorFactory_ITF) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_SetItemEditorFactory(ptr.Pointer(), PointerFromQItemEditorFactory(factory))
	}
}

//export callbackQItemDelegate_DestroyQItemDelegate
func callbackQItemDelegate_DestroyQItemDelegate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QItemDelegate"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQItemDelegateFromPointer(ptr).DestroyQItemDelegateDefault()
	}
}

func (ptr *QItemDelegate) ConnectDestroyQItemDelegate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QItemDelegate"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QItemDelegate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QItemDelegate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemDelegate) DisconnectDestroyQItemDelegate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QItemDelegate")
	}
}

func (ptr *QItemDelegate) DestroyQItemDelegate() {
	if ptr.Pointer() != nil {
		C.QItemDelegate_DestroyQItemDelegate(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QItemDelegate) DestroyQItemDelegateDefault() {
	if ptr.Pointer() != nil {
		C.QItemDelegate_DestroyQItemDelegateDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QItemDelegate) ItemEditorFactory() *QItemEditorFactory {
	if ptr.Pointer() != nil {
		return NewQItemEditorFactoryFromPointer(C.QItemDelegate_ItemEditorFactory(ptr.Pointer()))
	}
	return nil
}

//export callbackQItemDelegate_SizeHint
func callbackQItemDelegate_SizeHint(ptr unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func(*QStyleOptionViewItem, *core.QModelIndex) *core.QSize)(signal))(NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQSize(NewQItemDelegateFromPointer(ptr).SizeHintDefault(NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))
}

func (ptr *QItemDelegate) ConnectSizeHint(f func(option *QStyleOptionViewItem, index *core.QModelIndex) *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func(option *QStyleOptionViewItem, index *core.QModelIndex) *core.QSize {
				(*(*func(*QStyleOptionViewItem, *core.QModelIndex) *core.QSize)(signal))(option, index)
				return f(option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemDelegate) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QItemDelegate) SizeHint(option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QItemDelegate_SizeHint(ptr.Pointer(), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QItemDelegate) SizeHintDefault(option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QItemDelegate_SizeHintDefault(ptr.Pointer(), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QItemDelegate) HasClipping() bool {
	if ptr.Pointer() != nil {
		return int8(C.QItemDelegate_HasClipping(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QItemDelegate) DrawBackground(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_DrawBackground(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

//export callbackQItemDelegate_DrawCheck
func callbackQItemDelegate_DrawCheck(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, rect unsafe.Pointer, state C.longlong) {
	if signal := qt.GetSignal(ptr, "drawCheck"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QRect, core.Qt__CheckState))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQRectFromPointer(rect), core.Qt__CheckState(state))
	} else {
		NewQItemDelegateFromPointer(ptr).DrawCheckDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQRectFromPointer(rect), core.Qt__CheckState(state))
	}
}

func (ptr *QItemDelegate) ConnectDrawCheck(f func(painter *gui.QPainter, option *QStyleOptionViewItem, rect *core.QRect, state core.Qt__CheckState)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawCheck"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionViewItem, rect *core.QRect, state core.Qt__CheckState) {
				(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QRect, core.Qt__CheckState))(signal))(painter, option, rect, state)
				f(painter, option, rect, state)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawCheck", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawCheck", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemDelegate) DisconnectDrawCheck() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawCheck")
	}
}

func (ptr *QItemDelegate) DrawCheck(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, rect core.QRect_ITF, state core.Qt__CheckState) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_DrawCheck(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQRect(rect), C.longlong(state))
	}
}

func (ptr *QItemDelegate) DrawCheckDefault(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, rect core.QRect_ITF, state core.Qt__CheckState) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_DrawCheckDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQRect(rect), C.longlong(state))
	}
}

//export callbackQItemDelegate_DrawDecoration
func callbackQItemDelegate_DrawDecoration(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, rect unsafe.Pointer, pixmap unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawDecoration"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QRect, *gui.QPixmap))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQRectFromPointer(rect), gui.NewQPixmapFromPointer(pixmap))
	} else {
		NewQItemDelegateFromPointer(ptr).DrawDecorationDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQRectFromPointer(rect), gui.NewQPixmapFromPointer(pixmap))
	}
}

func (ptr *QItemDelegate) ConnectDrawDecoration(f func(painter *gui.QPainter, option *QStyleOptionViewItem, rect *core.QRect, pixmap *gui.QPixmap)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawDecoration"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionViewItem, rect *core.QRect, pixmap *gui.QPixmap) {
				(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QRect, *gui.QPixmap))(signal))(painter, option, rect, pixmap)
				f(painter, option, rect, pixmap)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawDecoration", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawDecoration", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemDelegate) DisconnectDrawDecoration() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawDecoration")
	}
}

func (ptr *QItemDelegate) DrawDecoration(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, rect core.QRect_ITF, pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_DrawDecoration(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQRect(rect), gui.PointerFromQPixmap(pixmap))
	}
}

func (ptr *QItemDelegate) DrawDecorationDefault(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, rect core.QRect_ITF, pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_DrawDecorationDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQRect(rect), gui.PointerFromQPixmap(pixmap))
	}
}

//export callbackQItemDelegate_DrawDisplay
func callbackQItemDelegate_DrawDisplay(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, rect unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "drawDisplay"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QRect, string))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQRectFromPointer(rect), cGoUnpackString(text))
	} else {
		NewQItemDelegateFromPointer(ptr).DrawDisplayDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQRectFromPointer(rect), cGoUnpackString(text))
	}
}

func (ptr *QItemDelegate) ConnectDrawDisplay(f func(painter *gui.QPainter, option *QStyleOptionViewItem, rect *core.QRect, text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawDisplay"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionViewItem, rect *core.QRect, text string) {
				(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QRect, string))(signal))(painter, option, rect, text)
				f(painter, option, rect, text)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawDisplay", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawDisplay", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemDelegate) DisconnectDrawDisplay() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawDisplay")
	}
}

func (ptr *QItemDelegate) DrawDisplay(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, rect core.QRect_ITF, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QItemDelegate_DrawDisplay(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQRect(rect), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QItemDelegate) DrawDisplayDefault(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, rect core.QRect_ITF, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QItemDelegate_DrawDisplayDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQRect(rect), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQItemDelegate_DrawFocus
func callbackQItemDelegate_DrawFocus(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawFocus"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QRect))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQRectFromPointer(rect))
	} else {
		NewQItemDelegateFromPointer(ptr).DrawFocusDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQRectFromPointer(rect))
	}
}

func (ptr *QItemDelegate) ConnectDrawFocus(f func(painter *gui.QPainter, option *QStyleOptionViewItem, rect *core.QRect)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawFocus"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionViewItem, rect *core.QRect) {
				(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QRect))(signal))(painter, option, rect)
				f(painter, option, rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawFocus", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawFocus", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemDelegate) DisconnectDrawFocus() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawFocus")
	}
}

func (ptr *QItemDelegate) DrawFocus(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_DrawFocus(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQRect(rect))
	}
}

func (ptr *QItemDelegate) DrawFocusDefault(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_DrawFocusDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQRect(rect))
	}
}

//export callbackQItemDelegate_Paint
func callbackQItemDelegate_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QModelIndex))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	} else {
		NewQItemDelegateFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QItemDelegate) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionViewItem, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionViewItem, index *core.QModelIndex) {
				(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QModelIndex))(signal))(painter, option, index)
				f(painter, option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemDelegate) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QItemDelegate) Paint(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QItemDelegate) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QItemDelegate_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

type QItemEditorCreator struct {
	QItemEditorCreatorBase
}

type QItemEditorCreator_ITF interface {
	QItemEditorCreatorBase_ITF
	QItemEditorCreator_PTR() *QItemEditorCreator
}

func (ptr *QItemEditorCreator) QItemEditorCreator_PTR() *QItemEditorCreator {
	return ptr
}

func (ptr *QItemEditorCreator) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemEditorCreatorBase_PTR().Pointer()
	}
	return nil
}

func (ptr *QItemEditorCreator) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QItemEditorCreatorBase_PTR().SetPointer(p)
	}
}

func PointerFromQItemEditorCreator(ptr QItemEditorCreator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemEditorCreator_PTR().Pointer()
	}
	return nil
}

func NewQItemEditorCreatorFromPointer(ptr unsafe.Pointer) (n *QItemEditorCreator) {
	n = new(QItemEditorCreator)
	n.SetPointer(ptr)
	return
}

func (ptr *QItemEditorCreator) DestroyQItemEditorCreator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(ptr.Pointer(), "")
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QItemEditorCreatorBase struct {
	ptr unsafe.Pointer
}

type QItemEditorCreatorBase_ITF interface {
	QItemEditorCreatorBase_PTR() *QItemEditorCreatorBase
}

func (ptr *QItemEditorCreatorBase) QItemEditorCreatorBase_PTR() *QItemEditorCreatorBase {
	return ptr
}

func (ptr *QItemEditorCreatorBase) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QItemEditorCreatorBase) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQItemEditorCreatorBase(ptr QItemEditorCreatorBase_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemEditorCreatorBase_PTR().Pointer()
	}
	return nil
}

func NewQItemEditorCreatorBaseFromPointer(ptr unsafe.Pointer) (n *QItemEditorCreatorBase) {
	n = new(QItemEditorCreatorBase)
	n.SetPointer(ptr)
	return
}

//export callbackQItemEditorCreatorBase_DestroyQItemEditorCreatorBase
func callbackQItemEditorCreatorBase_DestroyQItemEditorCreatorBase(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QItemEditorCreatorBase"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQItemEditorCreatorBaseFromPointer(ptr).DestroyQItemEditorCreatorBaseDefault()
	}
}

func (ptr *QItemEditorCreatorBase) ConnectDestroyQItemEditorCreatorBase(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QItemEditorCreatorBase"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QItemEditorCreatorBase", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QItemEditorCreatorBase", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemEditorCreatorBase) DisconnectDestroyQItemEditorCreatorBase() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QItemEditorCreatorBase")
	}
}

func (ptr *QItemEditorCreatorBase) DestroyQItemEditorCreatorBase() {
	if ptr.Pointer() != nil {
		C.QItemEditorCreatorBase_DestroyQItemEditorCreatorBase(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QItemEditorCreatorBase) DestroyQItemEditorCreatorBaseDefault() {
	if ptr.Pointer() != nil {
		C.QItemEditorCreatorBase_DestroyQItemEditorCreatorBaseDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQItemEditorCreatorBase_ValuePropertyName
func callbackQItemEditorCreatorBase_ValuePropertyName(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "valuePropertyName"); signal != nil {
		return core.PointerFromQByteArray((*(*func() *core.QByteArray)(signal))())
	}

	return core.PointerFromQByteArray(core.NewQByteArray())
}

func (ptr *QItemEditorCreatorBase) ConnectValuePropertyName(f func() *core.QByteArray) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "valuePropertyName"); signal != nil {
			f := func() *core.QByteArray {
				(*(*func() *core.QByteArray)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "valuePropertyName", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valuePropertyName", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemEditorCreatorBase) DisconnectValuePropertyName() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "valuePropertyName")
	}
}

func (ptr *QItemEditorCreatorBase) ValuePropertyName() *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QItemEditorCreatorBase_ValuePropertyName(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

//export callbackQItemEditorCreatorBase_CreateWidget
func callbackQItemEditorCreatorBase_CreateWidget(ptr unsafe.Pointer, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "createWidget"); signal != nil {
		return PointerFromQWidget((*(*func(*QWidget) *QWidget)(signal))(NewQWidgetFromPointer(parent)))
	}

	return PointerFromQWidget(nil)
}

func (ptr *QItemEditorCreatorBase) ConnectCreateWidget(f func(parent *QWidget) *QWidget) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "createWidget"); signal != nil {
			f := func(parent *QWidget) *QWidget {
				(*(*func(*QWidget) *QWidget)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "createWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "createWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemEditorCreatorBase) DisconnectCreateWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "createWidget")
	}
}

func (ptr *QItemEditorCreatorBase) CreateWidget(parent QWidget_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QItemEditorCreatorBase_CreateWidget(ptr.Pointer(), PointerFromQWidget(parent)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

type QItemEditorFactory struct {
	ptr unsafe.Pointer
}

type QItemEditorFactory_ITF interface {
	QItemEditorFactory_PTR() *QItemEditorFactory
}

func (ptr *QItemEditorFactory) QItemEditorFactory_PTR() *QItemEditorFactory {
	return ptr
}

func (ptr *QItemEditorFactory) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QItemEditorFactory) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQItemEditorFactory(ptr QItemEditorFactory_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemEditorFactory_PTR().Pointer()
	}
	return nil
}

func NewQItemEditorFactoryFromPointer(ptr unsafe.Pointer) (n *QItemEditorFactory) {
	n = new(QItemEditorFactory)
	n.SetPointer(ptr)
	return
}
func NewQItemEditorFactory() *QItemEditorFactory {
	return NewQItemEditorFactoryFromPointer(C.QItemEditorFactory_NewQItemEditorFactory())
}

func QItemEditorFactory_DefaultFactory() *QItemEditorFactory {
	return NewQItemEditorFactoryFromPointer(C.QItemEditorFactory_QItemEditorFactory_DefaultFactory())
}

func (ptr *QItemEditorFactory) DefaultFactory() *QItemEditorFactory {
	return NewQItemEditorFactoryFromPointer(C.QItemEditorFactory_QItemEditorFactory_DefaultFactory())
}

func (ptr *QItemEditorFactory) RegisterEditor(userType int, creator QItemEditorCreatorBase_ITF) {
	if ptr.Pointer() != nil {
		C.QItemEditorFactory_RegisterEditor(ptr.Pointer(), C.int(int32(userType)), PointerFromQItemEditorCreatorBase(creator))
	}
}

func QItemEditorFactory_SetDefaultFactory(factory QItemEditorFactory_ITF) {
	C.QItemEditorFactory_QItemEditorFactory_SetDefaultFactory(PointerFromQItemEditorFactory(factory))
}

func (ptr *QItemEditorFactory) SetDefaultFactory(factory QItemEditorFactory_ITF) {
	C.QItemEditorFactory_QItemEditorFactory_SetDefaultFactory(PointerFromQItemEditorFactory(factory))
}

//export callbackQItemEditorFactory_DestroyQItemEditorFactory
func callbackQItemEditorFactory_DestroyQItemEditorFactory(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QItemEditorFactory"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQItemEditorFactoryFromPointer(ptr).DestroyQItemEditorFactoryDefault()
	}
}

func (ptr *QItemEditorFactory) ConnectDestroyQItemEditorFactory(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QItemEditorFactory"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QItemEditorFactory", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QItemEditorFactory", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemEditorFactory) DisconnectDestroyQItemEditorFactory() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QItemEditorFactory")
	}
}

func (ptr *QItemEditorFactory) DestroyQItemEditorFactory() {
	if ptr.Pointer() != nil {
		C.QItemEditorFactory_DestroyQItemEditorFactory(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QItemEditorFactory) DestroyQItemEditorFactoryDefault() {
	if ptr.Pointer() != nil {
		C.QItemEditorFactory_DestroyQItemEditorFactoryDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQItemEditorFactory_ValuePropertyName
func callbackQItemEditorFactory_ValuePropertyName(ptr unsafe.Pointer, userType C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "valuePropertyName"); signal != nil {
		return core.PointerFromQByteArray((*(*func(int) *core.QByteArray)(signal))(int(int32(userType))))
	}

	return core.PointerFromQByteArray(NewQItemEditorFactoryFromPointer(ptr).ValuePropertyNameDefault(int(int32(userType))))
}

func (ptr *QItemEditorFactory) ConnectValuePropertyName(f func(userType int) *core.QByteArray) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "valuePropertyName"); signal != nil {
			f := func(userType int) *core.QByteArray {
				(*(*func(int) *core.QByteArray)(signal))(userType)
				return f(userType)
			}
			qt.ConnectSignal(ptr.Pointer(), "valuePropertyName", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valuePropertyName", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemEditorFactory) DisconnectValuePropertyName() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "valuePropertyName")
	}
}

func (ptr *QItemEditorFactory) ValuePropertyName(userType int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QItemEditorFactory_ValuePropertyName(ptr.Pointer(), C.int(int32(userType))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QItemEditorFactory) ValuePropertyNameDefault(userType int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QItemEditorFactory_ValuePropertyNameDefault(ptr.Pointer(), C.int(int32(userType))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

//export callbackQItemEditorFactory_CreateEditor
func callbackQItemEditorFactory_CreateEditor(ptr unsafe.Pointer, userType C.int, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "createEditor"); signal != nil {
		return PointerFromQWidget((*(*func(int, *QWidget) *QWidget)(signal))(int(int32(userType)), NewQWidgetFromPointer(parent)))
	}

	return PointerFromQWidget(NewQItemEditorFactoryFromPointer(ptr).CreateEditorDefault(int(int32(userType)), NewQWidgetFromPointer(parent)))
}

func (ptr *QItemEditorFactory) ConnectCreateEditor(f func(userType int, parent *QWidget) *QWidget) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "createEditor"); signal != nil {
			f := func(userType int, parent *QWidget) *QWidget {
				(*(*func(int, *QWidget) *QWidget)(signal))(userType, parent)
				return f(userType, parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "createEditor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "createEditor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QItemEditorFactory) DisconnectCreateEditor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "createEditor")
	}
}

func (ptr *QItemEditorFactory) CreateEditor(userType int, parent QWidget_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QItemEditorFactory_CreateEditor(ptr.Pointer(), C.int(int32(userType)), PointerFromQWidget(parent)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QItemEditorFactory) CreateEditorDefault(userType int, parent QWidget_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QItemEditorFactory_CreateEditorDefault(ptr.Pointer(), C.int(int32(userType)), PointerFromQWidget(parent)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QItemEditorFactory) __creatorMap_atList(v int, i int) *QItemEditorCreatorBase {
	if ptr.Pointer() != nil {
		return NewQItemEditorCreatorBaseFromPointer(C.QItemEditorFactory___creatorMap_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
	}
	return nil
}

func (ptr *QItemEditorFactory) __creatorMap_setList(key int, i QItemEditorCreatorBase_ITF) {
	if ptr.Pointer() != nil {
		C.QItemEditorFactory___creatorMap_setList(ptr.Pointer(), C.int(int32(key)), PointerFromQItemEditorCreatorBase(i))
	}
}

func (ptr *QItemEditorFactory) __creatorMap_newList() unsafe.Pointer {
	return C.QItemEditorFactory___creatorMap_newList(ptr.Pointer())
}

func (ptr *QItemEditorFactory) __creatorMap_keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQItemEditorFactoryFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____creatorMap_keyList_atList(i)
			}
			return out
		}(C.QItemEditorFactory___creatorMap_keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QItemEditorFactory) __setCreatorMap__atList(v int, i int) *QItemEditorCreatorBase {
	if ptr.Pointer() != nil {
		return NewQItemEditorCreatorBaseFromPointer(C.QItemEditorFactory___setCreatorMap__atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
	}
	return nil
}

func (ptr *QItemEditorFactory) __setCreatorMap__setList(key int, i QItemEditorCreatorBase_ITF) {
	if ptr.Pointer() != nil {
		C.QItemEditorFactory___setCreatorMap__setList(ptr.Pointer(), C.int(int32(key)), PointerFromQItemEditorCreatorBase(i))
	}
}

func (ptr *QItemEditorFactory) __setCreatorMap__newList() unsafe.Pointer {
	return C.QItemEditorFactory___setCreatorMap__newList(ptr.Pointer())
}

func (ptr *QItemEditorFactory) __setCreatorMap__keyList() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQItemEditorFactoryFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.____setCreatorMap__keyList_atList(i)
			}
			return out
		}(C.QItemEditorFactory___setCreatorMap__keyList(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QItemEditorFactory) ____creatorMap_keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QItemEditorFactory_____creatorMap_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QItemEditorFactory) ____creatorMap_keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QItemEditorFactory_____creatorMap_keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QItemEditorFactory) ____creatorMap_keyList_newList() unsafe.Pointer {
	return C.QItemEditorFactory_____creatorMap_keyList_newList(ptr.Pointer())
}

func (ptr *QItemEditorFactory) ____setCreatorMap__keyList_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QItemEditorFactory_____setCreatorMap__keyList_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QItemEditorFactory) ____setCreatorMap__keyList_setList(i int) {
	if ptr.Pointer() != nil {
		C.QItemEditorFactory_____setCreatorMap__keyList_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QItemEditorFactory) ____setCreatorMap__keyList_newList() unsafe.Pointer {
	return C.QItemEditorFactory_____setCreatorMap__keyList_newList(ptr.Pointer())
}

type QKeyEventTransition struct {
	core.QEventTransition
}

type QKeyEventTransition_ITF interface {
	core.QEventTransition_ITF
	QKeyEventTransition_PTR() *QKeyEventTransition
}

func (ptr *QKeyEventTransition) QKeyEventTransition_PTR() *QKeyEventTransition {
	return ptr
}

func (ptr *QKeyEventTransition) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QEventTransition_PTR().Pointer()
	}
	return nil
}

func (ptr *QKeyEventTransition) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QEventTransition_PTR().SetPointer(p)
	}
}

func PointerFromQKeyEventTransition(ptr QKeyEventTransition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QKeyEventTransition_PTR().Pointer()
	}
	return nil
}

func NewQKeyEventTransitionFromPointer(ptr unsafe.Pointer) (n *QKeyEventTransition) {
	n = new(QKeyEventTransition)
	n.SetPointer(ptr)
	return
}
func NewQKeyEventTransition2(object core.QObject_ITF, ty core.QEvent__Type, key int, sourceState core.QState_ITF) *QKeyEventTransition {
	tmpValue := NewQKeyEventTransitionFromPointer(C.QKeyEventTransition_NewQKeyEventTransition2(core.PointerFromQObject(object), C.longlong(ty), C.int(int32(key)), core.PointerFromQState(sourceState)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQKeyEventTransition(sourceState core.QState_ITF) *QKeyEventTransition {
	tmpValue := NewQKeyEventTransitionFromPointer(C.QKeyEventTransition_NewQKeyEventTransition(core.PointerFromQState(sourceState)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QKeyEventTransition_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QKeyEventTransition_QKeyEventTransition_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QKeyEventTransition) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QKeyEventTransition_QKeyEventTransition_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQKeyEventTransition_EventTest
func callbackQKeyEventTransition_EventTest(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventTest"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQKeyEventTransitionFromPointer(ptr).EventTestDefault(core.NewQEventFromPointer(event)))))
}

func (ptr *QKeyEventTransition) EventTestDefault(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QKeyEventTransition_EventTestDefault(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQKeyEventTransition_OnTransition
func callbackQKeyEventTransition_OnTransition(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onTransition"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQKeyEventTransitionFromPointer(ptr).OnTransitionDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QKeyEventTransition) OnTransitionDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_OnTransitionDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QKeyEventTransition) SetKey(key int) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_SetKey(ptr.Pointer(), C.int(int32(key)))
	}
}

func (ptr *QKeyEventTransition) SetModifierMask(modifierMask core.Qt__KeyboardModifier) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_SetModifierMask(ptr.Pointer(), C.longlong(modifierMask))
	}
}

//export callbackQKeyEventTransition_DestroyQKeyEventTransition
func callbackQKeyEventTransition_DestroyQKeyEventTransition(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QKeyEventTransition"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQKeyEventTransitionFromPointer(ptr).DestroyQKeyEventTransitionDefault()
	}
}

func (ptr *QKeyEventTransition) ConnectDestroyQKeyEventTransition(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QKeyEventTransition"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QKeyEventTransition", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QKeyEventTransition", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QKeyEventTransition) DisconnectDestroyQKeyEventTransition() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QKeyEventTransition")
	}
}

func (ptr *QKeyEventTransition) DestroyQKeyEventTransition() {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_DestroyQKeyEventTransition(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QKeyEventTransition) DestroyQKeyEventTransitionDefault() {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_DestroyQKeyEventTransitionDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QKeyEventTransition) ModifierMask() core.Qt__KeyboardModifier {
	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QKeyEventTransition_ModifierMask(ptr.Pointer()))
	}
	return 0
}

//export callbackQKeyEventTransition_MetaObject
func callbackQKeyEventTransition_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQKeyEventTransitionFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QKeyEventTransition) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QKeyEventTransition_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QKeyEventTransition) Key() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QKeyEventTransition_Key(ptr.Pointer())))
	}
	return 0
}

func (ptr *QKeyEventTransition) __setTargetStates_targets_atList(i int) *core.QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractStateFromPointer(C.QKeyEventTransition___setTargetStates_targets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QKeyEventTransition) __setTargetStates_targets_setList(i core.QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition___setTargetStates_targets_setList(ptr.Pointer(), core.PointerFromQAbstractState(i))
	}
}

func (ptr *QKeyEventTransition) __setTargetStates_targets_newList() unsafe.Pointer {
	return C.QKeyEventTransition___setTargetStates_targets_newList(ptr.Pointer())
}

func (ptr *QKeyEventTransition) __animations_atList(i int) *core.QAbstractAnimation {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractAnimationFromPointer(C.QKeyEventTransition___animations_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QKeyEventTransition) __animations_setList(i core.QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition___animations_setList(ptr.Pointer(), core.PointerFromQAbstractAnimation(i))
	}
}

func (ptr *QKeyEventTransition) __animations_newList() unsafe.Pointer {
	return C.QKeyEventTransition___animations_newList(ptr.Pointer())
}

func (ptr *QKeyEventTransition) __targetStates_atList(i int) *core.QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractStateFromPointer(C.QKeyEventTransition___targetStates_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QKeyEventTransition) __targetStates_setList(i core.QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition___targetStates_setList(ptr.Pointer(), core.PointerFromQAbstractState(i))
	}
}

func (ptr *QKeyEventTransition) __targetStates_newList() unsafe.Pointer {
	return C.QKeyEventTransition___targetStates_newList(ptr.Pointer())
}

func (ptr *QKeyEventTransition) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QKeyEventTransition___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QKeyEventTransition) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QKeyEventTransition) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QKeyEventTransition___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QKeyEventTransition) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QKeyEventTransition___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QKeyEventTransition) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QKeyEventTransition) __findChildren_newList2() unsafe.Pointer {
	return C.QKeyEventTransition___findChildren_newList2(ptr.Pointer())
}

func (ptr *QKeyEventTransition) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QKeyEventTransition___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QKeyEventTransition) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QKeyEventTransition) __findChildren_newList3() unsafe.Pointer {
	return C.QKeyEventTransition___findChildren_newList3(ptr.Pointer())
}

func (ptr *QKeyEventTransition) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QKeyEventTransition___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QKeyEventTransition) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QKeyEventTransition) __findChildren_newList() unsafe.Pointer {
	return C.QKeyEventTransition___findChildren_newList(ptr.Pointer())
}

func (ptr *QKeyEventTransition) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QKeyEventTransition___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QKeyEventTransition) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QKeyEventTransition) __children_newList() unsafe.Pointer {
	return C.QKeyEventTransition___children_newList(ptr.Pointer())
}

//export callbackQKeyEventTransition_Event
func callbackQKeyEventTransition_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQKeyEventTransitionFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QKeyEventTransition) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QKeyEventTransition_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQKeyEventTransition_TargetStateChanged
func callbackQKeyEventTransition_TargetStateChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "targetStateChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQKeyEventTransition_TargetStatesChanged
func callbackQKeyEventTransition_TargetStatesChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "targetStatesChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQKeyEventTransition_Triggered
func callbackQKeyEventTransition_Triggered(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "triggered"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQKeyEventTransition_EventFilter
func callbackQKeyEventTransition_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQKeyEventTransitionFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QKeyEventTransition) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QKeyEventTransition_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQKeyEventTransition_ChildEvent
func callbackQKeyEventTransition_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQKeyEventTransitionFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QKeyEventTransition) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQKeyEventTransition_ConnectNotify
func callbackQKeyEventTransition_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQKeyEventTransitionFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QKeyEventTransition) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQKeyEventTransition_CustomEvent
func callbackQKeyEventTransition_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQKeyEventTransitionFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QKeyEventTransition) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQKeyEventTransition_DeleteLater
func callbackQKeyEventTransition_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQKeyEventTransitionFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QKeyEventTransition) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQKeyEventTransition_Destroyed
func callbackQKeyEventTransition_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQKeyEventTransition_DisconnectNotify
func callbackQKeyEventTransition_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQKeyEventTransitionFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QKeyEventTransition) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQKeyEventTransition_ObjectNameChanged
func callbackQKeyEventTransition_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQKeyEventTransition_TimerEvent
func callbackQKeyEventTransition_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQKeyEventTransitionFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QKeyEventTransition) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QKeyEventTransition_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QKeySequenceEdit struct {
	QWidget
}

type QKeySequenceEdit_ITF interface {
	QWidget_ITF
	QKeySequenceEdit_PTR() *QKeySequenceEdit
}

func (ptr *QKeySequenceEdit) QKeySequenceEdit_PTR() *QKeySequenceEdit {
	return ptr
}

func (ptr *QKeySequenceEdit) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QKeySequenceEdit) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQKeySequenceEdit(ptr QKeySequenceEdit_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QKeySequenceEdit_PTR().Pointer()
	}
	return nil
}

func NewQKeySequenceEditFromPointer(ptr unsafe.Pointer) (n *QKeySequenceEdit) {
	n = new(QKeySequenceEdit)
	n.SetPointer(ptr)
	return
}
func NewQKeySequenceEdit(parent QWidget_ITF) *QKeySequenceEdit {
	tmpValue := NewQKeySequenceEditFromPointer(C.QKeySequenceEdit_NewQKeySequenceEdit(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQKeySequenceEdit2(keySequence gui.QKeySequence_ITF, parent QWidget_ITF) *QKeySequenceEdit {
	tmpValue := NewQKeySequenceEditFromPointer(C.QKeySequenceEdit_NewQKeySequenceEdit2(gui.PointerFromQKeySequence(keySequence), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQKeySequenceEdit_Clear
func callbackQKeySequenceEdit_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQKeySequenceEditFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QKeySequenceEdit) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QKeySequenceEdit) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QKeySequenceEdit) Clear() {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_Clear(ptr.Pointer())
	}
}

func (ptr *QKeySequenceEdit) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_ClearDefault(ptr.Pointer())
	}
}

//export callbackQKeySequenceEdit_EditingFinished
func callbackQKeySequenceEdit_EditingFinished(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "editingFinished"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QKeySequenceEdit) ConnectEditingFinished(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "editingFinished") {
			C.QKeySequenceEdit_ConnectEditingFinished(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "editingFinished"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "editingFinished", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "editingFinished", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QKeySequenceEdit) DisconnectEditingFinished() {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_DisconnectEditingFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "editingFinished")
	}
}

func (ptr *QKeySequenceEdit) EditingFinished() {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_EditingFinished(ptr.Pointer())
	}
}

//export callbackQKeySequenceEdit_KeySequenceChanged
func callbackQKeySequenceEdit_KeySequenceChanged(ptr unsafe.Pointer, keySequence unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "keySequenceChanged"); signal != nil {
		(*(*func(*gui.QKeySequence))(signal))(gui.NewQKeySequenceFromPointer(keySequence))
	}

}

func (ptr *QKeySequenceEdit) ConnectKeySequenceChanged(f func(keySequence *gui.QKeySequence)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "keySequenceChanged") {
			C.QKeySequenceEdit_ConnectKeySequenceChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "keySequenceChanged"); signal != nil {
			f := func(keySequence *gui.QKeySequence) {
				(*(*func(*gui.QKeySequence))(signal))(keySequence)
				f(keySequence)
			}
			qt.ConnectSignal(ptr.Pointer(), "keySequenceChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "keySequenceChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QKeySequenceEdit) DisconnectKeySequenceChanged() {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_DisconnectKeySequenceChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "keySequenceChanged")
	}
}

func (ptr *QKeySequenceEdit) KeySequenceChanged(keySequence gui.QKeySequence_ITF) {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_KeySequenceChanged(ptr.Pointer(), gui.PointerFromQKeySequence(keySequence))
	}
}

//export callbackQKeySequenceEdit_SetKeySequence
func callbackQKeySequenceEdit_SetKeySequence(ptr unsafe.Pointer, keySequence unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setKeySequence"); signal != nil {
		(*(*func(*gui.QKeySequence))(signal))(gui.NewQKeySequenceFromPointer(keySequence))
	} else {
		NewQKeySequenceEditFromPointer(ptr).SetKeySequenceDefault(gui.NewQKeySequenceFromPointer(keySequence))
	}
}

func (ptr *QKeySequenceEdit) ConnectSetKeySequence(f func(keySequence *gui.QKeySequence)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setKeySequence"); signal != nil {
			f := func(keySequence *gui.QKeySequence) {
				(*(*func(*gui.QKeySequence))(signal))(keySequence)
				f(keySequence)
			}
			qt.ConnectSignal(ptr.Pointer(), "setKeySequence", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setKeySequence", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QKeySequenceEdit) DisconnectSetKeySequence() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setKeySequence")
	}
}

func (ptr *QKeySequenceEdit) SetKeySequence(keySequence gui.QKeySequence_ITF) {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_SetKeySequence(ptr.Pointer(), gui.PointerFromQKeySequence(keySequence))
	}
}

func (ptr *QKeySequenceEdit) SetKeySequenceDefault(keySequence gui.QKeySequence_ITF) {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_SetKeySequenceDefault(ptr.Pointer(), gui.PointerFromQKeySequence(keySequence))
	}
}

//export callbackQKeySequenceEdit_DestroyQKeySequenceEdit
func callbackQKeySequenceEdit_DestroyQKeySequenceEdit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QKeySequenceEdit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQKeySequenceEditFromPointer(ptr).DestroyQKeySequenceEditDefault()
	}
}

func (ptr *QKeySequenceEdit) ConnectDestroyQKeySequenceEdit(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QKeySequenceEdit"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QKeySequenceEdit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QKeySequenceEdit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QKeySequenceEdit) DisconnectDestroyQKeySequenceEdit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QKeySequenceEdit")
	}
}

func (ptr *QKeySequenceEdit) DestroyQKeySequenceEdit() {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_DestroyQKeySequenceEdit(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QKeySequenceEdit) DestroyQKeySequenceEditDefault() {
	if ptr.Pointer() != nil {
		C.QKeySequenceEdit_DestroyQKeySequenceEditDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QKeySequenceEdit) KeySequence() *gui.QKeySequence {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQKeySequenceFromPointer(C.QKeySequenceEdit_KeySequence(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QKeySequence).DestroyQKeySequence)
		return tmpValue
	}
	return nil
}

type QLCDNumber struct {
	QFrame
}

type QLCDNumber_ITF interface {
	QFrame_ITF
	QLCDNumber_PTR() *QLCDNumber
}

func (ptr *QLCDNumber) QLCDNumber_PTR() *QLCDNumber {
	return ptr
}

func (ptr *QLCDNumber) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QFrame_PTR().Pointer()
	}
	return nil
}

func (ptr *QLCDNumber) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QFrame_PTR().SetPointer(p)
	}
}

func PointerFromQLCDNumber(ptr QLCDNumber_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLCDNumber_PTR().Pointer()
	}
	return nil
}

func NewQLCDNumberFromPointer(ptr unsafe.Pointer) (n *QLCDNumber) {
	n = new(QLCDNumber)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QLCDNumber__Mode
//QLCDNumber::Mode
type QLCDNumber__Mode int64

const (
	QLCDNumber__Hex QLCDNumber__Mode = QLCDNumber__Mode(0)
	QLCDNumber__Dec QLCDNumber__Mode = QLCDNumber__Mode(1)
	QLCDNumber__Oct QLCDNumber__Mode = QLCDNumber__Mode(2)
	QLCDNumber__Bin QLCDNumber__Mode = QLCDNumber__Mode(3)
)

//go:generate stringer -type=QLCDNumber__SegmentStyle
//QLCDNumber::SegmentStyle
type QLCDNumber__SegmentStyle int64

var (
	QLCDNumber__Outline QLCDNumber__SegmentStyle = QLCDNumber__SegmentStyle(0)
	QLCDNumber__Filled  QLCDNumber__SegmentStyle = QLCDNumber__SegmentStyle(1)
	QLCDNumber__Flat    QLCDNumber__SegmentStyle = QLCDNumber__SegmentStyle(2)
)

func NewQLCDNumber(parent QWidget_ITF) *QLCDNumber {
	tmpValue := NewQLCDNumberFromPointer(C.QLCDNumber_NewQLCDNumber(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQLCDNumber2(numDigits uint, parent QWidget_ITF) *QLCDNumber {
	tmpValue := NewQLCDNumberFromPointer(C.QLCDNumber_NewQLCDNumber2(C.uint(uint32(numDigits)), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQLCDNumber_Display
func callbackQLCDNumber_Display(ptr unsafe.Pointer, s C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "display"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(s))
	} else {
		NewQLCDNumberFromPointer(ptr).DisplayDefault(cGoUnpackString(s))
	}
}

func (ptr *QLCDNumber) ConnectDisplay(f func(s string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "display"); signal != nil {
			f := func(s string) {
				(*(*func(string))(signal))(s)
				f(s)
			}
			qt.ConnectSignal(ptr.Pointer(), "display", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "display", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectDisplay() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "display")
	}
}

func (ptr *QLCDNumber) Display(s string) {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		C.QLCDNumber_Display(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: sC, len: C.longlong(len(s))})
	}
}

func (ptr *QLCDNumber) DisplayDefault(s string) {
	if ptr.Pointer() != nil {
		var sC *C.char
		if s != "" {
			sC = C.CString(s)
			defer C.free(unsafe.Pointer(sC))
		}
		C.QLCDNumber_DisplayDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: sC, len: C.longlong(len(s))})
	}
}

//export callbackQLCDNumber_Display3
func callbackQLCDNumber_Display3(ptr unsafe.Pointer, num C.double) {
	if signal := qt.GetSignal(ptr, "display3"); signal != nil {
		(*(*func(float64))(signal))(float64(num))
	} else {
		NewQLCDNumberFromPointer(ptr).Display3Default(float64(num))
	}
}

func (ptr *QLCDNumber) ConnectDisplay3(f func(num float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "display3"); signal != nil {
			f := func(num float64) {
				(*(*func(float64))(signal))(num)
				f(num)
			}
			qt.ConnectSignal(ptr.Pointer(), "display3", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "display3", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectDisplay3() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "display3")
	}
}

func (ptr *QLCDNumber) Display3(num float64) {
	if ptr.Pointer() != nil {
		C.QLCDNumber_Display3(ptr.Pointer(), C.double(num))
	}
}

func (ptr *QLCDNumber) Display3Default(num float64) {
	if ptr.Pointer() != nil {
		C.QLCDNumber_Display3Default(ptr.Pointer(), C.double(num))
	}
}

//export callbackQLCDNumber_Display2
func callbackQLCDNumber_Display2(ptr unsafe.Pointer, num C.int) {
	if signal := qt.GetSignal(ptr, "display2"); signal != nil {
		(*(*func(int))(signal))(int(int32(num)))
	} else {
		NewQLCDNumberFromPointer(ptr).Display2Default(int(int32(num)))
	}
}

func (ptr *QLCDNumber) ConnectDisplay2(f func(num int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "display2"); signal != nil {
			f := func(num int) {
				(*(*func(int))(signal))(num)
				f(num)
			}
			qt.ConnectSignal(ptr.Pointer(), "display2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "display2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectDisplay2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "display2")
	}
}

func (ptr *QLCDNumber) Display2(num int) {
	if ptr.Pointer() != nil {
		C.QLCDNumber_Display2(ptr.Pointer(), C.int(int32(num)))
	}
}

func (ptr *QLCDNumber) Display2Default(num int) {
	if ptr.Pointer() != nil {
		C.QLCDNumber_Display2Default(ptr.Pointer(), C.int(int32(num)))
	}
}

//export callbackQLCDNumber_Overflow
func callbackQLCDNumber_Overflow(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "overflow"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QLCDNumber) ConnectOverflow(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "overflow") {
			C.QLCDNumber_ConnectOverflow(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "overflow"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "overflow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "overflow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectOverflow() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_DisconnectOverflow(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "overflow")
	}
}

func (ptr *QLCDNumber) Overflow() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_Overflow(ptr.Pointer())
	}
}

//export callbackQLCDNumber_SetBinMode
func callbackQLCDNumber_SetBinMode(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setBinMode"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLCDNumberFromPointer(ptr).SetBinModeDefault()
	}
}

func (ptr *QLCDNumber) ConnectSetBinMode(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setBinMode"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "setBinMode", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setBinMode", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectSetBinMode() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setBinMode")
	}
}

func (ptr *QLCDNumber) SetBinMode() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetBinMode(ptr.Pointer())
	}
}

func (ptr *QLCDNumber) SetBinModeDefault() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetBinModeDefault(ptr.Pointer())
	}
}

//export callbackQLCDNumber_SetDecMode
func callbackQLCDNumber_SetDecMode(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setDecMode"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLCDNumberFromPointer(ptr).SetDecModeDefault()
	}
}

func (ptr *QLCDNumber) ConnectSetDecMode(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setDecMode"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "setDecMode", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setDecMode", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectSetDecMode() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setDecMode")
	}
}

func (ptr *QLCDNumber) SetDecMode() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetDecMode(ptr.Pointer())
	}
}

func (ptr *QLCDNumber) SetDecModeDefault() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetDecModeDefault(ptr.Pointer())
	}
}

func (ptr *QLCDNumber) SetDigitCount(numDigits int) {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetDigitCount(ptr.Pointer(), C.int(int32(numDigits)))
	}
}

//export callbackQLCDNumber_SetHexMode
func callbackQLCDNumber_SetHexMode(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setHexMode"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLCDNumberFromPointer(ptr).SetHexModeDefault()
	}
}

func (ptr *QLCDNumber) ConnectSetHexMode(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setHexMode"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "setHexMode", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setHexMode", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectSetHexMode() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setHexMode")
	}
}

func (ptr *QLCDNumber) SetHexMode() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetHexMode(ptr.Pointer())
	}
}

func (ptr *QLCDNumber) SetHexModeDefault() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetHexModeDefault(ptr.Pointer())
	}
}

func (ptr *QLCDNumber) SetMode(vql QLCDNumber__Mode) {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetMode(ptr.Pointer(), C.longlong(vql))
	}
}

//export callbackQLCDNumber_SetOctMode
func callbackQLCDNumber_SetOctMode(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setOctMode"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLCDNumberFromPointer(ptr).SetOctModeDefault()
	}
}

func (ptr *QLCDNumber) ConnectSetOctMode(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOctMode"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "setOctMode", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOctMode", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectSetOctMode() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOctMode")
	}
}

func (ptr *QLCDNumber) SetOctMode() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetOctMode(ptr.Pointer())
	}
}

func (ptr *QLCDNumber) SetOctModeDefault() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetOctModeDefault(ptr.Pointer())
	}
}

func (ptr *QLCDNumber) SetSegmentStyle(vql QLCDNumber__SegmentStyle) {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetSegmentStyle(ptr.Pointer(), C.longlong(vql))
	}
}

//export callbackQLCDNumber_SetSmallDecimalPoint
func callbackQLCDNumber_SetSmallDecimalPoint(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setSmallDecimalPoint"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQLCDNumberFromPointer(ptr).SetSmallDecimalPointDefault(int8(vbo) != 0)
	}
}

func (ptr *QLCDNumber) ConnectSetSmallDecimalPoint(f func(vbo bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setSmallDecimalPoint"); signal != nil {
			f := func(vbo bool) {
				(*(*func(bool))(signal))(vbo)
				f(vbo)
			}
			qt.ConnectSignal(ptr.Pointer(), "setSmallDecimalPoint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setSmallDecimalPoint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectSetSmallDecimalPoint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setSmallDecimalPoint")
	}
}

func (ptr *QLCDNumber) SetSmallDecimalPoint(vbo bool) {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetSmallDecimalPoint(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QLCDNumber) SetSmallDecimalPointDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QLCDNumber_SetSmallDecimalPointDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQLCDNumber_DestroyQLCDNumber
func callbackQLCDNumber_DestroyQLCDNumber(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QLCDNumber"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLCDNumberFromPointer(ptr).DestroyQLCDNumberDefault()
	}
}

func (ptr *QLCDNumber) ConnectDestroyQLCDNumber(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QLCDNumber"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QLCDNumber", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QLCDNumber", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLCDNumber) DisconnectDestroyQLCDNumber() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QLCDNumber")
	}
}

func (ptr *QLCDNumber) DestroyQLCDNumber() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_DestroyQLCDNumber(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLCDNumber) DestroyQLCDNumberDefault() {
	if ptr.Pointer() != nil {
		C.QLCDNumber_DestroyQLCDNumberDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLCDNumber) Mode() QLCDNumber__Mode {
	if ptr.Pointer() != nil {
		return QLCDNumber__Mode(C.QLCDNumber_Mode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLCDNumber) SegmentStyle() QLCDNumber__SegmentStyle {
	if ptr.Pointer() != nil {
		return QLCDNumber__SegmentStyle(C.QLCDNumber_SegmentStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLCDNumber) CheckOverflow(num float64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLCDNumber_CheckOverflow(ptr.Pointer(), C.double(num))) != 0
	}
	return false
}

func (ptr *QLCDNumber) CheckOverflow2(num int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLCDNumber_CheckOverflow2(ptr.Pointer(), C.int(int32(num)))) != 0
	}
	return false
}

func (ptr *QLCDNumber) SmallDecimalPoint() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLCDNumber_SmallDecimalPoint(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLCDNumber) Value() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QLCDNumber_Value(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLCDNumber) DigitCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLCDNumber_DigitCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLCDNumber) IntValue() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLCDNumber_IntValue(ptr.Pointer())))
	}
	return 0
}

type QLabel struct {
	QFrame
}

type QLabel_ITF interface {
	QFrame_ITF
	QLabel_PTR() *QLabel
}

func (ptr *QLabel) QLabel_PTR() *QLabel {
	return ptr
}

func (ptr *QLabel) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QFrame_PTR().Pointer()
	}
	return nil
}

func (ptr *QLabel) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QFrame_PTR().SetPointer(p)
	}
}

func PointerFromQLabel(ptr QLabel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLabel_PTR().Pointer()
	}
	return nil
}

func NewQLabelFromPointer(ptr unsafe.Pointer) (n *QLabel) {
	n = new(QLabel)
	n.SetPointer(ptr)
	return
}
func NewQLabel(parent QWidget_ITF, ff core.Qt__WindowType) *QLabel {
	tmpValue := NewQLabelFromPointer(C.QLabel_NewQLabel(PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQLabel2(text string, parent QWidget_ITF, ff core.Qt__WindowType) *QLabel {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQLabelFromPointer(C.QLabel_NewQLabel2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQLabel_Clear
func callbackQLabel_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLabelFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QLabel) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QLabel) Clear() {
	if ptr.Pointer() != nil {
		C.QLabel_Clear(ptr.Pointer())
	}
}

func (ptr *QLabel) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QLabel_ClearDefault(ptr.Pointer())
	}
}

//export callbackQLabel_LinkActivated
func callbackQLabel_LinkActivated(ptr unsafe.Pointer, link C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "linkActivated"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(link))
	}

}

func (ptr *QLabel) ConnectLinkActivated(f func(link string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "linkActivated") {
			C.QLabel_ConnectLinkActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "linkActivated"); signal != nil {
			f := func(link string) {
				(*(*func(string))(signal))(link)
				f(link)
			}
			qt.ConnectSignal(ptr.Pointer(), "linkActivated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "linkActivated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectLinkActivated() {
	if ptr.Pointer() != nil {
		C.QLabel_DisconnectLinkActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "linkActivated")
	}
}

func (ptr *QLabel) LinkActivated(link string) {
	if ptr.Pointer() != nil {
		var linkC *C.char
		if link != "" {
			linkC = C.CString(link)
			defer C.free(unsafe.Pointer(linkC))
		}
		C.QLabel_LinkActivated(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: linkC, len: C.longlong(len(link))})
	}
}

//export callbackQLabel_LinkHovered
func callbackQLabel_LinkHovered(ptr unsafe.Pointer, link C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "linkHovered"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(link))
	}

}

func (ptr *QLabel) ConnectLinkHovered(f func(link string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "linkHovered") {
			C.QLabel_ConnectLinkHovered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "linkHovered"); signal != nil {
			f := func(link string) {
				(*(*func(string))(signal))(link)
				f(link)
			}
			qt.ConnectSignal(ptr.Pointer(), "linkHovered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "linkHovered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectLinkHovered() {
	if ptr.Pointer() != nil {
		C.QLabel_DisconnectLinkHovered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "linkHovered")
	}
}

func (ptr *QLabel) LinkHovered(link string) {
	if ptr.Pointer() != nil {
		var linkC *C.char
		if link != "" {
			linkC = C.CString(link)
			defer C.free(unsafe.Pointer(linkC))
		}
		C.QLabel_LinkHovered(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: linkC, len: C.longlong(len(link))})
	}
}

func (ptr *QLabel) SetAlignment(vqt core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QLabel_SetAlignment(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QLabel) SetBuddy(buddy QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QLabel_SetBuddy(ptr.Pointer(), PointerFromQWidget(buddy))
	}
}

func (ptr *QLabel) SetIndent(vin int) {
	if ptr.Pointer() != nil {
		C.QLabel_SetIndent(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QLabel) SetMargin(vin int) {
	if ptr.Pointer() != nil {
		C.QLabel_SetMargin(ptr.Pointer(), C.int(int32(vin)))
	}
}

//export callbackQLabel_SetMovie
func callbackQLabel_SetMovie(ptr unsafe.Pointer, movie unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setMovie"); signal != nil {
		(*(*func(*gui.QMovie))(signal))(gui.NewQMovieFromPointer(movie))
	} else {
		NewQLabelFromPointer(ptr).SetMovieDefault(gui.NewQMovieFromPointer(movie))
	}
}

func (ptr *QLabel) ConnectSetMovie(f func(movie *gui.QMovie)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setMovie"); signal != nil {
			f := func(movie *gui.QMovie) {
				(*(*func(*gui.QMovie))(signal))(movie)
				f(movie)
			}
			qt.ConnectSignal(ptr.Pointer(), "setMovie", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setMovie", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectSetMovie() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setMovie")
	}
}

func (ptr *QLabel) SetMovie(movie gui.QMovie_ITF) {
	if ptr.Pointer() != nil {
		C.QLabel_SetMovie(ptr.Pointer(), gui.PointerFromQMovie(movie))
	}
}

func (ptr *QLabel) SetMovieDefault(movie gui.QMovie_ITF) {
	if ptr.Pointer() != nil {
		C.QLabel_SetMovieDefault(ptr.Pointer(), gui.PointerFromQMovie(movie))
	}
}

//export callbackQLabel_SetNum2
func callbackQLabel_SetNum2(ptr unsafe.Pointer, num C.double) {
	if signal := qt.GetSignal(ptr, "setNum2"); signal != nil {
		(*(*func(float64))(signal))(float64(num))
	} else {
		NewQLabelFromPointer(ptr).SetNum2Default(float64(num))
	}
}

func (ptr *QLabel) ConnectSetNum2(f func(num float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setNum2"); signal != nil {
			f := func(num float64) {
				(*(*func(float64))(signal))(num)
				f(num)
			}
			qt.ConnectSignal(ptr.Pointer(), "setNum2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setNum2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectSetNum2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setNum2")
	}
}

func (ptr *QLabel) SetNum2(num float64) {
	if ptr.Pointer() != nil {
		C.QLabel_SetNum2(ptr.Pointer(), C.double(num))
	}
}

func (ptr *QLabel) SetNum2Default(num float64) {
	if ptr.Pointer() != nil {
		C.QLabel_SetNum2Default(ptr.Pointer(), C.double(num))
	}
}

//export callbackQLabel_SetNum
func callbackQLabel_SetNum(ptr unsafe.Pointer, num C.int) {
	if signal := qt.GetSignal(ptr, "setNum"); signal != nil {
		(*(*func(int))(signal))(int(int32(num)))
	} else {
		NewQLabelFromPointer(ptr).SetNumDefault(int(int32(num)))
	}
}

func (ptr *QLabel) ConnectSetNum(f func(num int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setNum"); signal != nil {
			f := func(num int) {
				(*(*func(int))(signal))(num)
				f(num)
			}
			qt.ConnectSignal(ptr.Pointer(), "setNum", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setNum", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectSetNum() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setNum")
	}
}

func (ptr *QLabel) SetNum(num int) {
	if ptr.Pointer() != nil {
		C.QLabel_SetNum(ptr.Pointer(), C.int(int32(num)))
	}
}

func (ptr *QLabel) SetNumDefault(num int) {
	if ptr.Pointer() != nil {
		C.QLabel_SetNumDefault(ptr.Pointer(), C.int(int32(num)))
	}
}

func (ptr *QLabel) SetOpenExternalLinks(open bool) {
	if ptr.Pointer() != nil {
		C.QLabel_SetOpenExternalLinks(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(open))))
	}
}

//export callbackQLabel_SetPicture
func callbackQLabel_SetPicture(ptr unsafe.Pointer, picture unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setPicture"); signal != nil {
		(*(*func(*gui.QPicture))(signal))(gui.NewQPictureFromPointer(picture))
	} else {
		NewQLabelFromPointer(ptr).SetPictureDefault(gui.NewQPictureFromPointer(picture))
	}
}

func (ptr *QLabel) ConnectSetPicture(f func(picture *gui.QPicture)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setPicture"); signal != nil {
			f := func(picture *gui.QPicture) {
				(*(*func(*gui.QPicture))(signal))(picture)
				f(picture)
			}
			qt.ConnectSignal(ptr.Pointer(), "setPicture", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setPicture", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectSetPicture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setPicture")
	}
}

func (ptr *QLabel) SetPicture(picture gui.QPicture_ITF) {
	if ptr.Pointer() != nil {
		C.QLabel_SetPicture(ptr.Pointer(), gui.PointerFromQPicture(picture))
	}
}

func (ptr *QLabel) SetPictureDefault(picture gui.QPicture_ITF) {
	if ptr.Pointer() != nil {
		C.QLabel_SetPictureDefault(ptr.Pointer(), gui.PointerFromQPicture(picture))
	}
}

//export callbackQLabel_SetPixmap
func callbackQLabel_SetPixmap(ptr unsafe.Pointer, vqp unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setPixmap"); signal != nil {
		(*(*func(*gui.QPixmap))(signal))(gui.NewQPixmapFromPointer(vqp))
	} else {
		NewQLabelFromPointer(ptr).SetPixmapDefault(gui.NewQPixmapFromPointer(vqp))
	}
}

func (ptr *QLabel) ConnectSetPixmap(f func(vqp *gui.QPixmap)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setPixmap"); signal != nil {
			f := func(vqp *gui.QPixmap) {
				(*(*func(*gui.QPixmap))(signal))(vqp)
				f(vqp)
			}
			qt.ConnectSignal(ptr.Pointer(), "setPixmap", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setPixmap", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectSetPixmap() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setPixmap")
	}
}

func (ptr *QLabel) SetPixmap(vqp gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QLabel_SetPixmap(ptr.Pointer(), gui.PointerFromQPixmap(vqp))
	}
}

func (ptr *QLabel) SetPixmapDefault(vqp gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QLabel_SetPixmapDefault(ptr.Pointer(), gui.PointerFromQPixmap(vqp))
	}
}

func (ptr *QLabel) SetScaledContents(vbo bool) {
	if ptr.Pointer() != nil {
		C.QLabel_SetScaledContents(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QLabel) SetSelection(start int, length int) {
	if ptr.Pointer() != nil {
		C.QLabel_SetSelection(ptr.Pointer(), C.int(int32(start)), C.int(int32(length)))
	}
}

//export callbackQLabel_SetText
func callbackQLabel_SetText(ptr unsafe.Pointer, vqs C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(vqs))
	} else {
		NewQLabelFromPointer(ptr).SetTextDefault(cGoUnpackString(vqs))
	}
}

func (ptr *QLabel) ConnectSetText(f func(vqs string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setText"); signal != nil {
			f := func(vqs string) {
				(*(*func(string))(signal))(vqs)
				f(vqs)
			}
			qt.ConnectSignal(ptr.Pointer(), "setText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectSetText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setText")
	}
}

func (ptr *QLabel) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QLabel_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QLabel) SetTextDefault(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QLabel_SetTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QLabel) SetTextFormat(vqt core.Qt__TextFormat) {
	if ptr.Pointer() != nil {
		C.QLabel_SetTextFormat(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QLabel) SetTextInteractionFlags(flags core.Qt__TextInteractionFlag) {
	if ptr.Pointer() != nil {
		C.QLabel_SetTextInteractionFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QLabel) SetWordWrap(on bool) {
	if ptr.Pointer() != nil {
		C.QLabel_SetWordWrap(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

//export callbackQLabel_DestroyQLabel
func callbackQLabel_DestroyQLabel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QLabel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLabelFromPointer(ptr).DestroyQLabelDefault()
	}
}

func (ptr *QLabel) ConnectDestroyQLabel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QLabel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QLabel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QLabel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLabel) DisconnectDestroyQLabel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QLabel")
	}
}

func (ptr *QLabel) DestroyQLabel() {
	if ptr.Pointer() != nil {
		C.QLabel_DestroyQLabel(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLabel) DestroyQLabelDefault() {
	if ptr.Pointer() != nil {
		C.QLabel_DestroyQLabelDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLabel) Movie() *gui.QMovie {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQMovieFromPointer(C.QLabel_Movie(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLabel) SelectedText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLabel_SelectedText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLabel) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLabel_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLabel) Buddy() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QLabel_Buddy(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLabel) Alignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QLabel_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLabel) TextFormat() core.Qt__TextFormat {
	if ptr.Pointer() != nil {
		return core.Qt__TextFormat(C.QLabel_TextFormat(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLabel) TextInteractionFlags() core.Qt__TextInteractionFlag {
	if ptr.Pointer() != nil {
		return core.Qt__TextInteractionFlag(C.QLabel_TextInteractionFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLabel) HasScaledContents() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLabel_HasScaledContents(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLabel) HasSelectedText() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLabel_HasSelectedText(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLabel) OpenExternalLinks() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLabel_OpenExternalLinks(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLabel) WordWrap() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLabel_WordWrap(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLabel) Picture() *gui.QPicture {
	if ptr.Pointer() != nil {
		return gui.NewQPictureFromPointer(C.QLabel_Picture(ptr.Pointer()))
	}
	return nil
}

func (ptr *QLabel) Pixmap() *gui.QPixmap {
	if ptr.Pointer() != nil {
		return gui.NewQPixmapFromPointer(C.QLabel_Pixmap(ptr.Pointer()))
	}
	return nil
}

func (ptr *QLabel) Indent() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLabel_Indent(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLabel) Margin() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLabel_Margin(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLabel) SelectionStart() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLabel_SelectionStart(ptr.Pointer())))
	}
	return 0
}

type QLayout struct {
	core.QObject
	QLayoutItem
}

type QLayout_ITF interface {
	core.QObject_ITF
	QLayoutItem_ITF
	QLayout_PTR() *QLayout
}

func (ptr *QLayout) QLayout_PTR() *QLayout {
	return ptr
}

func (ptr *QLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
		ptr.QLayoutItem_PTR().SetPointer(p)
	}
}

func PointerFromQLayout(ptr QLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLayout_PTR().Pointer()
	}
	return nil
}

func NewQLayoutFromPointer(ptr unsafe.Pointer) (n *QLayout) {
	n = new(QLayout)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QLayout__SizeConstraint
//QLayout::SizeConstraint
type QLayout__SizeConstraint int64

const (
	QLayout__SetDefaultConstraint QLayout__SizeConstraint = QLayout__SizeConstraint(0)
	QLayout__SetNoConstraint      QLayout__SizeConstraint = QLayout__SizeConstraint(1)
	QLayout__SetMinimumSize       QLayout__SizeConstraint = QLayout__SizeConstraint(2)
	QLayout__SetFixedSize         QLayout__SizeConstraint = QLayout__SizeConstraint(3)
	QLayout__SetMaximumSize       QLayout__SizeConstraint = QLayout__SizeConstraint(4)
	QLayout__SetMinAndMaxSize     QLayout__SizeConstraint = QLayout__SizeConstraint(5)
)

func NewQLayout2() *QLayout {
	tmpValue := NewQLayoutFromPointer(C.QLayout_NewQLayout2())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQLayout(parent QWidget_ITF) *QLayout {
	tmpValue := NewQLayoutFromPointer(C.QLayout_NewQLayout(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QLayout) ReplaceWidget(from QWidget_ITF, to QWidget_ITF, options core.Qt__FindChildOption) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QLayout_ReplaceWidget(ptr.Pointer(), PointerFromQWidget(from), PointerFromQWidget(to), C.longlong(options)))
	}
	return nil
}

//export callbackQLayout_TakeAt
func callbackQLayout_TakeAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "takeAt"); signal != nil {
		return PointerFromQLayoutItem((*(*func(int) *QLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQLayoutItem(NewQLayoutItem(0))
}

func (ptr *QLayout) ConnectTakeAt(f func(index int) *QLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "takeAt"); signal != nil {
			f := func(index int) *QLayoutItem {
				(*(*func(int) *QLayoutItem)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "takeAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "takeAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectTakeAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "takeAt")
	}
}

func (ptr *QLayout) TakeAt(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QLayout_TakeAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func QLayout_ClosestAcceptableSize(widget QWidget_ITF, size core.QSize_ITF) *core.QSize {
	tmpValue := core.NewQSizeFromPointer(C.QLayout_QLayout_ClosestAcceptableSize(PointerFromQWidget(widget), core.PointerFromQSize(size)))
	runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
	return tmpValue
}

func (ptr *QLayout) ClosestAcceptableSize(widget QWidget_ITF, size core.QSize_ITF) *core.QSize {
	tmpValue := core.NewQSizeFromPointer(C.QLayout_QLayout_ClosestAcceptableSize(PointerFromQWidget(widget), core.PointerFromQSize(size)))
	runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
	return tmpValue
}

func QLayout_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QLayout_QLayout_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QLayout) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QLayout_QLayout_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QLayout) Activate() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_Activate(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLayout) SetAlignment2(l QLayout_ITF, alignment core.Qt__AlignmentFlag) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_SetAlignment2(ptr.Pointer(), PointerFromQLayout(l), C.longlong(alignment))) != 0
	}
	return false
}

func (ptr *QLayout) SetAlignment(w QWidget_ITF, alignment core.Qt__AlignmentFlag) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_SetAlignment(ptr.Pointer(), PointerFromQWidget(w), C.longlong(alignment))) != 0
	}
	return false
}

func (ptr *QLayout) AddChildLayout(l QLayout_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_AddChildLayout(ptr.Pointer(), PointerFromQLayout(l))
	}
}

func (ptr *QLayout) AddChildWidget(w QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_AddChildWidget(ptr.Pointer(), PointerFromQWidget(w))
	}
}

//export callbackQLayout_AddItem
func callbackQLayout_AddItem(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "addItem"); signal != nil {
		(*(*func(*QLayoutItem))(signal))(NewQLayoutItemFromPointer(item))
	}

}

func (ptr *QLayout) ConnectAddItem(f func(item *QLayoutItem)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "addItem"); signal != nil {
			f := func(item *QLayoutItem) {
				(*(*func(*QLayoutItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "addItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "addItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectAddItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "addItem")
	}
}

func (ptr *QLayout) AddItem(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_AddItem(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

func (ptr *QLayout) AddWidget(w QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_AddWidget(ptr.Pointer(), PointerFromQWidget(w))
	}
}

//export callbackQLayout_ChildEvent
func callbackQLayout_ChildEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(e))
	} else {
		NewQLayoutFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(e))
	}
}

func (ptr *QLayout) ConnectChildEvent(f func(e *core.QChildEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "childEvent"); signal != nil {
			f := func(e *core.QChildEvent) {
				(*(*func(*core.QChildEvent))(signal))(e)
				f(e)
			}
			qt.ConnectSignal(ptr.Pointer(), "childEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "childEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectChildEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "childEvent")
	}
}

func (ptr *QLayout) ChildEvent(e core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(e))
	}
}

func (ptr *QLayout) ChildEventDefault(e core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(e))
	}
}

func (ptr *QLayout) RemoveItem(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_RemoveItem(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

func (ptr *QLayout) RemoveWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_RemoveWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QLayout) SetContentsMargins2(margins core.QMargins_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_SetContentsMargins2(ptr.Pointer(), core.PointerFromQMargins(margins))
	}
}

func (ptr *QLayout) SetContentsMargins(left int, top int, right int, bottom int) {
	if ptr.Pointer() != nil {
		C.QLayout_SetContentsMargins(ptr.Pointer(), C.int(int32(left)), C.int(int32(top)), C.int(int32(right)), C.int(int32(bottom)))
	}
}

func (ptr *QLayout) SetEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QLayout_SetEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQLayout_SetGeometry
func callbackQLayout_SetGeometry(ptr unsafe.Pointer, r unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setGeometry"); signal != nil {
		(*(*func(*core.QRect))(signal))(core.NewQRectFromPointer(r))
	} else {
		NewQLayoutFromPointer(ptr).SetGeometryDefault(core.NewQRectFromPointer(r))
	}
}

func (ptr *QLayout) ConnectSetGeometry(f func(r *core.QRect)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setGeometry"); signal != nil {
			f := func(r *core.QRect) {
				(*(*func(*core.QRect))(signal))(r)
				f(r)
			}
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectSetGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setGeometry")
	}
}

func (ptr *QLayout) SetGeometry(r core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_SetGeometry(ptr.Pointer(), core.PointerFromQRect(r))
	}
}

func (ptr *QLayout) SetGeometryDefault(r core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_SetGeometryDefault(ptr.Pointer(), core.PointerFromQRect(r))
	}
}

func (ptr *QLayout) SetMenuBar(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_SetMenuBar(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QLayout) SetSizeConstraint(vql QLayout__SizeConstraint) {
	if ptr.Pointer() != nil {
		C.QLayout_SetSizeConstraint(ptr.Pointer(), C.longlong(vql))
	}
}

func (ptr *QLayout) SetSpacing(vin int) {
	if ptr.Pointer() != nil {
		C.QLayout_SetSpacing(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QLayout) Update() {
	if ptr.Pointer() != nil {
		C.QLayout_Update(ptr.Pointer())
	}
}

func (ptr *QLayout) SizeConstraint() QLayout__SizeConstraint {
	if ptr.Pointer() != nil {
		return QLayout__SizeConstraint(C.QLayout_SizeConstraint(ptr.Pointer()))
	}
	return 0
}

//export callbackQLayout_ItemAt
func callbackQLayout_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemAt"); signal != nil {
		return PointerFromQLayoutItem((*(*func(int) *QLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQLayoutItem(NewQLayoutItem(0))
}

func (ptr *QLayout) ConnectItemAt(f func(index int) *QLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemAt"); signal != nil {
			f := func(index int) *QLayoutItem {
				(*(*func(int) *QLayoutItem)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectItemAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemAt")
	}
}

func (ptr *QLayout) ItemAt(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QLayout_ItemAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QLayout) ContentsMargins() *core.QMargins {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMarginsFromPointer(C.QLayout_ContentsMargins(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QMargins).DestroyQMargins)
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) AlignmentRect(r core.QRect_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QLayout_AlignmentRect(ptr.Pointer(), core.PointerFromQRect(r)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) ContentsRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QLayout_ContentsRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQLayout_Geometry
func callbackQLayout_Geometry(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "geometry"); signal != nil {
		return core.PointerFromQRect((*(*func() *core.QRect)(signal))())
	}

	return core.PointerFromQRect(NewQLayoutFromPointer(ptr).GeometryDefault())
}

func (ptr *QLayout) ConnectGeometry(f func() *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "geometry"); signal != nil {
			f := func() *core.QRect {
				(*(*func() *core.QRect)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "geometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "geometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "geometry")
	}
}

func (ptr *QLayout) Geometry() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QLayout_Geometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) GeometryDefault() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QLayout_GeometryDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQLayout_MaximumSize
func callbackQLayout_MaximumSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "maximumSize"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQLayoutFromPointer(ptr).MaximumSizeDefault())
}

func (ptr *QLayout) ConnectMaximumSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "maximumSize"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "maximumSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "maximumSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectMaximumSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "maximumSize")
	}
}

func (ptr *QLayout) MaximumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QLayout_MaximumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) MaximumSizeDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QLayout_MaximumSizeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQLayout_MinimumSize
func callbackQLayout_MinimumSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "minimumSize"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQLayoutFromPointer(ptr).MinimumSizeDefault())
}

func (ptr *QLayout) ConnectMinimumSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "minimumSize"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "minimumSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "minimumSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectMinimumSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "minimumSize")
	}
}

func (ptr *QLayout) MinimumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QLayout_MinimumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) MinimumSizeDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QLayout_MinimumSizeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) MenuBar() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QLayout_MenuBar(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) ParentWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QLayout_ParentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQLayout_ExpandingDirections
func callbackQLayout_ExpandingDirections(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "expandingDirections"); signal != nil {
		return C.longlong((*(*func() core.Qt__Orientation)(signal))())
	}

	return C.longlong(NewQLayoutFromPointer(ptr).ExpandingDirectionsDefault())
}

func (ptr *QLayout) ConnectExpandingDirections(f func() core.Qt__Orientation) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "expandingDirections"); signal != nil {
			f := func() core.Qt__Orientation {
				(*(*func() core.Qt__Orientation)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "expandingDirections", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "expandingDirections", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectExpandingDirections() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "expandingDirections")
	}
}

func (ptr *QLayout) ExpandingDirections() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QLayout_ExpandingDirections(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLayout) ExpandingDirectionsDefault() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QLayout_ExpandingDirectionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQLayout_IsEmpty
func callbackQLayout_IsEmpty(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isEmpty"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQLayoutFromPointer(ptr).IsEmptyDefault())))
}

func (ptr *QLayout) ConnectIsEmpty(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isEmpty"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectIsEmpty() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isEmpty")
	}
}

func (ptr *QLayout) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLayout) IsEmptyDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_IsEmptyDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLayout) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_IsEnabled(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQLayout_MetaObject
func callbackQLayout_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQLayoutFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QLayout) ConnectMetaObject(f func() *core.QMetaObject) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "metaObject"); signal != nil {
			f := func() *core.QMetaObject {
				(*(*func() *core.QMetaObject)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "metaObject", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "metaObject", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectMetaObject() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "metaObject")
	}
}

func (ptr *QLayout) MetaObject() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QLayout_MetaObject(ptr.Pointer()))
	}
	return nil
}

func (ptr *QLayout) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QLayout_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQLayout_Count
func callbackQLayout_Count(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "count"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(0))
}

func (ptr *QLayout) ConnectCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "count"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "count")
	}
}

func (ptr *QLayout) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLayout_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLayout) IndexOf2(layoutItem QLayoutItem_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLayout_IndexOf2(ptr.Pointer(), PointerFromQLayoutItem(layoutItem))))
	}
	return 0
}

//export callbackQLayout_IndexOf
func callbackQLayout_IndexOf(ptr unsafe.Pointer, widget unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "indexOf"); signal != nil {
		return C.int(int32((*(*func(*QWidget) int)(signal))(NewQWidgetFromPointer(widget))))
	}

	return C.int(int32(NewQLayoutFromPointer(ptr).IndexOfDefault(NewQWidgetFromPointer(widget))))
}

func (ptr *QLayout) ConnectIndexOf(f func(widget *QWidget) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "indexOf"); signal != nil {
			f := func(widget *QWidget) int {
				(*(*func(*QWidget) int)(signal))(widget)
				return f(widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "indexOf", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "indexOf", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayout) DisconnectIndexOf() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "indexOf")
	}
}

func (ptr *QLayout) IndexOf(widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLayout_IndexOf(ptr.Pointer(), PointerFromQWidget(widget))))
	}
	return 0
}

func (ptr *QLayout) IndexOfDefault(widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLayout_IndexOfDefault(ptr.Pointer(), PointerFromQWidget(widget))))
	}
	return 0
}

func (ptr *QLayout) Spacing() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLayout_Spacing(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLayout) GetContentsMargins(left int, top int, right int, bottom int) {
	if ptr.Pointer() != nil {
		C.QLayout_GetContentsMargins(ptr.Pointer(), C.int(int32(left)), C.int(int32(top)), C.int(int32(right)), C.int(int32(bottom)))
	}
}

func (ptr *QLayout) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QLayout___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QLayout) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QLayout___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QLayout) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QLayout___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QLayout) __findChildren_newList2() unsafe.Pointer {
	return C.QLayout___findChildren_newList2(ptr.Pointer())
}

func (ptr *QLayout) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QLayout___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QLayout) __findChildren_newList3() unsafe.Pointer {
	return C.QLayout___findChildren_newList3(ptr.Pointer())
}

func (ptr *QLayout) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QLayout___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QLayout) __findChildren_newList() unsafe.Pointer {
	return C.QLayout___findChildren_newList(ptr.Pointer())
}

func (ptr *QLayout) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QLayout___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QLayout) __children_newList() unsafe.Pointer {
	return C.QLayout___children_newList(ptr.Pointer())
}

//export callbackQLayout_Event
func callbackQLayout_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQLayoutFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QLayout) Event(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_Event(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

func (ptr *QLayout) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQLayout_EventFilter
func callbackQLayout_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQLayoutFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QLayout) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QLayout) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayout_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQLayout_ConnectNotify
func callbackQLayout_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQLayoutFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QLayout) ConnectNotify(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

func (ptr *QLayout) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQLayout_CustomEvent
func callbackQLayout_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQLayoutFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QLayout) CustomEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QLayout) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQLayout_DeleteLater
func callbackQLayout_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLayoutFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QLayout) DeleteLater() {
	if ptr.Pointer() != nil {
		C.QLayout_DeleteLater(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLayout) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QLayout_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQLayout_Destroyed
func callbackQLayout_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQLayout_DisconnectNotify
func callbackQLayout_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQLayoutFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QLayout) DisconnectNotify(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

func (ptr *QLayout) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQLayout_ObjectNameChanged
func callbackQLayout_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQLayout_TimerEvent
func callbackQLayout_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQLayoutFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QLayout) TimerEvent(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QLayout) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QLayout_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

//export callbackQLayout_SizeHint
func callbackQLayout_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQLayoutFromPointer(ptr).SizeHintDefault())
}

func (ptr *QLayout) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QLayout_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QLayout) SizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QLayout_SizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

type QLayoutItem struct {
	ptr unsafe.Pointer
}

type QLayoutItem_ITF interface {
	QLayoutItem_PTR() *QLayoutItem
}

func (ptr *QLayoutItem) QLayoutItem_PTR() *QLayoutItem {
	return ptr
}

func (ptr *QLayoutItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QLayoutItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQLayoutItem(ptr QLayoutItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLayoutItem_PTR().Pointer()
	}
	return nil
}

func NewQLayoutItemFromPointer(ptr unsafe.Pointer) (n *QLayoutItem) {
	n = new(QLayoutItem)
	n.SetPointer(ptr)
	return
}

//export callbackQLayoutItem_Layout
func callbackQLayoutItem_Layout(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "layout"); signal != nil {
		return PointerFromQLayout((*(*func() *QLayout)(signal))())
	}

	return PointerFromQLayout(NewQLayoutItemFromPointer(ptr).LayoutDefault())
}

func (ptr *QLayoutItem) ConnectLayout(f func() *QLayout) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "layout"); signal != nil {
			f := func() *QLayout {
				(*(*func() *QLayout)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "layout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "layout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "layout")
	}
}

func (ptr *QLayoutItem) Layout() *QLayout {
	if ptr.Pointer() != nil {
		tmpValue := NewQLayoutFromPointer(C.QLayoutItem_Layout(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLayoutItem) LayoutDefault() *QLayout {
	if ptr.Pointer() != nil {
		tmpValue := NewQLayoutFromPointer(C.QLayoutItem_LayoutDefault(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQLayoutItem(alignment core.Qt__AlignmentFlag) *QLayoutItem {
	return NewQLayoutItemFromPointer(C.QLayoutItem_NewQLayoutItem(C.longlong(alignment)))
}

//export callbackQLayoutItem_SpacerItem
func callbackQLayoutItem_SpacerItem(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "spacerItem"); signal != nil {
		return PointerFromQSpacerItem((*(*func() *QSpacerItem)(signal))())
	}

	return PointerFromQSpacerItem(NewQLayoutItemFromPointer(ptr).SpacerItemDefault())
}

func (ptr *QLayoutItem) ConnectSpacerItem(f func() *QSpacerItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "spacerItem"); signal != nil {
			f := func() *QSpacerItem {
				(*(*func() *QSpacerItem)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "spacerItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "spacerItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectSpacerItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "spacerItem")
	}
}

func (ptr *QLayoutItem) SpacerItem() *QSpacerItem {
	if ptr.Pointer() != nil {
		return NewQSpacerItemFromPointer(C.QLayoutItem_SpacerItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QLayoutItem) SpacerItemDefault() *QSpacerItem {
	if ptr.Pointer() != nil {
		return NewQSpacerItemFromPointer(C.QLayoutItem_SpacerItemDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQLayoutItem_Widget
func callbackQLayoutItem_Widget(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "widget"); signal != nil {
		return PointerFromQWidget((*(*func() *QWidget)(signal))())
	}

	return PointerFromQWidget(NewQLayoutItemFromPointer(ptr).WidgetDefault())
}

func (ptr *QLayoutItem) ConnectWidget(f func() *QWidget) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "widget"); signal != nil {
			f := func() *QWidget {
				(*(*func() *QWidget)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "widget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "widget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "widget")
	}
}

func (ptr *QLayoutItem) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QLayoutItem_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLayoutItem) WidgetDefault() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QLayoutItem_WidgetDefault(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQLayoutItem_Invalidate
func callbackQLayoutItem_Invalidate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "invalidate"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLayoutItemFromPointer(ptr).InvalidateDefault()
	}
}

func (ptr *QLayoutItem) ConnectInvalidate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "invalidate"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "invalidate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "invalidate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectInvalidate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "invalidate")
	}
}

func (ptr *QLayoutItem) Invalidate() {
	if ptr.Pointer() != nil {
		C.QLayoutItem_Invalidate(ptr.Pointer())
	}
}

func (ptr *QLayoutItem) InvalidateDefault() {
	if ptr.Pointer() != nil {
		C.QLayoutItem_InvalidateDefault(ptr.Pointer())
	}
}

func (ptr *QLayoutItem) SetAlignment(alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QLayoutItem_SetAlignment(ptr.Pointer(), C.longlong(alignment))
	}
}

//export callbackQLayoutItem_SetGeometry
func callbackQLayoutItem_SetGeometry(ptr unsafe.Pointer, r unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setGeometry"); signal != nil {
		(*(*func(*core.QRect))(signal))(core.NewQRectFromPointer(r))
	}

}

func (ptr *QLayoutItem) ConnectSetGeometry(f func(r *core.QRect)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setGeometry"); signal != nil {
			f := func(r *core.QRect) {
				(*(*func(*core.QRect))(signal))(r)
				f(r)
			}
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectSetGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setGeometry")
	}
}

func (ptr *QLayoutItem) SetGeometry(r core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QLayoutItem_SetGeometry(ptr.Pointer(), core.PointerFromQRect(r))
	}
}

//export callbackQLayoutItem_DestroyQLayoutItem
func callbackQLayoutItem_DestroyQLayoutItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QLayoutItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLayoutItemFromPointer(ptr).DestroyQLayoutItemDefault()
	}
}

func (ptr *QLayoutItem) ConnectDestroyQLayoutItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QLayoutItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QLayoutItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QLayoutItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectDestroyQLayoutItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QLayoutItem")
	}
}

func (ptr *QLayoutItem) DestroyQLayoutItem() {
	if ptr.Pointer() != nil {
		C.QLayoutItem_DestroyQLayoutItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLayoutItem) DestroyQLayoutItemDefault() {
	if ptr.Pointer() != nil {
		C.QLayoutItem_DestroyQLayoutItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQLayoutItem_Geometry
func callbackQLayoutItem_Geometry(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "geometry"); signal != nil {
		return core.PointerFromQRect((*(*func() *core.QRect)(signal))())
	}

	return core.PointerFromQRect(core.NewQRect())
}

func (ptr *QLayoutItem) ConnectGeometry(f func() *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "geometry"); signal != nil {
			f := func() *core.QRect {
				(*(*func() *core.QRect)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "geometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "geometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "geometry")
	}
}

func (ptr *QLayoutItem) Geometry() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QLayoutItem_Geometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQLayoutItem_MaximumSize
func callbackQLayoutItem_MaximumSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "maximumSize"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(core.NewQSize())
}

func (ptr *QLayoutItem) ConnectMaximumSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "maximumSize"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "maximumSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "maximumSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectMaximumSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "maximumSize")
	}
}

func (ptr *QLayoutItem) MaximumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QLayoutItem_MaximumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQLayoutItem_MinimumSize
func callbackQLayoutItem_MinimumSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "minimumSize"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(core.NewQSize())
}

func (ptr *QLayoutItem) ConnectMinimumSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "minimumSize"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "minimumSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "minimumSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectMinimumSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "minimumSize")
	}
}

func (ptr *QLayoutItem) MinimumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QLayoutItem_MinimumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQLayoutItem_SizeHint
func callbackQLayoutItem_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(core.NewQSize())
}

func (ptr *QLayoutItem) ConnectSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QLayoutItem) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QLayoutItem_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQLayoutItem_ControlTypes
func callbackQLayoutItem_ControlTypes(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "controlTypes"); signal != nil {
		return C.longlong((*(*func() QSizePolicy__ControlType)(signal))())
	}

	return C.longlong(NewQLayoutItemFromPointer(ptr).ControlTypesDefault())
}

func (ptr *QLayoutItem) ConnectControlTypes(f func() QSizePolicy__ControlType) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "controlTypes"); signal != nil {
			f := func() QSizePolicy__ControlType {
				(*(*func() QSizePolicy__ControlType)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "controlTypes", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "controlTypes", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectControlTypes() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "controlTypes")
	}
}

func (ptr *QLayoutItem) ControlTypes() QSizePolicy__ControlType {
	if ptr.Pointer() != nil {
		return QSizePolicy__ControlType(C.QLayoutItem_ControlTypes(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLayoutItem) ControlTypesDefault() QSizePolicy__ControlType {
	if ptr.Pointer() != nil {
		return QSizePolicy__ControlType(C.QLayoutItem_ControlTypesDefault(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLayoutItem) Alignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QLayoutItem_Alignment(ptr.Pointer()))
	}
	return 0
}

//export callbackQLayoutItem_ExpandingDirections
func callbackQLayoutItem_ExpandingDirections(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "expandingDirections"); signal != nil {
		return C.longlong((*(*func() core.Qt__Orientation)(signal))())
	}

	return C.longlong(0)
}

func (ptr *QLayoutItem) ConnectExpandingDirections(f func() core.Qt__Orientation) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "expandingDirections"); signal != nil {
			f := func() core.Qt__Orientation {
				(*(*func() core.Qt__Orientation)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "expandingDirections", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "expandingDirections", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectExpandingDirections() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "expandingDirections")
	}
}

func (ptr *QLayoutItem) ExpandingDirections() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QLayoutItem_ExpandingDirections(ptr.Pointer()))
	}
	return 0
}

//export callbackQLayoutItem_HasHeightForWidth
func callbackQLayoutItem_HasHeightForWidth(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "hasHeightForWidth"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQLayoutItemFromPointer(ptr).HasHeightForWidthDefault())))
}

func (ptr *QLayoutItem) ConnectHasHeightForWidth(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hasHeightForWidth"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "hasHeightForWidth", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hasHeightForWidth", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectHasHeightForWidth() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hasHeightForWidth")
	}
}

func (ptr *QLayoutItem) HasHeightForWidth() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayoutItem_HasHeightForWidth(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLayoutItem) HasHeightForWidthDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayoutItem_HasHeightForWidthDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQLayoutItem_IsEmpty
func callbackQLayoutItem_IsEmpty(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isEmpty"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(false)))
}

func (ptr *QLayoutItem) ConnectIsEmpty(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isEmpty"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectIsEmpty() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isEmpty")
	}
}

func (ptr *QLayoutItem) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLayoutItem_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQLayoutItem_HeightForWidth
func callbackQLayoutItem_HeightForWidth(ptr unsafe.Pointer, vin C.int) C.int {
	if signal := qt.GetSignal(ptr, "heightForWidth"); signal != nil {
		return C.int(int32((*(*func(int) int)(signal))(int(int32(vin)))))
	}

	return C.int(int32(NewQLayoutItemFromPointer(ptr).HeightForWidthDefault(int(int32(vin)))))
}

func (ptr *QLayoutItem) ConnectHeightForWidth(f func(vin int) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "heightForWidth"); signal != nil {
			f := func(vin int) int {
				(*(*func(int) int)(signal))(vin)
				return f(vin)
			}
			qt.ConnectSignal(ptr.Pointer(), "heightForWidth", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "heightForWidth", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectHeightForWidth() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "heightForWidth")
	}
}

func (ptr *QLayoutItem) HeightForWidth(vin int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLayoutItem_HeightForWidth(ptr.Pointer(), C.int(int32(vin)))))
	}
	return 0
}

func (ptr *QLayoutItem) HeightForWidthDefault(vin int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLayoutItem_HeightForWidthDefault(ptr.Pointer(), C.int(int32(vin)))))
	}
	return 0
}

//export callbackQLayoutItem_MinimumHeightForWidth
func callbackQLayoutItem_MinimumHeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
	if signal := qt.GetSignal(ptr, "minimumHeightForWidth"); signal != nil {
		return C.int(int32((*(*func(int) int)(signal))(int(int32(w)))))
	}

	return C.int(int32(NewQLayoutItemFromPointer(ptr).MinimumHeightForWidthDefault(int(int32(w)))))
}

func (ptr *QLayoutItem) ConnectMinimumHeightForWidth(f func(w int) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "minimumHeightForWidth"); signal != nil {
			f := func(w int) int {
				(*(*func(int) int)(signal))(w)
				return f(w)
			}
			qt.ConnectSignal(ptr.Pointer(), "minimumHeightForWidth", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "minimumHeightForWidth", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLayoutItem) DisconnectMinimumHeightForWidth() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "minimumHeightForWidth")
	}
}

func (ptr *QLayoutItem) MinimumHeightForWidth(w int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLayoutItem_MinimumHeightForWidth(ptr.Pointer(), C.int(int32(w)))))
	}
	return 0
}

func (ptr *QLayoutItem) MinimumHeightForWidthDefault(w int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLayoutItem_MinimumHeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
	}
	return 0
}

func (ptr *QLayoutItem) Align() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QLayoutItem_Align(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLayoutItem) SetAlign(vqt core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QLayoutItem_SetAlign(ptr.Pointer(), C.longlong(vqt))
	}
}

type QLineEdit struct {
	QWidget
}

type QLineEdit_ITF interface {
	QWidget_ITF
	QLineEdit_PTR() *QLineEdit
}

func (ptr *QLineEdit) QLineEdit_PTR() *QLineEdit {
	return ptr
}

func (ptr *QLineEdit) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QLineEdit) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQLineEdit(ptr QLineEdit_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLineEdit_PTR().Pointer()
	}
	return nil
}

func NewQLineEditFromPointer(ptr unsafe.Pointer) (n *QLineEdit) {
	n = new(QLineEdit)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QLineEdit__ActionPosition
//QLineEdit::ActionPosition
type QLineEdit__ActionPosition int64

const (
	QLineEdit__LeadingPosition  QLineEdit__ActionPosition = QLineEdit__ActionPosition(0)
	QLineEdit__TrailingPosition QLineEdit__ActionPosition = QLineEdit__ActionPosition(1)
)

//go:generate stringer -type=QLineEdit__EchoMode
//QLineEdit::EchoMode
type QLineEdit__EchoMode int64

const (
	QLineEdit__Normal             QLineEdit__EchoMode = QLineEdit__EchoMode(0)
	QLineEdit__NoEcho             QLineEdit__EchoMode = QLineEdit__EchoMode(1)
	QLineEdit__Password           QLineEdit__EchoMode = QLineEdit__EchoMode(2)
	QLineEdit__PasswordEchoOnEdit QLineEdit__EchoMode = QLineEdit__EchoMode(3)
)

func (ptr *QLineEdit) AddAction2(icon gui.QIcon_ITF, position QLineEdit__ActionPosition) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QLineEdit_AddAction2(ptr.Pointer(), gui.PointerFromQIcon(icon), C.longlong(position)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQLineEdit(parent QWidget_ITF) *QLineEdit {
	tmpValue := NewQLineEditFromPointer(C.QLineEdit_NewQLineEdit(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQLineEdit2(contents string, parent QWidget_ITF) *QLineEdit {
	var contentsC *C.char
	if contents != "" {
		contentsC = C.CString(contents)
		defer C.free(unsafe.Pointer(contentsC))
	}
	tmpValue := NewQLineEditFromPointer(C.QLineEdit_NewQLineEdit2(C.struct_QtWidgets_PackedString{data: contentsC, len: C.longlong(len(contents))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QLineEdit) CreateStandardContextMenu() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QLineEdit_CreateStandardContextMenu(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLineEdit) CursorPositionAt(pos core.QPoint_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLineEdit_CursorPositionAt(ptr.Pointer(), core.PointerFromQPoint(pos))))
	}
	return 0
}

func (ptr *QLineEdit) AddAction(action QAction_ITF, position QLineEdit__ActionPosition) {
	if ptr.Pointer() != nil {
		C.QLineEdit_AddAction(ptr.Pointer(), PointerFromQAction(action), C.longlong(position))
	}
}

func (ptr *QLineEdit) Backspace() {
	if ptr.Pointer() != nil {
		C.QLineEdit_Backspace(ptr.Pointer())
	}
}

//export callbackQLineEdit_Clear
func callbackQLineEdit_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLineEditFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QLineEdit) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QLineEdit) Clear() {
	if ptr.Pointer() != nil {
		C.QLineEdit_Clear(ptr.Pointer())
	}
}

func (ptr *QLineEdit) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QLineEdit_ClearDefault(ptr.Pointer())
	}
}

func (ptr *QLineEdit) CursorBackward(mark bool, steps int) {
	if ptr.Pointer() != nil {
		C.QLineEdit_CursorBackward(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(mark))), C.int(int32(steps)))
	}
}

func (ptr *QLineEdit) CursorForward(mark bool, steps int) {
	if ptr.Pointer() != nil {
		C.QLineEdit_CursorForward(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(mark))), C.int(int32(steps)))
	}
}

//export callbackQLineEdit_CursorPositionChanged
func callbackQLineEdit_CursorPositionChanged(ptr unsafe.Pointer, oldPos C.int, newPos C.int) {
	if signal := qt.GetSignal(ptr, "cursorPositionChanged"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(oldPos)), int(int32(newPos)))
	}

}

func (ptr *QLineEdit) ConnectCursorPositionChanged(f func(oldPos int, newPos int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cursorPositionChanged") {
			C.QLineEdit_ConnectCursorPositionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cursorPositionChanged"); signal != nil {
			f := func(oldPos int, newPos int) {
				(*(*func(int, int))(signal))(oldPos, newPos)
				f(oldPos, newPos)
			}
			qt.ConnectSignal(ptr.Pointer(), "cursorPositionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cursorPositionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectCursorPositionChanged() {
	if ptr.Pointer() != nil {
		C.QLineEdit_DisconnectCursorPositionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cursorPositionChanged")
	}
}

func (ptr *QLineEdit) CursorPositionChanged(oldPos int, newPos int) {
	if ptr.Pointer() != nil {
		C.QLineEdit_CursorPositionChanged(ptr.Pointer(), C.int(int32(oldPos)), C.int(int32(newPos)))
	}
}

func (ptr *QLineEdit) CursorWordBackward(mark bool) {
	if ptr.Pointer() != nil {
		C.QLineEdit_CursorWordBackward(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(mark))))
	}
}

func (ptr *QLineEdit) CursorWordForward(mark bool) {
	if ptr.Pointer() != nil {
		C.QLineEdit_CursorWordForward(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(mark))))
	}
}

//export callbackQLineEdit_Cut
func callbackQLineEdit_Cut(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "cut"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLineEditFromPointer(ptr).CutDefault()
	}
}

func (ptr *QLineEdit) ConnectCut(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "cut"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "cut", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cut", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectCut() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "cut")
	}
}

func (ptr *QLineEdit) Cut() {
	if ptr.Pointer() != nil {
		C.QLineEdit_Cut(ptr.Pointer())
	}
}

func (ptr *QLineEdit) CutDefault() {
	if ptr.Pointer() != nil {
		C.QLineEdit_CutDefault(ptr.Pointer())
	}
}

func (ptr *QLineEdit) Del() {
	if ptr.Pointer() != nil {
		C.QLineEdit_Del(ptr.Pointer())
	}
}

func (ptr *QLineEdit) Deselect() {
	if ptr.Pointer() != nil {
		C.QLineEdit_Deselect(ptr.Pointer())
	}
}

//export callbackQLineEdit_EditingFinished
func callbackQLineEdit_EditingFinished(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "editingFinished"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QLineEdit) ConnectEditingFinished(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "editingFinished") {
			C.QLineEdit_ConnectEditingFinished(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "editingFinished"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "editingFinished", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "editingFinished", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectEditingFinished() {
	if ptr.Pointer() != nil {
		C.QLineEdit_DisconnectEditingFinished(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "editingFinished")
	}
}

func (ptr *QLineEdit) EditingFinished() {
	if ptr.Pointer() != nil {
		C.QLineEdit_EditingFinished(ptr.Pointer())
	}
}

func (ptr *QLineEdit) End(mark bool) {
	if ptr.Pointer() != nil {
		C.QLineEdit_End(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(mark))))
	}
}

func (ptr *QLineEdit) Home(mark bool) {
	if ptr.Pointer() != nil {
		C.QLineEdit_Home(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(mark))))
	}
}

//export callbackQLineEdit_InputRejected
func callbackQLineEdit_InputRejected(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "inputRejected"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QLineEdit) ConnectInputRejected(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "inputRejected") {
			C.QLineEdit_ConnectInputRejected(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "inputRejected"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "inputRejected", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "inputRejected", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectInputRejected() {
	if ptr.Pointer() != nil {
		C.QLineEdit_DisconnectInputRejected(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "inputRejected")
	}
}

func (ptr *QLineEdit) InputRejected() {
	if ptr.Pointer() != nil {
		C.QLineEdit_InputRejected(ptr.Pointer())
	}
}

func (ptr *QLineEdit) Insert(newText string) {
	if ptr.Pointer() != nil {
		var newTextC *C.char
		if newText != "" {
			newTextC = C.CString(newText)
			defer C.free(unsafe.Pointer(newTextC))
		}
		C.QLineEdit_Insert(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: newTextC, len: C.longlong(len(newText))})
	}
}

//export callbackQLineEdit_Paste
func callbackQLineEdit_Paste(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paste"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLineEditFromPointer(ptr).PasteDefault()
	}
}

func (ptr *QLineEdit) ConnectPaste(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paste"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "paste", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paste", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectPaste() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paste")
	}
}

func (ptr *QLineEdit) Paste() {
	if ptr.Pointer() != nil {
		C.QLineEdit_Paste(ptr.Pointer())
	}
}

func (ptr *QLineEdit) PasteDefault() {
	if ptr.Pointer() != nil {
		C.QLineEdit_PasteDefault(ptr.Pointer())
	}
}

//export callbackQLineEdit_Redo
func callbackQLineEdit_Redo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "redo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLineEditFromPointer(ptr).RedoDefault()
	}
}

func (ptr *QLineEdit) ConnectRedo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "redo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectRedo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "redo")
	}
}

func (ptr *QLineEdit) Redo() {
	if ptr.Pointer() != nil {
		C.QLineEdit_Redo(ptr.Pointer())
	}
}

func (ptr *QLineEdit) RedoDefault() {
	if ptr.Pointer() != nil {
		C.QLineEdit_RedoDefault(ptr.Pointer())
	}
}

//export callbackQLineEdit_ReturnPressed
func callbackQLineEdit_ReturnPressed(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "returnPressed"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QLineEdit) ConnectReturnPressed(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "returnPressed") {
			C.QLineEdit_ConnectReturnPressed(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "returnPressed"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "returnPressed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "returnPressed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectReturnPressed() {
	if ptr.Pointer() != nil {
		C.QLineEdit_DisconnectReturnPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "returnPressed")
	}
}

func (ptr *QLineEdit) ReturnPressed() {
	if ptr.Pointer() != nil {
		C.QLineEdit_ReturnPressed(ptr.Pointer())
	}
}

//export callbackQLineEdit_SelectAll
func callbackQLineEdit_SelectAll(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectAll"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLineEditFromPointer(ptr).SelectAllDefault()
	}
}

func (ptr *QLineEdit) ConnectSelectAll(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "selectAll"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "selectAll", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectAll", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectSelectAll() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "selectAll")
	}
}

func (ptr *QLineEdit) SelectAll() {
	if ptr.Pointer() != nil {
		C.QLineEdit_SelectAll(ptr.Pointer())
	}
}

func (ptr *QLineEdit) SelectAllDefault() {
	if ptr.Pointer() != nil {
		C.QLineEdit_SelectAllDefault(ptr.Pointer())
	}
}

//export callbackQLineEdit_SelectionChanged
func callbackQLineEdit_SelectionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QLineEdit) ConnectSelectionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "selectionChanged") {
			C.QLineEdit_ConnectSelectionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "selectionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QLineEdit_DisconnectSelectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "selectionChanged")
	}
}

func (ptr *QLineEdit) SelectionChanged() {
	if ptr.Pointer() != nil {
		C.QLineEdit_SelectionChanged(ptr.Pointer())
	}
}

func (ptr *QLineEdit) SetAlignment(flag core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetAlignment(ptr.Pointer(), C.longlong(flag))
	}
}

func (ptr *QLineEdit) SetClearButtonEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetClearButtonEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QLineEdit) SetCompleter(c QCompleter_ITF) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetCompleter(ptr.Pointer(), PointerFromQCompleter(c))
	}
}

func (ptr *QLineEdit) SetCursorMoveStyle(style core.Qt__CursorMoveStyle) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetCursorMoveStyle(ptr.Pointer(), C.longlong(style))
	}
}

func (ptr *QLineEdit) SetCursorPosition(vin int) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetCursorPosition(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QLineEdit) SetDragEnabled(b bool) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetDragEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QLineEdit) SetEchoMode(vql QLineEdit__EchoMode) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetEchoMode(ptr.Pointer(), C.longlong(vql))
	}
}

func (ptr *QLineEdit) SetFrame(vbo bool) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetFrame(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QLineEdit) SetInputMask(inputMask string) {
	if ptr.Pointer() != nil {
		var inputMaskC *C.char
		if inputMask != "" {
			inputMaskC = C.CString(inputMask)
			defer C.free(unsafe.Pointer(inputMaskC))
		}
		C.QLineEdit_SetInputMask(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: inputMaskC, len: C.longlong(len(inputMask))})
	}
}

func (ptr *QLineEdit) SetMaxLength(vin int) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetMaxLength(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QLineEdit) SetModified(vbo bool) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetModified(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QLineEdit) SetPlaceholderText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QLineEdit_SetPlaceholderText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QLineEdit) SetReadOnly(vbo bool) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetReadOnly(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QLineEdit) SetSelection(start int, length int) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetSelection(ptr.Pointer(), C.int(int32(start)), C.int(int32(length)))
	}
}

//export callbackQLineEdit_SetText
func callbackQLineEdit_SetText(ptr unsafe.Pointer, vqs C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(vqs))
	} else {
		NewQLineEditFromPointer(ptr).SetTextDefault(cGoUnpackString(vqs))
	}
}

func (ptr *QLineEdit) ConnectSetText(f func(vqs string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setText"); signal != nil {
			f := func(vqs string) {
				(*(*func(string))(signal))(vqs)
				f(vqs)
			}
			qt.ConnectSignal(ptr.Pointer(), "setText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectSetText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setText")
	}
}

func (ptr *QLineEdit) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QLineEdit_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QLineEdit) SetTextDefault(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QLineEdit_SetTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QLineEdit) SetTextMargins2(margins core.QMargins_ITF) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetTextMargins2(ptr.Pointer(), core.PointerFromQMargins(margins))
	}
}

func (ptr *QLineEdit) SetTextMargins(left int, top int, right int, bottom int) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetTextMargins(ptr.Pointer(), C.int(int32(left)), C.int(int32(top)), C.int(int32(right)), C.int(int32(bottom)))
	}
}

func (ptr *QLineEdit) SetValidator(v gui.QValidator_ITF) {
	if ptr.Pointer() != nil {
		C.QLineEdit_SetValidator(ptr.Pointer(), gui.PointerFromQValidator(v))
	}
}

//export callbackQLineEdit_TextChanged
func callbackQLineEdit_TextChanged(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "textChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QLineEdit) ConnectTextChanged(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "textChanged") {
			C.QLineEdit_ConnectTextChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "textChanged"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "textChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "textChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectTextChanged() {
	if ptr.Pointer() != nil {
		C.QLineEdit_DisconnectTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "textChanged")
	}
}

func (ptr *QLineEdit) TextChanged(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QLineEdit_TextChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQLineEdit_TextEdited
func callbackQLineEdit_TextEdited(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "textEdited"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QLineEdit) ConnectTextEdited(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "textEdited") {
			C.QLineEdit_ConnectTextEdited(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "textEdited"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "textEdited", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "textEdited", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectTextEdited() {
	if ptr.Pointer() != nil {
		C.QLineEdit_DisconnectTextEdited(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "textEdited")
	}
}

func (ptr *QLineEdit) TextEdited(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QLineEdit_TextEdited(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQLineEdit_Undo
func callbackQLineEdit_Undo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "undo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLineEditFromPointer(ptr).UndoDefault()
	}
}

func (ptr *QLineEdit) ConnectUndo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "undo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectUndo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "undo")
	}
}

func (ptr *QLineEdit) Undo() {
	if ptr.Pointer() != nil {
		C.QLineEdit_Undo(ptr.Pointer())
	}
}

func (ptr *QLineEdit) UndoDefault() {
	if ptr.Pointer() != nil {
		C.QLineEdit_UndoDefault(ptr.Pointer())
	}
}

//export callbackQLineEdit_DestroyQLineEdit
func callbackQLineEdit_DestroyQLineEdit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QLineEdit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLineEditFromPointer(ptr).DestroyQLineEditDefault()
	}
}

func (ptr *QLineEdit) ConnectDestroyQLineEdit(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QLineEdit"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QLineEdit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QLineEdit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectDestroyQLineEdit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QLineEdit")
	}
}

func (ptr *QLineEdit) DestroyQLineEdit() {
	if ptr.Pointer() != nil {
		C.QLineEdit_DestroyQLineEdit(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLineEdit) DestroyQLineEditDefault() {
	if ptr.Pointer() != nil {
		C.QLineEdit_DestroyQLineEditDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QLineEdit) Completer() *QCompleter {
	if ptr.Pointer() != nil {
		tmpValue := NewQCompleterFromPointer(C.QLineEdit_Completer(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLineEdit) EchoMode() QLineEdit__EchoMode {
	if ptr.Pointer() != nil {
		return QLineEdit__EchoMode(C.QLineEdit_EchoMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineEdit) TextMargins() *core.QMargins {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMarginsFromPointer(C.QLineEdit_TextMargins(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QMargins).DestroyQMargins)
		return tmpValue
	}
	return nil
}

func (ptr *QLineEdit) CursorRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QLineEdit_CursorRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QLineEdit) DisplayText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLineEdit_DisplayText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLineEdit) InputMask() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLineEdit_InputMask(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLineEdit) PlaceholderText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLineEdit_PlaceholderText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLineEdit) SelectedText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLineEdit_SelectedText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLineEdit) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QLineEdit_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QLineEdit) Alignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QLineEdit_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineEdit) CursorMoveStyle() core.Qt__CursorMoveStyle {
	if ptr.Pointer() != nil {
		return core.Qt__CursorMoveStyle(C.QLineEdit_CursorMoveStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QLineEdit) DragEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineEdit_DragEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineEdit) HasAcceptableInput() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineEdit_HasAcceptableInput(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineEdit) HasFrame() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineEdit_HasFrame(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineEdit) HasSelectedText() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineEdit_HasSelectedText(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineEdit) IsClearButtonEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineEdit_IsClearButtonEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineEdit) IsModified() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineEdit_IsModified(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineEdit) IsReadOnly() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineEdit_IsReadOnly(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineEdit) IsRedoAvailable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineEdit_IsRedoAvailable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineEdit) IsUndoAvailable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QLineEdit_IsUndoAvailable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QLineEdit) Validator() *gui.QValidator {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQValidatorFromPointer(C.QLineEdit_Validator(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QLineEdit) CursorPosition() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLineEdit_CursorPosition(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLineEdit) MaxLength() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLineEdit_MaxLength(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLineEdit) SelectionEnd() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLineEdit_SelectionEnd(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLineEdit) SelectionLength() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLineEdit_SelectionLength(ptr.Pointer())))
	}
	return 0
}

func (ptr *QLineEdit) SelectionStart() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QLineEdit_SelectionStart(ptr.Pointer())))
	}
	return 0
}

//export callbackQLineEdit_Copy
func callbackQLineEdit_Copy(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "copy"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQLineEditFromPointer(ptr).CopyDefault()
	}
}

func (ptr *QLineEdit) ConnectCopy(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "copy"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "copy", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "copy", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QLineEdit) DisconnectCopy() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "copy")
	}
}

func (ptr *QLineEdit) Copy() {
	if ptr.Pointer() != nil {
		C.QLineEdit_Copy(ptr.Pointer())
	}
}

func (ptr *QLineEdit) CopyDefault() {
	if ptr.Pointer() != nil {
		C.QLineEdit_CopyDefault(ptr.Pointer())
	}
}

func (ptr *QLineEdit) GetTextMargins(left int, top int, right int, bottom int) {
	if ptr.Pointer() != nil {
		C.QLineEdit_GetTextMargins(ptr.Pointer(), C.int(int32(left)), C.int(int32(top)), C.int(int32(right)), C.int(int32(bottom)))
	}
}

func (ptr *QLineEdit) InitStyleOption(option QStyleOptionFrame_ITF) {
	if ptr.Pointer() != nil {
		C.QLineEdit_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionFrame(option))
	}
}

type QListView struct {
	QAbstractItemView
}

type QListView_ITF interface {
	QAbstractItemView_ITF
	QListView_PTR() *QListView
}

func (ptr *QListView) QListView_PTR() *QListView {
	return ptr
}

func (ptr *QListView) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemView_PTR().Pointer()
	}
	return nil
}

func (ptr *QListView) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractItemView_PTR().SetPointer(p)
	}
}

func PointerFromQListView(ptr QListView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QListView_PTR().Pointer()
	}
	return nil
}

func NewQListViewFromPointer(ptr unsafe.Pointer) (n *QListView) {
	n = new(QListView)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QListView__Flow
//QListView::Flow
type QListView__Flow int64

const (
	QListView__LeftToRight QListView__Flow = QListView__Flow(0)
	QListView__TopToBottom QListView__Flow = QListView__Flow(1)
)

//go:generate stringer -type=QListView__LayoutMode
//QListView::LayoutMode
type QListView__LayoutMode int64

const (
	QListView__SinglePass QListView__LayoutMode = QListView__LayoutMode(0)
	QListView__Batched    QListView__LayoutMode = QListView__LayoutMode(1)
)

//go:generate stringer -type=QListView__Movement
//QListView::Movement
type QListView__Movement int64

const (
	QListView__Static QListView__Movement = QListView__Movement(0)
	QListView__Free   QListView__Movement = QListView__Movement(1)
	QListView__Snap   QListView__Movement = QListView__Movement(2)
)

//go:generate stringer -type=QListView__ResizeMode
//QListView::ResizeMode
type QListView__ResizeMode int64

const (
	QListView__Fixed  QListView__ResizeMode = QListView__ResizeMode(0)
	QListView__Adjust QListView__ResizeMode = QListView__ResizeMode(1)
)

//go:generate stringer -type=QListView__ViewMode
//QListView::ViewMode
type QListView__ViewMode int64

const (
	QListView__ListMode QListView__ViewMode = QListView__ViewMode(0)
	QListView__IconMode QListView__ViewMode = QListView__ViewMode(1)
)

func NewQListView(parent QWidget_ITF) *QListView {
	tmpValue := NewQListViewFromPointer(C.QListView_NewQListView(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQListView_MoveCursor
func callbackQListView_MoveCursor(ptr unsafe.Pointer, cursorAction C.longlong, modifiers C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "moveCursor"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
	}

	return core.PointerFromQModelIndex(NewQListViewFromPointer(ptr).MoveCursorDefault(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
}

func (ptr *QListView) ConnectMoveCursor(f func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "moveCursor"); signal != nil {
			f := func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
				(*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(cursorAction, modifiers)
				return f(cursorAction, modifiers)
			}
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectMoveCursor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "moveCursor")
	}
}

func (ptr *QListView) MoveCursor(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QListView_MoveCursor(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QListView) MoveCursorDefault(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QListView_MoveCursorDefault(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QListView) ClearPropertyFlags() {
	if ptr.Pointer() != nil {
		C.QListView_ClearPropertyFlags(ptr.Pointer())
	}
}

//export callbackQListView_CurrentChanged
func callbackQListView_CurrentChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	} else {
		NewQListViewFromPointer(ptr).CurrentChangedDefault(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	}
}

func (ptr *QListView) ConnectCurrentChanged(f func(current *core.QModelIndex, previous *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(current *core.QModelIndex, previous *core.QModelIndex) {
				(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(current, previous)
				f(current, previous)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QListView) CurrentChanged(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QListView_CurrentChanged(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

func (ptr *QListView) CurrentChangedDefault(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QListView_CurrentChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

//export callbackQListView_DataChanged
func callbackQListView_DataChanged(ptr unsafe.Pointer, topLeft unsafe.Pointer, bottomRight unsafe.Pointer, roles C.struct_QtWidgets_PackedList) {
	if signal := qt.GetSignal(ptr, "dataChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex, []int))(signal))(core.NewQModelIndexFromPointer(topLeft), core.NewQModelIndexFromPointer(bottomRight), func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQListViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__dataChanged_roles_atList(i)
			}
			return out
		}(roles))
	} else {
		NewQListViewFromPointer(ptr).DataChangedDefault(core.NewQModelIndexFromPointer(topLeft), core.NewQModelIndexFromPointer(bottomRight), func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQListViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__dataChanged_roles_atList(i)
			}
			return out
		}(roles))
	}
}

func (ptr *QListView) ConnectDataChanged(f func(topLeft *core.QModelIndex, bottomRight *core.QModelIndex, roles []int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dataChanged"); signal != nil {
			f := func(topLeft *core.QModelIndex, bottomRight *core.QModelIndex, roles []int) {
				(*(*func(*core.QModelIndex, *core.QModelIndex, []int))(signal))(topLeft, bottomRight, roles)
				f(topLeft, bottomRight, roles)
			}
			qt.ConnectSignal(ptr.Pointer(), "dataChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dataChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectDataChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dataChanged")
	}
}

func (ptr *QListView) DataChanged(topLeft core.QModelIndex_ITF, bottomRight core.QModelIndex_ITF, roles []int) {
	if ptr.Pointer() != nil {
		C.QListView_DataChanged(ptr.Pointer(), core.PointerFromQModelIndex(topLeft), core.PointerFromQModelIndex(bottomRight), func() unsafe.Pointer {
			tmpList := NewQListViewFromPointer(NewQListViewFromPointer(nil).__dataChanged_roles_newList())
			for _, v := range roles {
				tmpList.__dataChanged_roles_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QListView) DataChangedDefault(topLeft core.QModelIndex_ITF, bottomRight core.QModelIndex_ITF, roles []int) {
	if ptr.Pointer() != nil {
		C.QListView_DataChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(topLeft), core.PointerFromQModelIndex(bottomRight), func() unsafe.Pointer {
			tmpList := NewQListViewFromPointer(NewQListViewFromPointer(nil).__dataChanged_roles_newList())
			for _, v := range roles {
				tmpList.__dataChanged_roles_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQListView_RowsAboutToBeRemoved
func callbackQListView_RowsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	} else {
		NewQListViewFromPointer(ptr).RowsAboutToBeRemovedDefault(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}
}

func (ptr *QListView) ConnectRowsAboutToBeRemoved(f func(parent *core.QModelIndex, start int, end int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowsAboutToBeRemoved"); signal != nil {
			f := func(parent *core.QModelIndex, start int, end int) {
				(*(*func(*core.QModelIndex, int, int))(signal))(parent, start, end)
				f(parent, start, end)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectRowsAboutToBeRemoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowsAboutToBeRemoved")
	}
}

func (ptr *QListView) RowsAboutToBeRemoved(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QListView_RowsAboutToBeRemoved(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

func (ptr *QListView) RowsAboutToBeRemovedDefault(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QListView_RowsAboutToBeRemovedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

//export callbackQListView_RowsInserted
func callbackQListView_RowsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	} else {
		NewQListViewFromPointer(ptr).RowsInsertedDefault(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}
}

func (ptr *QListView) ConnectRowsInserted(f func(parent *core.QModelIndex, start int, end int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowsInserted"); signal != nil {
			f := func(parent *core.QModelIndex, start int, end int) {
				(*(*func(*core.QModelIndex, int, int))(signal))(parent, start, end)
				f(parent, start, end)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectRowsInserted() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowsInserted")
	}
}

func (ptr *QListView) RowsInserted(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QListView_RowsInserted(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

func (ptr *QListView) RowsInsertedDefault(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QListView_RowsInsertedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

//export callbackQListView_ScrollTo
func callbackQListView_ScrollTo(ptr unsafe.Pointer, index unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "scrollTo"); signal != nil {
		(*(*func(*core.QModelIndex, QAbstractItemView__ScrollHint))(signal))(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	} else {
		NewQListViewFromPointer(ptr).ScrollToDefault(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	}
}

func (ptr *QListView) ConnectScrollTo(f func(index *core.QModelIndex, hint QAbstractItemView__ScrollHint)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "scrollTo"); signal != nil {
			f := func(index *core.QModelIndex, hint QAbstractItemView__ScrollHint) {
				(*(*func(*core.QModelIndex, QAbstractItemView__ScrollHint))(signal))(index, hint)
				f(index, hint)
			}
			qt.ConnectSignal(ptr.Pointer(), "scrollTo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scrollTo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectScrollTo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "scrollTo")
	}
}

func (ptr *QListView) ScrollTo(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QListView_ScrollTo(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

func (ptr *QListView) ScrollToDefault(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QListView_ScrollToDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

//export callbackQListView_SelectionChanged
func callbackQListView_SelectionChanged(ptr unsafe.Pointer, selected unsafe.Pointer, deselected unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
		(*(*func(*core.QItemSelection, *core.QItemSelection))(signal))(core.NewQItemSelectionFromPointer(selected), core.NewQItemSelectionFromPointer(deselected))
	} else {
		NewQListViewFromPointer(ptr).SelectionChangedDefault(core.NewQItemSelectionFromPointer(selected), core.NewQItemSelectionFromPointer(deselected))
	}
}

func (ptr *QListView) ConnectSelectionChanged(f func(selected *core.QItemSelection, deselected *core.QItemSelection)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "selectionChanged"); signal != nil {
			f := func(selected *core.QItemSelection, deselected *core.QItemSelection) {
				(*(*func(*core.QItemSelection, *core.QItemSelection))(signal))(selected, deselected)
				f(selected, deselected)
			}
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "selectionChanged")
	}
}

func (ptr *QListView) SelectionChanged(selected core.QItemSelection_ITF, deselected core.QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QListView_SelectionChanged(ptr.Pointer(), core.PointerFromQItemSelection(selected), core.PointerFromQItemSelection(deselected))
	}
}

func (ptr *QListView) SelectionChangedDefault(selected core.QItemSelection_ITF, deselected core.QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QListView_SelectionChangedDefault(ptr.Pointer(), core.PointerFromQItemSelection(selected), core.PointerFromQItemSelection(deselected))
	}
}

func (ptr *QListView) SetBatchSize(batchSize int) {
	if ptr.Pointer() != nil {
		C.QListView_SetBatchSize(ptr.Pointer(), C.int(int32(batchSize)))
	}
}

func (ptr *QListView) SetFlow(flow QListView__Flow) {
	if ptr.Pointer() != nil {
		C.QListView_SetFlow(ptr.Pointer(), C.longlong(flow))
	}
}

func (ptr *QListView) SetGridSize(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QListView_SetGridSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QListView) SetItemAlignment(alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QListView_SetItemAlignment(ptr.Pointer(), C.longlong(alignment))
	}
}

func (ptr *QListView) SetLayoutMode(mode QListView__LayoutMode) {
	if ptr.Pointer() != nil {
		C.QListView_SetLayoutMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QListView) SetModelColumn(column int) {
	if ptr.Pointer() != nil {
		C.QListView_SetModelColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QListView) SetMovement(movement QListView__Movement) {
	if ptr.Pointer() != nil {
		C.QListView_SetMovement(ptr.Pointer(), C.longlong(movement))
	}
}

func (ptr *QListView) SetPositionForIndex(position core.QPoint_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QListView_SetPositionForIndex(ptr.Pointer(), core.PointerFromQPoint(position), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QListView) SetResizeMode(mode QListView__ResizeMode) {
	if ptr.Pointer() != nil {
		C.QListView_SetResizeMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QListView) SetRowHidden(row int, hide bool) {
	if ptr.Pointer() != nil {
		C.QListView_SetRowHidden(ptr.Pointer(), C.int(int32(row)), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

//export callbackQListView_SetSelection
func callbackQListView_SetSelection(ptr unsafe.Pointer, rect unsafe.Pointer, command C.longlong) {
	if signal := qt.GetSignal(ptr, "setSelection"); signal != nil {
		(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(command))
	} else {
		NewQListViewFromPointer(ptr).SetSelectionDefault(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(command))
	}
}

func (ptr *QListView) ConnectSetSelection(f func(rect *core.QRect, command core.QItemSelectionModel__SelectionFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setSelection"); signal != nil {
			f := func(rect *core.QRect, command core.QItemSelectionModel__SelectionFlag) {
				(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(rect, command)
				f(rect, command)
			}
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectSetSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setSelection")
	}
}

func (ptr *QListView) SetSelection(rect core.QRect_ITF, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QListView_SetSelection(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(command))
	}
}

func (ptr *QListView) SetSelectionDefault(rect core.QRect_ITF, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QListView_SetSelectionDefault(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(command))
	}
}

func (ptr *QListView) SetSelectionRectVisible(show bool) {
	if ptr.Pointer() != nil {
		C.QListView_SetSelectionRectVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(show))))
	}
}

func (ptr *QListView) SetSpacing(space int) {
	if ptr.Pointer() != nil {
		C.QListView_SetSpacing(ptr.Pointer(), C.int(int32(space)))
	}
}

func (ptr *QListView) SetUniformItemSizes(enable bool) {
	if ptr.Pointer() != nil {
		C.QListView_SetUniformItemSizes(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QListView) SetViewMode(mode QListView__ViewMode) {
	if ptr.Pointer() != nil {
		C.QListView_SetViewMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QListView) SetWordWrap(on bool) {
	if ptr.Pointer() != nil {
		C.QListView_SetWordWrap(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QListView) SetWrapping(enable bool) {
	if ptr.Pointer() != nil {
		C.QListView_SetWrapping(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQListView_UpdateGeometries
func callbackQListView_UpdateGeometries(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateGeometries"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQListViewFromPointer(ptr).UpdateGeometriesDefault()
	}
}

func (ptr *QListView) ConnectUpdateGeometries(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateGeometries"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "updateGeometries", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateGeometries", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectUpdateGeometries() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateGeometries")
	}
}

func (ptr *QListView) UpdateGeometries() {
	if ptr.Pointer() != nil {
		C.QListView_UpdateGeometries(ptr.Pointer())
	}
}

func (ptr *QListView) UpdateGeometriesDefault() {
	if ptr.Pointer() != nil {
		C.QListView_UpdateGeometriesDefault(ptr.Pointer())
	}
}

//export callbackQListView_DestroyQListView
func callbackQListView_DestroyQListView(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QListView"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQListViewFromPointer(ptr).DestroyQListViewDefault()
	}
}

func (ptr *QListView) ConnectDestroyQListView(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QListView"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QListView", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QListView", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectDestroyQListView() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QListView")
	}
}

func (ptr *QListView) DestroyQListView() {
	if ptr.Pointer() != nil {
		C.QListView_DestroyQListView(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QListView) DestroyQListViewDefault() {
	if ptr.Pointer() != nil {
		C.QListView_DestroyQListViewDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QListView) Flow() QListView__Flow {
	if ptr.Pointer() != nil {
		return QListView__Flow(C.QListView_Flow(ptr.Pointer()))
	}
	return 0
}

func (ptr *QListView) LayoutMode() QListView__LayoutMode {
	if ptr.Pointer() != nil {
		return QListView__LayoutMode(C.QListView_LayoutMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QListView) Movement() QListView__Movement {
	if ptr.Pointer() != nil {
		return QListView__Movement(C.QListView_Movement(ptr.Pointer()))
	}
	return 0
}

func (ptr *QListView) ResizeMode() QListView__ResizeMode {
	if ptr.Pointer() != nil {
		return QListView__ResizeMode(C.QListView_ResizeMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QListView) ViewMode() QListView__ViewMode {
	if ptr.Pointer() != nil {
		return QListView__ViewMode(C.QListView_ViewMode(ptr.Pointer()))
	}
	return 0
}

//export callbackQListView_IndexAt
func callbackQListView_IndexAt(ptr unsafe.Pointer, p unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "indexAt"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QPoint) *core.QModelIndex)(signal))(core.NewQPointFromPointer(p)))
	}

	return core.PointerFromQModelIndex(NewQListViewFromPointer(ptr).IndexAtDefault(core.NewQPointFromPointer(p)))
}

func (ptr *QListView) ConnectIndexAt(f func(p *core.QPoint) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "indexAt"); signal != nil {
			f := func(p *core.QPoint) *core.QModelIndex {
				(*(*func(*core.QPoint) *core.QModelIndex)(signal))(p)
				return f(p)
			}
			qt.ConnectSignal(ptr.Pointer(), "indexAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "indexAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectIndexAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "indexAt")
	}
}

func (ptr *QListView) IndexAt(p core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QListView_IndexAt(ptr.Pointer(), core.PointerFromQPoint(p)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QListView) IndexAtDefault(p core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QListView_IndexAtDefault(ptr.Pointer(), core.PointerFromQPoint(p)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QListView) RectForIndex(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QListView_RectForIndex(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQListView_VisualRect
func callbackQListView_VisualRect(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRect"); signal != nil {
		return core.PointerFromQRect((*(*func(*core.QModelIndex) *core.QRect)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQRect(NewQListViewFromPointer(ptr).VisualRectDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QListView) ConnectVisualRect(f func(index *core.QModelIndex) *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "visualRect"); signal != nil {
			f := func(index *core.QModelIndex) *core.QRect {
				(*(*func(*core.QModelIndex) *core.QRect)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "visualRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "visualRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectVisualRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "visualRect")
	}
}

func (ptr *QListView) VisualRect(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QListView_VisualRect(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QListView) VisualRectDefault(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QListView_VisualRectDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQListView_VisualRegionForSelection
func callbackQListView_VisualRegionForSelection(ptr unsafe.Pointer, selection unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRegionForSelection"); signal != nil {
		return gui.PointerFromQRegion((*(*func(*core.QItemSelection) *gui.QRegion)(signal))(core.NewQItemSelectionFromPointer(selection)))
	}

	return gui.PointerFromQRegion(NewQListViewFromPointer(ptr).VisualRegionForSelectionDefault(core.NewQItemSelectionFromPointer(selection)))
}

func (ptr *QListView) ConnectVisualRegionForSelection(f func(selection *core.QItemSelection) *gui.QRegion) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "visualRegionForSelection"); signal != nil {
			f := func(selection *core.QItemSelection) *gui.QRegion {
				(*(*func(*core.QItemSelection) *gui.QRegion)(signal))(selection)
				return f(selection)
			}
			qt.ConnectSignal(ptr.Pointer(), "visualRegionForSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "visualRegionForSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectVisualRegionForSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "visualRegionForSelection")
	}
}

func (ptr *QListView) VisualRegionForSelection(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QListView_VisualRegionForSelection(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QListView) VisualRegionForSelectionDefault(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QListView_VisualRegionForSelectionDefault(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QListView) GridSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QListView_GridSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QListView) ItemAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QListView_ItemAlignment(ptr.Pointer()))
	}
	return 0
}

//export callbackQListView_IsIndexHidden
func callbackQListView_IsIndexHidden(ptr unsafe.Pointer, index unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isIndexHidden"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex) bool)(signal))(core.NewQModelIndexFromPointer(index)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQListViewFromPointer(ptr).IsIndexHiddenDefault(core.NewQModelIndexFromPointer(index)))))
}

func (ptr *QListView) ConnectIsIndexHidden(f func(index *core.QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isIndexHidden"); signal != nil {
			f := func(index *core.QModelIndex) bool {
				(*(*func(*core.QModelIndex) bool)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "isIndexHidden", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isIndexHidden", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectIsIndexHidden() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isIndexHidden")
	}
}

func (ptr *QListView) IsIndexHidden(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QListView_IsIndexHidden(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QListView) IsIndexHiddenDefault(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QListView_IsIndexHiddenDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QListView) IsRowHidden(row int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QListView_IsRowHidden(ptr.Pointer(), C.int(int32(row)))) != 0
	}
	return false
}

func (ptr *QListView) IsSelectionRectVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QListView_IsSelectionRectVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QListView) IsWrapping() bool {
	if ptr.Pointer() != nil {
		return int8(C.QListView_IsWrapping(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QListView) UniformItemSizes() bool {
	if ptr.Pointer() != nil {
		return int8(C.QListView_UniformItemSizes(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QListView) WordWrap() bool {
	if ptr.Pointer() != nil {
		return int8(C.QListView_WordWrap(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QListView) BatchSize() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListView_BatchSize(ptr.Pointer())))
	}
	return 0
}

//export callbackQListView_HorizontalOffset
func callbackQListView_HorizontalOffset(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "horizontalOffset"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQListViewFromPointer(ptr).HorizontalOffsetDefault()))
}

func (ptr *QListView) ConnectHorizontalOffset(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "horizontalOffset"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "horizontalOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "horizontalOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectHorizontalOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "horizontalOffset")
	}
}

func (ptr *QListView) HorizontalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListView_HorizontalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QListView) HorizontalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListView_HorizontalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QListView) ModelColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListView_ModelColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QListView) Spacing() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListView_Spacing(ptr.Pointer())))
	}
	return 0
}

//export callbackQListView_VerticalOffset
func callbackQListView_VerticalOffset(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "verticalOffset"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQListViewFromPointer(ptr).VerticalOffsetDefault()))
}

func (ptr *QListView) ConnectVerticalOffset(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "verticalOffset"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "verticalOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "verticalOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListView) DisconnectVerticalOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "verticalOffset")
	}
}

func (ptr *QListView) VerticalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListView_VerticalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QListView) VerticalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListView_VerticalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QListView) __indexesMoved_indexes_atList(i int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QListView___indexesMoved_indexes_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QListView) __indexesMoved_indexes_setList(i core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QListView___indexesMoved_indexes_setList(ptr.Pointer(), core.PointerFromQModelIndex(i))
	}
}

func (ptr *QListView) __indexesMoved_indexes_newList() unsafe.Pointer {
	return C.QListView___indexesMoved_indexes_newList(ptr.Pointer())
}

type QListWidget struct {
	QListView
}

type QListWidget_ITF interface {
	QListView_ITF
	QListWidget_PTR() *QListWidget
}

func (ptr *QListWidget) QListWidget_PTR() *QListWidget {
	return ptr
}

func (ptr *QListWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QListView_PTR().Pointer()
	}
	return nil
}

func (ptr *QListWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QListView_PTR().SetPointer(p)
	}
}

func PointerFromQListWidget(ptr QListWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QListWidget_PTR().Pointer()
	}
	return nil
}

func NewQListWidgetFromPointer(ptr unsafe.Pointer) (n *QListWidget) {
	n = new(QListWidget)
	n.SetPointer(ptr)
	return
}
func NewQListWidget(parent QWidget_ITF) *QListWidget {
	tmpValue := NewQListWidgetFromPointer(C.QListWidget_NewQListWidget(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QListWidget) TakeItem(row int) *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget_TakeItem(ptr.Pointer(), C.int(int32(row))))
	}
	return nil
}

//export callbackQListWidget_DropMimeData
func callbackQListWidget_DropMimeData(ptr unsafe.Pointer, index C.int, data unsafe.Pointer, action C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "dropMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, *core.QMimeData, core.Qt__DropAction) bool)(signal))(int(int32(index)), core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQListWidgetFromPointer(ptr).DropMimeDataDefault(int(int32(index)), core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action)))))
}

func (ptr *QListWidget) ConnectDropMimeData(f func(index int, data *core.QMimeData, action core.Qt__DropAction) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dropMimeData"); signal != nil {
			f := func(index int, data *core.QMimeData, action core.Qt__DropAction) bool {
				(*(*func(int, *core.QMimeData, core.Qt__DropAction) bool)(signal))(index, data, action)
				return f(index, data, action)
			}
			qt.ConnectSignal(ptr.Pointer(), "dropMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dropMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectDropMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dropMimeData")
	}
}

func (ptr *QListWidget) DropMimeData(index int, data core.QMimeData_ITF, action core.Qt__DropAction) bool {
	if ptr.Pointer() != nil {
		return int8(C.QListWidget_DropMimeData(ptr.Pointer(), C.int(int32(index)), core.PointerFromQMimeData(data), C.longlong(action))) != 0
	}
	return false
}

func (ptr *QListWidget) DropMimeDataDefault(index int, data core.QMimeData_ITF, action core.Qt__DropAction) bool {
	if ptr.Pointer() != nil {
		return int8(C.QListWidget_DropMimeDataDefault(ptr.Pointer(), C.int(int32(index)), core.PointerFromQMimeData(data), C.longlong(action))) != 0
	}
	return false
}

func (ptr *QListWidget) AddItem2(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_AddItem2(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

func (ptr *QListWidget) AddItem(label string) {
	if ptr.Pointer() != nil {
		var labelC *C.char
		if label != "" {
			labelC = C.CString(label)
			defer C.free(unsafe.Pointer(labelC))
		}
		C.QListWidget_AddItem(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))})
	}
}

func (ptr *QListWidget) AddItems(labels []string) {
	if ptr.Pointer() != nil {
		labelsC := C.CString(strings.Join(labels, "|"))
		defer C.free(unsafe.Pointer(labelsC))
		C.QListWidget_AddItems(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: labelsC, len: C.longlong(len(strings.Join(labels, "|")))})
	}
}

//export callbackQListWidget_Clear
func callbackQListWidget_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQListWidgetFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QListWidget) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QListWidget) Clear() {
	if ptr.Pointer() != nil {
		C.QListWidget_Clear(ptr.Pointer())
	}
}

func (ptr *QListWidget) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QListWidget_ClearDefault(ptr.Pointer())
	}
}

func (ptr *QListWidget) ClosePersistentEditor(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_ClosePersistentEditor(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

//export callbackQListWidget_CurrentItemChanged
func callbackQListWidget_CurrentItemChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentItemChanged"); signal != nil {
		(*(*func(*QListWidgetItem, *QListWidgetItem))(signal))(NewQListWidgetItemFromPointer(current), NewQListWidgetItemFromPointer(previous))
	}

}

func (ptr *QListWidget) ConnectCurrentItemChanged(f func(current *QListWidgetItem, previous *QListWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentItemChanged") {
			C.QListWidget_ConnectCurrentItemChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentItemChanged"); signal != nil {
			f := func(current *QListWidgetItem, previous *QListWidgetItem) {
				(*(*func(*QListWidgetItem, *QListWidgetItem))(signal))(current, previous)
				f(current, previous)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentItemChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentItemChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectCurrentItemChanged() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectCurrentItemChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentItemChanged")
	}
}

func (ptr *QListWidget) CurrentItemChanged(current QListWidgetItem_ITF, previous QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_CurrentItemChanged(ptr.Pointer(), PointerFromQListWidgetItem(current), PointerFromQListWidgetItem(previous))
	}
}

//export callbackQListWidget_CurrentRowChanged
func callbackQListWidget_CurrentRowChanged(ptr unsafe.Pointer, currentRow C.int) {
	if signal := qt.GetSignal(ptr, "currentRowChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(currentRow)))
	}

}

func (ptr *QListWidget) ConnectCurrentRowChanged(f func(currentRow int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentRowChanged") {
			C.QListWidget_ConnectCurrentRowChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentRowChanged"); signal != nil {
			f := func(currentRow int) {
				(*(*func(int))(signal))(currentRow)
				f(currentRow)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentRowChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentRowChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectCurrentRowChanged() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectCurrentRowChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentRowChanged")
	}
}

func (ptr *QListWidget) CurrentRowChanged(currentRow int) {
	if ptr.Pointer() != nil {
		C.QListWidget_CurrentRowChanged(ptr.Pointer(), C.int(int32(currentRow)))
	}
}

//export callbackQListWidget_CurrentTextChanged
func callbackQListWidget_CurrentTextChanged(ptr unsafe.Pointer, currentText C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "currentTextChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(currentText))
	}

}

func (ptr *QListWidget) ConnectCurrentTextChanged(f func(currentText string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentTextChanged") {
			C.QListWidget_ConnectCurrentTextChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentTextChanged"); signal != nil {
			f := func(currentText string) {
				(*(*func(string))(signal))(currentText)
				f(currentText)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentTextChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentTextChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectCurrentTextChanged() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectCurrentTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentTextChanged")
	}
}

func (ptr *QListWidget) CurrentTextChanged(currentText string) {
	if ptr.Pointer() != nil {
		var currentTextC *C.char
		if currentText != "" {
			currentTextC = C.CString(currentText)
			defer C.free(unsafe.Pointer(currentTextC))
		}
		C.QListWidget_CurrentTextChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: currentTextC, len: C.longlong(len(currentText))})
	}
}

func (ptr *QListWidget) EditItem(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_EditItem(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

func (ptr *QListWidget) InsertItem(row int, item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_InsertItem(ptr.Pointer(), C.int(int32(row)), PointerFromQListWidgetItem(item))
	}
}

func (ptr *QListWidget) InsertItem2(row int, label string) {
	if ptr.Pointer() != nil {
		var labelC *C.char
		if label != "" {
			labelC = C.CString(label)
			defer C.free(unsafe.Pointer(labelC))
		}
		C.QListWidget_InsertItem2(ptr.Pointer(), C.int(int32(row)), C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))})
	}
}

func (ptr *QListWidget) InsertItems(row int, labels []string) {
	if ptr.Pointer() != nil {
		labelsC := C.CString(strings.Join(labels, "|"))
		defer C.free(unsafe.Pointer(labelsC))
		C.QListWidget_InsertItems(ptr.Pointer(), C.int(int32(row)), C.struct_QtWidgets_PackedString{data: labelsC, len: C.longlong(len(strings.Join(labels, "|")))})
	}
}

//export callbackQListWidget_ItemActivated
func callbackQListWidget_ItemActivated(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemActivated"); signal != nil {
		(*(*func(*QListWidgetItem))(signal))(NewQListWidgetItemFromPointer(item))
	}

}

func (ptr *QListWidget) ConnectItemActivated(f func(item *QListWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemActivated") {
			C.QListWidget_ConnectItemActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemActivated"); signal != nil {
			f := func(item *QListWidgetItem) {
				(*(*func(*QListWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemActivated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemActivated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectItemActivated() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectItemActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemActivated")
	}
}

func (ptr *QListWidget) ItemActivated(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_ItemActivated(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

//export callbackQListWidget_ItemChanged
func callbackQListWidget_ItemChanged(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemChanged"); signal != nil {
		(*(*func(*QListWidgetItem))(signal))(NewQListWidgetItemFromPointer(item))
	}

}

func (ptr *QListWidget) ConnectItemChanged(f func(item *QListWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemChanged") {
			C.QListWidget_ConnectItemChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemChanged"); signal != nil {
			f := func(item *QListWidgetItem) {
				(*(*func(*QListWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectItemChanged() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectItemChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemChanged")
	}
}

func (ptr *QListWidget) ItemChanged(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_ItemChanged(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

//export callbackQListWidget_ItemClicked
func callbackQListWidget_ItemClicked(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemClicked"); signal != nil {
		(*(*func(*QListWidgetItem))(signal))(NewQListWidgetItemFromPointer(item))
	}

}

func (ptr *QListWidget) ConnectItemClicked(f func(item *QListWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemClicked") {
			C.QListWidget_ConnectItemClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemClicked"); signal != nil {
			f := func(item *QListWidgetItem) {
				(*(*func(*QListWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectItemClicked() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectItemClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemClicked")
	}
}

func (ptr *QListWidget) ItemClicked(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_ItemClicked(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

//export callbackQListWidget_ItemDoubleClicked
func callbackQListWidget_ItemDoubleClicked(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemDoubleClicked"); signal != nil {
		(*(*func(*QListWidgetItem))(signal))(NewQListWidgetItemFromPointer(item))
	}

}

func (ptr *QListWidget) ConnectItemDoubleClicked(f func(item *QListWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemDoubleClicked") {
			C.QListWidget_ConnectItemDoubleClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemDoubleClicked"); signal != nil {
			f := func(item *QListWidgetItem) {
				(*(*func(*QListWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemDoubleClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemDoubleClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectItemDoubleClicked() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectItemDoubleClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemDoubleClicked")
	}
}

func (ptr *QListWidget) ItemDoubleClicked(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_ItemDoubleClicked(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

//export callbackQListWidget_ItemEntered
func callbackQListWidget_ItemEntered(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemEntered"); signal != nil {
		(*(*func(*QListWidgetItem))(signal))(NewQListWidgetItemFromPointer(item))
	}

}

func (ptr *QListWidget) ConnectItemEntered(f func(item *QListWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemEntered") {
			C.QListWidget_ConnectItemEntered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemEntered"); signal != nil {
			f := func(item *QListWidgetItem) {
				(*(*func(*QListWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemEntered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemEntered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectItemEntered() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectItemEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemEntered")
	}
}

func (ptr *QListWidget) ItemEntered(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_ItemEntered(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

//export callbackQListWidget_ItemPressed
func callbackQListWidget_ItemPressed(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemPressed"); signal != nil {
		(*(*func(*QListWidgetItem))(signal))(NewQListWidgetItemFromPointer(item))
	}

}

func (ptr *QListWidget) ConnectItemPressed(f func(item *QListWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemPressed") {
			C.QListWidget_ConnectItemPressed(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemPressed"); signal != nil {
			f := func(item *QListWidgetItem) {
				(*(*func(*QListWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemPressed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemPressed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectItemPressed() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectItemPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemPressed")
	}
}

func (ptr *QListWidget) ItemPressed(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_ItemPressed(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

//export callbackQListWidget_ItemSelectionChanged
func callbackQListWidget_ItemSelectionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemSelectionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QListWidget) ConnectItemSelectionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemSelectionChanged") {
			C.QListWidget_ConnectItemSelectionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemSelectionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "itemSelectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemSelectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectItemSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QListWidget_DisconnectItemSelectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemSelectionChanged")
	}
}

func (ptr *QListWidget) ItemSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QListWidget_ItemSelectionChanged(ptr.Pointer())
	}
}

func (ptr *QListWidget) OpenPersistentEditor(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_OpenPersistentEditor(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

func (ptr *QListWidget) RemoveItemWidget(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_RemoveItemWidget(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

//export callbackQListWidget_ScrollToItem
func callbackQListWidget_ScrollToItem(ptr unsafe.Pointer, item unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "scrollToItem"); signal != nil {
		(*(*func(*QListWidgetItem, QAbstractItemView__ScrollHint))(signal))(NewQListWidgetItemFromPointer(item), QAbstractItemView__ScrollHint(hint))
	} else {
		NewQListWidgetFromPointer(ptr).ScrollToItemDefault(NewQListWidgetItemFromPointer(item), QAbstractItemView__ScrollHint(hint))
	}
}

func (ptr *QListWidget) ConnectScrollToItem(f func(item *QListWidgetItem, hint QAbstractItemView__ScrollHint)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "scrollToItem"); signal != nil {
			f := func(item *QListWidgetItem, hint QAbstractItemView__ScrollHint) {
				(*(*func(*QListWidgetItem, QAbstractItemView__ScrollHint))(signal))(item, hint)
				f(item, hint)
			}
			qt.ConnectSignal(ptr.Pointer(), "scrollToItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scrollToItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectScrollToItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "scrollToItem")
	}
}

func (ptr *QListWidget) ScrollToItem(item QListWidgetItem_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QListWidget_ScrollToItem(ptr.Pointer(), PointerFromQListWidgetItem(item), C.longlong(hint))
	}
}

func (ptr *QListWidget) ScrollToItemDefault(item QListWidgetItem_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QListWidget_ScrollToItemDefault(ptr.Pointer(), PointerFromQListWidgetItem(item), C.longlong(hint))
	}
}

func (ptr *QListWidget) SetCurrentItem(item QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_SetCurrentItem(ptr.Pointer(), PointerFromQListWidgetItem(item))
	}
}

func (ptr *QListWidget) SetCurrentItem2(item QListWidgetItem_ITF, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QListWidget_SetCurrentItem2(ptr.Pointer(), PointerFromQListWidgetItem(item), C.longlong(command))
	}
}

func (ptr *QListWidget) SetCurrentRow(row int) {
	if ptr.Pointer() != nil {
		C.QListWidget_SetCurrentRow(ptr.Pointer(), C.int(int32(row)))
	}
}

func (ptr *QListWidget) SetCurrentRow2(row int, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QListWidget_SetCurrentRow2(ptr.Pointer(), C.int(int32(row)), C.longlong(command))
	}
}

func (ptr *QListWidget) SetItemWidget(item QListWidgetItem_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget_SetItemWidget(ptr.Pointer(), PointerFromQListWidgetItem(item), PointerFromQWidget(widget))
	}
}

func (ptr *QListWidget) SetSortingEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QListWidget_SetSortingEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QListWidget) SortItems(order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QListWidget_SortItems(ptr.Pointer(), C.longlong(order))
	}
}

//export callbackQListWidget_DestroyQListWidget
func callbackQListWidget_DestroyQListWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QListWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQListWidgetFromPointer(ptr).DestroyQListWidgetDefault()
	}
}

func (ptr *QListWidget) ConnectDestroyQListWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QListWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QListWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QListWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectDestroyQListWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QListWidget")
	}
}

func (ptr *QListWidget) DestroyQListWidget() {
	if ptr.Pointer() != nil {
		C.QListWidget_DestroyQListWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QListWidget) DestroyQListWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QListWidget_DestroyQListWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QListWidget) FindItems(text string, flags core.Qt__MatchFlag) []*QListWidgetItem {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return func(l C.struct_QtWidgets_PackedList) []*QListWidgetItem {
			out := make([]*QListWidgetItem, int(l.len))
			tmpList := NewQListWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__findItems_atList(i)
			}
			return out
		}(C.QListWidget_FindItems(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(flags)))
	}
	return make([]*QListWidgetItem, 0)
}

func (ptr *QListWidget) Items(data core.QMimeData_ITF) []*QListWidgetItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QListWidgetItem {
			out := make([]*QListWidgetItem, int(l.len))
			tmpList := NewQListWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList(i)
			}
			return out
		}(C.QListWidget_Items(ptr.Pointer(), core.PointerFromQMimeData(data)))
	}
	return make([]*QListWidgetItem, 0)
}

func (ptr *QListWidget) SelectedItems() []*QListWidgetItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QListWidgetItem {
			out := make([]*QListWidgetItem, int(l.len))
			tmpList := NewQListWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedItems_atList(i)
			}
			return out
		}(C.QListWidget_SelectedItems(ptr.Pointer()))
	}
	return make([]*QListWidgetItem, 0)
}

func (ptr *QListWidget) CurrentItem() *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget_CurrentItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QListWidget) Item(row int) *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget_Item(ptr.Pointer(), C.int(int32(row))))
	}
	return nil
}

func (ptr *QListWidget) ItemAt(p core.QPoint_ITF) *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget_ItemAt(ptr.Pointer(), core.PointerFromQPoint(p)))
	}
	return nil
}

func (ptr *QListWidget) ItemAt2(x int, y int) *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget_ItemAt2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y))))
	}
	return nil
}

func (ptr *QListWidget) ItemFromIndex(index core.QModelIndex_ITF) *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget_ItemFromIndex(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return nil
}

//export callbackQListWidget_MimeData
func callbackQListWidget_MimeData(ptr unsafe.Pointer, items C.struct_QtWidgets_PackedList) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mimeData"); signal != nil {
		return core.PointerFromQMimeData((*(*func([]*QListWidgetItem) *core.QMimeData)(signal))(func(l C.struct_QtWidgets_PackedList) []*QListWidgetItem {
			out := make([]*QListWidgetItem, int(l.len))
			tmpList := NewQListWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__mimeData_items_atList(i)
			}
			return out
		}(items)))
	}

	return core.PointerFromQMimeData(NewQListWidgetFromPointer(ptr).MimeDataDefault(func(l C.struct_QtWidgets_PackedList) []*QListWidgetItem {
		out := make([]*QListWidgetItem, int(l.len))
		tmpList := NewQListWidgetFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__mimeData_items_atList(i)
		}
		return out
	}(items)))
}

func (ptr *QListWidget) ConnectMimeData(f func(items []*QListWidgetItem) *core.QMimeData) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mimeData"); signal != nil {
			f := func(items []*QListWidgetItem) *core.QMimeData {
				(*(*func([]*QListWidgetItem) *core.QMimeData)(signal))(items)
				return f(items)
			}
			qt.ConnectSignal(ptr.Pointer(), "mimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mimeData")
	}
}

func (ptr *QListWidget) MimeData(items []*QListWidgetItem) *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QListWidget_MimeData(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQListWidgetFromPointer(NewQListWidgetFromPointer(nil).__mimeData_items_newList())
			for _, v := range items {
				tmpList.__mimeData_items_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QListWidget) MimeDataDefault(items []*QListWidgetItem) *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QListWidget_MimeDataDefault(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQListWidgetFromPointer(NewQListWidgetFromPointer(nil).__mimeData_items_newList())
			for _, v := range items {
				tmpList.__mimeData_items_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QListWidget) IndexFromItem(item QListWidgetItem_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QListWidget_IndexFromItem(ptr.Pointer(), PointerFromQListWidgetItem(item)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QListWidget) VisualItemRect(item QListWidgetItem_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QListWidget_VisualItemRect(ptr.Pointer(), PointerFromQListWidgetItem(item)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQListWidget_MimeTypes
func callbackQListWidget_MimeTypes(ptr unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "mimeTypes"); signal != nil {
		tempVal := (*(*func() []string)(signal))()
		return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
	}
	tempVal := NewQListWidgetFromPointer(ptr).MimeTypesDefault()
	return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
}

func (ptr *QListWidget) ConnectMimeTypes(f func() []string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mimeTypes"); signal != nil {
			f := func() []string {
				(*(*func() []string)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "mimeTypes", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mimeTypes", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectMimeTypes() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mimeTypes")
	}
}

func (ptr *QListWidget) MimeTypes() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QListWidget_MimeTypes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QListWidget) MimeTypesDefault() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QListWidget_MimeTypesDefault(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QListWidget) ItemWidget(item QListWidgetItem_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QListWidget_ItemWidget(ptr.Pointer(), PointerFromQListWidgetItem(item)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQListWidget_SupportedDropActions
func callbackQListWidget_SupportedDropActions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "supportedDropActions"); signal != nil {
		return C.longlong((*(*func() core.Qt__DropAction)(signal))())
	}

	return C.longlong(NewQListWidgetFromPointer(ptr).SupportedDropActionsDefault())
}

func (ptr *QListWidget) ConnectSupportedDropActions(f func() core.Qt__DropAction) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "supportedDropActions"); signal != nil {
			f := func() core.Qt__DropAction {
				(*(*func() core.Qt__DropAction)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "supportedDropActions", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "supportedDropActions", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidget) DisconnectSupportedDropActions() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "supportedDropActions")
	}
}

func (ptr *QListWidget) SupportedDropActions() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QListWidget_SupportedDropActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QListWidget) SupportedDropActionsDefault() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QListWidget_SupportedDropActionsDefault(ptr.Pointer()))
	}
	return 0
}

func (ptr *QListWidget) IsPersistentEditorOpen(item QListWidgetItem_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QListWidget_IsPersistentEditorOpen(ptr.Pointer(), PointerFromQListWidgetItem(item))) != 0
	}
	return false
}

func (ptr *QListWidget) IsSortingEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QListWidget_IsSortingEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QListWidget) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListWidget_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QListWidget) CurrentRow() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListWidget_CurrentRow(ptr.Pointer())))
	}
	return 0
}

func (ptr *QListWidget) Row(item QListWidgetItem_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListWidget_Row(ptr.Pointer(), PointerFromQListWidgetItem(item))))
	}
	return 0
}

func (ptr *QListWidget) __findItems_atList(i int) *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget___findItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QListWidget) __findItems_setList(i QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget___findItems_setList(ptr.Pointer(), PointerFromQListWidgetItem(i))
	}
}

func (ptr *QListWidget) __findItems_newList() unsafe.Pointer {
	return C.QListWidget___findItems_newList(ptr.Pointer())
}

func (ptr *QListWidget) __items_atList(i int) *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget___items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QListWidget) __items_setList(i QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget___items_setList(ptr.Pointer(), PointerFromQListWidgetItem(i))
	}
}

func (ptr *QListWidget) __items_newList() unsafe.Pointer {
	return C.QListWidget___items_newList(ptr.Pointer())
}

func (ptr *QListWidget) __selectedItems_atList(i int) *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget___selectedItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QListWidget) __selectedItems_setList(i QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget___selectedItems_setList(ptr.Pointer(), PointerFromQListWidgetItem(i))
	}
}

func (ptr *QListWidget) __selectedItems_newList() unsafe.Pointer {
	return C.QListWidget___selectedItems_newList(ptr.Pointer())
}

func (ptr *QListWidget) __mimeData_items_atList(i int) *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidget___mimeData_items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QListWidget) __mimeData_items_setList(i QListWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidget___mimeData_items_setList(ptr.Pointer(), PointerFromQListWidgetItem(i))
	}
}

func (ptr *QListWidget) __mimeData_items_newList() unsafe.Pointer {
	return C.QListWidget___mimeData_items_newList(ptr.Pointer())
}

type QListWidgetItem struct {
	ptr unsafe.Pointer
}

type QListWidgetItem_ITF interface {
	QListWidgetItem_PTR() *QListWidgetItem
}

func (ptr *QListWidgetItem) QListWidgetItem_PTR() *QListWidgetItem {
	return ptr
}

func (ptr *QListWidgetItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QListWidgetItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQListWidgetItem(ptr QListWidgetItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QListWidgetItem_PTR().Pointer()
	}
	return nil
}

func NewQListWidgetItemFromPointer(ptr unsafe.Pointer) (n *QListWidgetItem) {
	n = new(QListWidgetItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QListWidgetItem__ItemType
//QListWidgetItem::ItemType
type QListWidgetItem__ItemType int64

const (
	QListWidgetItem__Type     QListWidgetItem__ItemType = QListWidgetItem__ItemType(0)
	QListWidgetItem__UserType QListWidgetItem__ItemType = QListWidgetItem__ItemType(1000)
)

func NewQListWidgetItem(parent QListWidget_ITF, ty int) *QListWidgetItem {
	return NewQListWidgetItemFromPointer(C.QListWidgetItem_NewQListWidgetItem(PointerFromQListWidget(parent), C.int(int32(ty))))
}

func NewQListWidgetItem3(icon gui.QIcon_ITF, text string, parent QListWidget_ITF, ty int) *QListWidgetItem {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return NewQListWidgetItemFromPointer(C.QListWidgetItem_NewQListWidgetItem3(gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQListWidget(parent), C.int(int32(ty))))
}

func NewQListWidgetItem4(other QListWidgetItem_ITF) *QListWidgetItem {
	return NewQListWidgetItemFromPointer(C.QListWidgetItem_NewQListWidgetItem4(PointerFromQListWidgetItem(other)))
}

func NewQListWidgetItem2(text string, parent QListWidget_ITF, ty int) *QListWidgetItem {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return NewQListWidgetItemFromPointer(C.QListWidgetItem_NewQListWidgetItem2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQListWidget(parent), C.int(int32(ty))))
}

//export callbackQListWidgetItem_Read
func callbackQListWidgetItem_Read(ptr unsafe.Pointer, in unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "read"); signal != nil {
		(*(*func(*core.QDataStream))(signal))(core.NewQDataStreamFromPointer(in))
	} else {
		NewQListWidgetItemFromPointer(ptr).ReadDefault(core.NewQDataStreamFromPointer(in))
	}
}

func (ptr *QListWidgetItem) ConnectRead(f func(in *core.QDataStream)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "read"); signal != nil {
			f := func(in *core.QDataStream) {
				(*(*func(*core.QDataStream))(signal))(in)
				f(in)
			}
			qt.ConnectSignal(ptr.Pointer(), "read", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "read", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidgetItem) DisconnectRead() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "read")
	}
}

func (ptr *QListWidgetItem) Read(in core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_Read(ptr.Pointer(), core.PointerFromQDataStream(in))
	}
}

func (ptr *QListWidgetItem) ReadDefault(in core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_ReadDefault(ptr.Pointer(), core.PointerFromQDataStream(in))
	}
}

func (ptr *QListWidgetItem) SetBackground(brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetBackground(ptr.Pointer(), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QListWidgetItem) SetCheckState(state core.Qt__CheckState) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetCheckState(ptr.Pointer(), C.longlong(state))
	}
}

//export callbackQListWidgetItem_SetData
func callbackQListWidgetItem_SetData(ptr unsafe.Pointer, role C.int, value unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setData"); signal != nil {
		(*(*func(int, *core.QVariant))(signal))(int(int32(role)), core.NewQVariantFromPointer(value))
	} else {
		NewQListWidgetItemFromPointer(ptr).SetDataDefault(int(int32(role)), core.NewQVariantFromPointer(value))
	}
}

func (ptr *QListWidgetItem) ConnectSetData(f func(role int, value *core.QVariant)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setData"); signal != nil {
			f := func(role int, value *core.QVariant) {
				(*(*func(int, *core.QVariant))(signal))(role, value)
				f(role, value)
			}
			qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidgetItem) DisconnectSetData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setData")
	}
}

func (ptr *QListWidgetItem) SetData(role int, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetData(ptr.Pointer(), C.int(int32(role)), core.PointerFromQVariant(value))
	}
}

func (ptr *QListWidgetItem) SetDataDefault(role int, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetDataDefault(ptr.Pointer(), C.int(int32(role)), core.PointerFromQVariant(value))
	}
}

func (ptr *QListWidgetItem) SetFlags(flags core.Qt__ItemFlag) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QListWidgetItem) SetFont(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetFont(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

func (ptr *QListWidgetItem) SetForeground(brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetForeground(ptr.Pointer(), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QListWidgetItem) SetHidden(hide bool) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetHidden(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

func (ptr *QListWidgetItem) SetIcon(icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QListWidgetItem) SetSelected(sele bool) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetSelected(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(sele))))
	}
}

func (ptr *QListWidgetItem) SetSizeHint(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetSizeHint(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QListWidgetItem) SetStatusTip(statusTip string) {
	if ptr.Pointer() != nil {
		var statusTipC *C.char
		if statusTip != "" {
			statusTipC = C.CString(statusTip)
			defer C.free(unsafe.Pointer(statusTipC))
		}
		C.QListWidgetItem_SetStatusTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: statusTipC, len: C.longlong(len(statusTip))})
	}
}

func (ptr *QListWidgetItem) SetText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QListWidgetItem_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QListWidgetItem) SetTextAlignment(alignment int) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_SetTextAlignment(ptr.Pointer(), C.int(int32(alignment)))
	}
}

func (ptr *QListWidgetItem) SetToolTip(toolTip string) {
	if ptr.Pointer() != nil {
		var toolTipC *C.char
		if toolTip != "" {
			toolTipC = C.CString(toolTip)
			defer C.free(unsafe.Pointer(toolTipC))
		}
		C.QListWidgetItem_SetToolTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: toolTipC, len: C.longlong(len(toolTip))})
	}
}

func (ptr *QListWidgetItem) SetWhatsThis(whatsThis string) {
	if ptr.Pointer() != nil {
		var whatsThisC *C.char
		if whatsThis != "" {
			whatsThisC = C.CString(whatsThis)
			defer C.free(unsafe.Pointer(whatsThisC))
		}
		C.QListWidgetItem_SetWhatsThis(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: whatsThisC, len: C.longlong(len(whatsThis))})
	}
}

//export callbackQListWidgetItem_DestroyQListWidgetItem
func callbackQListWidgetItem_DestroyQListWidgetItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QListWidgetItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQListWidgetItemFromPointer(ptr).DestroyQListWidgetItemDefault()
	}
}

func (ptr *QListWidgetItem) ConnectDestroyQListWidgetItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QListWidgetItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QListWidgetItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QListWidgetItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidgetItem) DisconnectDestroyQListWidgetItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QListWidgetItem")
	}
}

func (ptr *QListWidgetItem) DestroyQListWidgetItem() {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_DestroyQListWidgetItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QListWidgetItem) DestroyQListWidgetItemDefault() {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_DestroyQListWidgetItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QListWidgetItem) Background() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QListWidgetItem_Background(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QListWidgetItem) Foreground() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QListWidgetItem_Foreground(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QListWidgetItem) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QListWidgetItem_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QListWidgetItem) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QListWidgetItem_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QListWidgetItem) ListWidget() *QListWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQListWidgetFromPointer(C.QListWidgetItem_ListWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQListWidgetItem_Clone
func callbackQListWidgetItem_Clone(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "clone"); signal != nil {
		return PointerFromQListWidgetItem((*(*func() *QListWidgetItem)(signal))())
	}

	return PointerFromQListWidgetItem(NewQListWidgetItemFromPointer(ptr).CloneDefault())
}

func (ptr *QListWidgetItem) ConnectClone(f func() *QListWidgetItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clone"); signal != nil {
			f := func() *QListWidgetItem {
				(*(*func() *QListWidgetItem)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clone", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clone", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidgetItem) DisconnectClone() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clone")
	}
}

func (ptr *QListWidgetItem) Clone() *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidgetItem_Clone(ptr.Pointer()))
	}
	return nil
}

func (ptr *QListWidgetItem) CloneDefault() *QListWidgetItem {
	if ptr.Pointer() != nil {
		return NewQListWidgetItemFromPointer(C.QListWidgetItem_CloneDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QListWidgetItem) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QListWidgetItem_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QListWidgetItem) StatusTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QListWidgetItem_StatusTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QListWidgetItem) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QListWidgetItem_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QListWidgetItem) ToolTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QListWidgetItem_ToolTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QListWidgetItem) WhatsThis() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QListWidgetItem_WhatsThis(ptr.Pointer()))
	}
	return ""
}

//export callbackQListWidgetItem_Data
func callbackQListWidgetItem_Data(ptr unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return core.PointerFromQVariant((*(*func(int) *core.QVariant)(signal))(int(int32(role))))
	}

	return core.PointerFromQVariant(NewQListWidgetItemFromPointer(ptr).DataDefault(int(int32(role))))
}

func (ptr *QListWidgetItem) ConnectData(f func(role int) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "data"); signal != nil {
			f := func(role int) *core.QVariant {
				(*(*func(int) *core.QVariant)(signal))(role)
				return f(role)
			}
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidgetItem) DisconnectData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "data")
	}
}

func (ptr *QListWidgetItem) Data(role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QListWidgetItem_Data(ptr.Pointer(), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QListWidgetItem) DataDefault(role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QListWidgetItem_DataDefault(ptr.Pointer(), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QListWidgetItem) CheckState() core.Qt__CheckState {
	if ptr.Pointer() != nil {
		return core.Qt__CheckState(C.QListWidgetItem_CheckState(ptr.Pointer()))
	}
	return 0
}

func (ptr *QListWidgetItem) Flags() core.Qt__ItemFlag {
	if ptr.Pointer() != nil {
		return core.Qt__ItemFlag(C.QListWidgetItem_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QListWidgetItem) IsHidden() bool {
	if ptr.Pointer() != nil {
		return int8(C.QListWidgetItem_IsHidden(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QListWidgetItem) IsSelected() bool {
	if ptr.Pointer() != nil {
		return int8(C.QListWidgetItem_IsSelected(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QListWidgetItem) TextAlignment() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListWidgetItem_TextAlignment(ptr.Pointer())))
	}
	return 0
}

func (ptr *QListWidgetItem) Type() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QListWidgetItem_Type(ptr.Pointer())))
	}
	return 0
}

//export callbackQListWidgetItem_Write
func callbackQListWidgetItem_Write(ptr unsafe.Pointer, out unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "write"); signal != nil {
		(*(*func(*core.QDataStream))(signal))(core.NewQDataStreamFromPointer(out))
	} else {
		NewQListWidgetItemFromPointer(ptr).WriteDefault(core.NewQDataStreamFromPointer(out))
	}
}

func (ptr *QListWidgetItem) ConnectWrite(f func(out *core.QDataStream)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "write"); signal != nil {
			f := func(out *core.QDataStream) {
				(*(*func(*core.QDataStream))(signal))(out)
				f(out)
			}
			qt.ConnectSignal(ptr.Pointer(), "write", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "write", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QListWidgetItem) DisconnectWrite() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "write")
	}
}

func (ptr *QListWidgetItem) Write(out core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_Write(ptr.Pointer(), core.PointerFromQDataStream(out))
	}
}

func (ptr *QListWidgetItem) WriteDefault(out core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem_WriteDefault(ptr.Pointer(), core.PointerFromQDataStream(out))
	}
}

func (ptr *QListWidgetItem) __dummy_atList(i int) unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QListWidgetItem___dummy_atList(ptr.Pointer(), C.int(int32(i)))
	}
	return nil
}

func (ptr *QListWidgetItem) __dummy_setList(i unsafe.Pointer) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem___dummy_setList(ptr.Pointer(), i)
	}
}

func (ptr *QListWidgetItem) __dummy_newList() unsafe.Pointer {
	return C.QListWidgetItem___dummy_newList(ptr.Pointer())
}

func (ptr *QListWidgetItem) __setDummy__atList(i int) unsafe.Pointer {
	if ptr.Pointer() != nil {
		return C.QListWidgetItem___setDummy__atList(ptr.Pointer(), C.int(int32(i)))
	}
	return nil
}

func (ptr *QListWidgetItem) __setDummy__setList(i unsafe.Pointer) {
	if ptr.Pointer() != nil {
		C.QListWidgetItem___setDummy__setList(ptr.Pointer(), i)
	}
}

func (ptr *QListWidgetItem) __setDummy__newList() unsafe.Pointer {
	return C.QListWidgetItem___setDummy__newList(ptr.Pointer())
}

type QMainWindow struct {
	QWidget
}

type QMainWindow_ITF interface {
	QWidget_ITF
	QMainWindow_PTR() *QMainWindow
}

func (ptr *QMainWindow) QMainWindow_PTR() *QMainWindow {
	return ptr
}

func (ptr *QMainWindow) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QMainWindow) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQMainWindow(ptr QMainWindow_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMainWindow_PTR().Pointer()
	}
	return nil
}

func NewQMainWindowFromPointer(ptr unsafe.Pointer) (n *QMainWindow) {
	n = new(QMainWindow)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QMainWindow__DockOption
//QMainWindow::DockOption
type QMainWindow__DockOption int64

const (
	QMainWindow__AnimatedDocks    QMainWindow__DockOption = QMainWindow__DockOption(0x01)
	QMainWindow__AllowNestedDocks QMainWindow__DockOption = QMainWindow__DockOption(0x02)
	QMainWindow__AllowTabbedDocks QMainWindow__DockOption = QMainWindow__DockOption(0x04)
	QMainWindow__ForceTabbedDocks QMainWindow__DockOption = QMainWindow__DockOption(0x08)
	QMainWindow__VerticalTabs     QMainWindow__DockOption = QMainWindow__DockOption(0x10)
	QMainWindow__GroupedDragging  QMainWindow__DockOption = QMainWindow__DockOption(0x20)
)

func NewQMainWindow(parent QWidget_ITF, flags core.Qt__WindowType) *QMainWindow {
	tmpValue := NewQMainWindowFromPointer(C.QMainWindow_NewQMainWindow(PointerFromQWidget(parent), C.longlong(flags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQMainWindow_CreatePopupMenu
func callbackQMainWindow_CreatePopupMenu(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "createPopupMenu"); signal != nil {
		return PointerFromQMenu((*(*func() *QMenu)(signal))())
	}

	return PointerFromQMenu(NewQMainWindowFromPointer(ptr).CreatePopupMenuDefault())
}

func (ptr *QMainWindow) ConnectCreatePopupMenu(f func() *QMenu) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "createPopupMenu"); signal != nil {
			f := func() *QMenu {
				(*(*func() *QMenu)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "createPopupMenu", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "createPopupMenu", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMainWindow) DisconnectCreatePopupMenu() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "createPopupMenu")
	}
}

func (ptr *QMainWindow) CreatePopupMenu() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QMainWindow_CreatePopupMenu(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) CreatePopupMenuDefault() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QMainWindow_CreatePopupMenuDefault(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) AddToolBar3(title string) *QToolBar {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		tmpValue := NewQToolBarFromPointer(C.QMainWindow_AddToolBar3(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) TakeCentralWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QMainWindow_TakeCentralWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) RestoreDockWidget(dockwidget QDockWidget_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMainWindow_RestoreDockWidget(ptr.Pointer(), PointerFromQDockWidget(dockwidget))) != 0
	}
	return false
}

func (ptr *QMainWindow) RestoreState(state core.QByteArray_ITF, version int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMainWindow_RestoreState(ptr.Pointer(), core.PointerFromQByteArray(state), C.int(int32(version)))) != 0
	}
	return false
}

func (ptr *QMainWindow) AddDockWidget(area core.Qt__DockWidgetArea, dockwidget QDockWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_AddDockWidget(ptr.Pointer(), C.longlong(area), PointerFromQDockWidget(dockwidget))
	}
}

func (ptr *QMainWindow) AddDockWidget2(area core.Qt__DockWidgetArea, dockwidget QDockWidget_ITF, orientation core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QMainWindow_AddDockWidget2(ptr.Pointer(), C.longlong(area), PointerFromQDockWidget(dockwidget), C.longlong(orientation))
	}
}

func (ptr *QMainWindow) AddToolBar2(toolbar QToolBar_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_AddToolBar2(ptr.Pointer(), PointerFromQToolBar(toolbar))
	}
}

func (ptr *QMainWindow) AddToolBar(area core.Qt__ToolBarArea, toolbar QToolBar_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_AddToolBar(ptr.Pointer(), C.longlong(area), PointerFromQToolBar(toolbar))
	}
}

func (ptr *QMainWindow) AddToolBarBreak(area core.Qt__ToolBarArea) {
	if ptr.Pointer() != nil {
		C.QMainWindow_AddToolBarBreak(ptr.Pointer(), C.longlong(area))
	}
}

//export callbackQMainWindow_IconSizeChanged
func callbackQMainWindow_IconSizeChanged(ptr unsafe.Pointer, iconSize unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "iconSizeChanged"); signal != nil {
		(*(*func(*core.QSize))(signal))(core.NewQSizeFromPointer(iconSize))
	}

}

func (ptr *QMainWindow) ConnectIconSizeChanged(f func(iconSize *core.QSize)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "iconSizeChanged") {
			C.QMainWindow_ConnectIconSizeChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "iconSizeChanged"); signal != nil {
			f := func(iconSize *core.QSize) {
				(*(*func(*core.QSize))(signal))(iconSize)
				f(iconSize)
			}
			qt.ConnectSignal(ptr.Pointer(), "iconSizeChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "iconSizeChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMainWindow) DisconnectIconSizeChanged() {
	if ptr.Pointer() != nil {
		C.QMainWindow_DisconnectIconSizeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "iconSizeChanged")
	}
}

func (ptr *QMainWindow) IconSizeChanged(iconSize core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_IconSizeChanged(ptr.Pointer(), core.PointerFromQSize(iconSize))
	}
}

func (ptr *QMainWindow) InsertToolBar(before QToolBar_ITF, toolbar QToolBar_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_InsertToolBar(ptr.Pointer(), PointerFromQToolBar(before), PointerFromQToolBar(toolbar))
	}
}

func (ptr *QMainWindow) InsertToolBarBreak(before QToolBar_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_InsertToolBarBreak(ptr.Pointer(), PointerFromQToolBar(before))
	}
}

func (ptr *QMainWindow) RemoveDockWidget(dockwidget QDockWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_RemoveDockWidget(ptr.Pointer(), PointerFromQDockWidget(dockwidget))
	}
}

func (ptr *QMainWindow) RemoveToolBar(toolbar QToolBar_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_RemoveToolBar(ptr.Pointer(), PointerFromQToolBar(toolbar))
	}
}

func (ptr *QMainWindow) RemoveToolBarBreak(before QToolBar_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_RemoveToolBarBreak(ptr.Pointer(), PointerFromQToolBar(before))
	}
}

func (ptr *QMainWindow) ResizeDocks(docks []*QDockWidget, sizes []int, orientation core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QMainWindow_ResizeDocks(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQMainWindowFromPointer(NewQMainWindowFromPointer(nil).__resizeDocks_docks_newList())
			for _, v := range docks {
				tmpList.__resizeDocks_docks_setList(v)
			}
			return tmpList.Pointer()
		}(), func() unsafe.Pointer {
			tmpList := NewQMainWindowFromPointer(NewQMainWindowFromPointer(nil).__resizeDocks_sizes_newList())
			for _, v := range sizes {
				tmpList.__resizeDocks_sizes_setList(v)
			}
			return tmpList.Pointer()
		}(), C.longlong(orientation))
	}
}

//export callbackQMainWindow_SetAnimated
func callbackQMainWindow_SetAnimated(ptr unsafe.Pointer, enabled C.char) {
	if signal := qt.GetSignal(ptr, "setAnimated"); signal != nil {
		(*(*func(bool))(signal))(int8(enabled) != 0)
	} else {
		NewQMainWindowFromPointer(ptr).SetAnimatedDefault(int8(enabled) != 0)
	}
}

func (ptr *QMainWindow) ConnectSetAnimated(f func(enabled bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setAnimated"); signal != nil {
			f := func(enabled bool) {
				(*(*func(bool))(signal))(enabled)
				f(enabled)
			}
			qt.ConnectSignal(ptr.Pointer(), "setAnimated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setAnimated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMainWindow) DisconnectSetAnimated() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setAnimated")
	}
}

func (ptr *QMainWindow) SetAnimated(enabled bool) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetAnimated(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QMainWindow) SetAnimatedDefault(enabled bool) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetAnimatedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QMainWindow) SetCentralWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetCentralWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QMainWindow) SetCorner(corner core.Qt__Corner, area core.Qt__DockWidgetArea) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetCorner(ptr.Pointer(), C.longlong(corner), C.longlong(area))
	}
}

//export callbackQMainWindow_SetDockNestingEnabled
func callbackQMainWindow_SetDockNestingEnabled(ptr unsafe.Pointer, enabled C.char) {
	if signal := qt.GetSignal(ptr, "setDockNestingEnabled"); signal != nil {
		(*(*func(bool))(signal))(int8(enabled) != 0)
	} else {
		NewQMainWindowFromPointer(ptr).SetDockNestingEnabledDefault(int8(enabled) != 0)
	}
}

func (ptr *QMainWindow) ConnectSetDockNestingEnabled(f func(enabled bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setDockNestingEnabled"); signal != nil {
			f := func(enabled bool) {
				(*(*func(bool))(signal))(enabled)
				f(enabled)
			}
			qt.ConnectSignal(ptr.Pointer(), "setDockNestingEnabled", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setDockNestingEnabled", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMainWindow) DisconnectSetDockNestingEnabled() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setDockNestingEnabled")
	}
}

func (ptr *QMainWindow) SetDockNestingEnabled(enabled bool) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetDockNestingEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QMainWindow) SetDockNestingEnabledDefault(enabled bool) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetDockNestingEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QMainWindow) SetDockOptions(options QMainWindow__DockOption) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetDockOptions(ptr.Pointer(), C.longlong(options))
	}
}

func (ptr *QMainWindow) SetDocumentMode(enabled bool) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetDocumentMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QMainWindow) SetIconSize(iconSize core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetIconSize(ptr.Pointer(), core.PointerFromQSize(iconSize))
	}
}

func (ptr *QMainWindow) SetMenuBar(menuBar QMenuBar_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetMenuBar(ptr.Pointer(), PointerFromQMenuBar(menuBar))
	}
}

func (ptr *QMainWindow) SetMenuWidget(menuBar QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetMenuWidget(ptr.Pointer(), PointerFromQWidget(menuBar))
	}
}

func (ptr *QMainWindow) SetStatusBar(statusbar QStatusBar_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetStatusBar(ptr.Pointer(), PointerFromQStatusBar(statusbar))
	}
}

func (ptr *QMainWindow) SetTabPosition(areas core.Qt__DockWidgetArea, tabPosition QTabWidget__TabPosition) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetTabPosition(ptr.Pointer(), C.longlong(areas), C.longlong(tabPosition))
	}
}

func (ptr *QMainWindow) SetTabShape(tabShape QTabWidget__TabShape) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetTabShape(ptr.Pointer(), C.longlong(tabShape))
	}
}

func (ptr *QMainWindow) SetToolButtonStyle(toolButtonStyle core.Qt__ToolButtonStyle) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetToolButtonStyle(ptr.Pointer(), C.longlong(toolButtonStyle))
	}
}

//export callbackQMainWindow_SetUnifiedTitleAndToolBarOnMac
func callbackQMainWindow_SetUnifiedTitleAndToolBarOnMac(ptr unsafe.Pointer, set C.char) {
	if signal := qt.GetSignal(ptr, "setUnifiedTitleAndToolBarOnMac"); signal != nil {
		(*(*func(bool))(signal))(int8(set) != 0)
	} else {
		NewQMainWindowFromPointer(ptr).SetUnifiedTitleAndToolBarOnMacDefault(int8(set) != 0)
	}
}

func (ptr *QMainWindow) ConnectSetUnifiedTitleAndToolBarOnMac(f func(set bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setUnifiedTitleAndToolBarOnMac"); signal != nil {
			f := func(set bool) {
				(*(*func(bool))(signal))(set)
				f(set)
			}
			qt.ConnectSignal(ptr.Pointer(), "setUnifiedTitleAndToolBarOnMac", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setUnifiedTitleAndToolBarOnMac", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMainWindow) DisconnectSetUnifiedTitleAndToolBarOnMac() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setUnifiedTitleAndToolBarOnMac")
	}
}

func (ptr *QMainWindow) SetUnifiedTitleAndToolBarOnMac(set bool) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetUnifiedTitleAndToolBarOnMac(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(set))))
	}
}

func (ptr *QMainWindow) SetUnifiedTitleAndToolBarOnMacDefault(set bool) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SetUnifiedTitleAndToolBarOnMacDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(set))))
	}
}

func (ptr *QMainWindow) SplitDockWidget(first QDockWidget_ITF, second QDockWidget_ITF, orientation core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QMainWindow_SplitDockWidget(ptr.Pointer(), PointerFromQDockWidget(first), PointerFromQDockWidget(second), C.longlong(orientation))
	}
}

//export callbackQMainWindow_TabifiedDockWidgetActivated
func callbackQMainWindow_TabifiedDockWidgetActivated(ptr unsafe.Pointer, dockWidget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "tabifiedDockWidgetActivated"); signal != nil {
		(*(*func(*QDockWidget))(signal))(NewQDockWidgetFromPointer(dockWidget))
	}

}

func (ptr *QMainWindow) ConnectTabifiedDockWidgetActivated(f func(dockWidget *QDockWidget)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "tabifiedDockWidgetActivated") {
			C.QMainWindow_ConnectTabifiedDockWidgetActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "tabifiedDockWidgetActivated"); signal != nil {
			f := func(dockWidget *QDockWidget) {
				(*(*func(*QDockWidget))(signal))(dockWidget)
				f(dockWidget)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabifiedDockWidgetActivated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabifiedDockWidgetActivated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMainWindow) DisconnectTabifiedDockWidgetActivated() {
	if ptr.Pointer() != nil {
		C.QMainWindow_DisconnectTabifiedDockWidgetActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "tabifiedDockWidgetActivated")
	}
}

func (ptr *QMainWindow) TabifiedDockWidgetActivated(dockWidget QDockWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_TabifiedDockWidgetActivated(ptr.Pointer(), PointerFromQDockWidget(dockWidget))
	}
}

func (ptr *QMainWindow) TabifyDockWidget(first QDockWidget_ITF, second QDockWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow_TabifyDockWidget(ptr.Pointer(), PointerFromQDockWidget(first), PointerFromQDockWidget(second))
	}
}

//export callbackQMainWindow_ToolButtonStyleChanged
func callbackQMainWindow_ToolButtonStyleChanged(ptr unsafe.Pointer, toolButtonStyle C.longlong) {
	if signal := qt.GetSignal(ptr, "toolButtonStyleChanged"); signal != nil {
		(*(*func(core.Qt__ToolButtonStyle))(signal))(core.Qt__ToolButtonStyle(toolButtonStyle))
	}

}

func (ptr *QMainWindow) ConnectToolButtonStyleChanged(f func(toolButtonStyle core.Qt__ToolButtonStyle)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "toolButtonStyleChanged") {
			C.QMainWindow_ConnectToolButtonStyleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "toolButtonStyleChanged"); signal != nil {
			f := func(toolButtonStyle core.Qt__ToolButtonStyle) {
				(*(*func(core.Qt__ToolButtonStyle))(signal))(toolButtonStyle)
				f(toolButtonStyle)
			}
			qt.ConnectSignal(ptr.Pointer(), "toolButtonStyleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "toolButtonStyleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMainWindow) DisconnectToolButtonStyleChanged() {
	if ptr.Pointer() != nil {
		C.QMainWindow_DisconnectToolButtonStyleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "toolButtonStyleChanged")
	}
}

func (ptr *QMainWindow) ToolButtonStyleChanged(toolButtonStyle core.Qt__ToolButtonStyle) {
	if ptr.Pointer() != nil {
		C.QMainWindow_ToolButtonStyleChanged(ptr.Pointer(), C.longlong(toolButtonStyle))
	}
}

//export callbackQMainWindow_DestroyQMainWindow
func callbackQMainWindow_DestroyQMainWindow(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QMainWindow"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMainWindowFromPointer(ptr).DestroyQMainWindowDefault()
	}
}

func (ptr *QMainWindow) ConnectDestroyQMainWindow(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QMainWindow"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QMainWindow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QMainWindow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMainWindow) DisconnectDestroyQMainWindow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QMainWindow")
	}
}

func (ptr *QMainWindow) DestroyQMainWindow() {
	if ptr.Pointer() != nil {
		C.QMainWindow_DestroyQMainWindow(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMainWindow) DestroyQMainWindowDefault() {
	if ptr.Pointer() != nil {
		C.QMainWindow_DestroyQMainWindowDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMainWindow) SaveState(version int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QMainWindow_SaveState(ptr.Pointer(), C.int(int32(version))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) TabifiedDockWidgets(dockwidget QDockWidget_ITF) []*QDockWidget {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QDockWidget {
			out := make([]*QDockWidget, int(l.len))
			tmpList := NewQMainWindowFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__tabifiedDockWidgets_atList(i)
			}
			return out
		}(C.QMainWindow_TabifiedDockWidgets(ptr.Pointer(), PointerFromQDockWidget(dockwidget)))
	}
	return make([]*QDockWidget, 0)
}

func (ptr *QMainWindow) DockOptions() QMainWindow__DockOption {
	if ptr.Pointer() != nil {
		return QMainWindow__DockOption(C.QMainWindow_DockOptions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMainWindow) MenuBar() *QMenuBar {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuBarFromPointer(C.QMainWindow_MenuBar(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QMainWindow_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) StatusBar() *QStatusBar {
	if ptr.Pointer() != nil {
		tmpValue := NewQStatusBarFromPointer(C.QMainWindow_StatusBar(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) TabPosition(area core.Qt__DockWidgetArea) QTabWidget__TabPosition {
	if ptr.Pointer() != nil {
		return QTabWidget__TabPosition(C.QMainWindow_TabPosition(ptr.Pointer(), C.longlong(area)))
	}
	return 0
}

func (ptr *QMainWindow) TabShape() QTabWidget__TabShape {
	if ptr.Pointer() != nil {
		return QTabWidget__TabShape(C.QMainWindow_TabShape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMainWindow) CentralWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QMainWindow_CentralWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) MenuWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QMainWindow_MenuWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) Corner(corner core.Qt__Corner) core.Qt__DockWidgetArea {
	if ptr.Pointer() != nil {
		return core.Qt__DockWidgetArea(C.QMainWindow_Corner(ptr.Pointer(), C.longlong(corner)))
	}
	return 0
}

func (ptr *QMainWindow) DockWidgetArea(dockwidget QDockWidget_ITF) core.Qt__DockWidgetArea {
	if ptr.Pointer() != nil {
		return core.Qt__DockWidgetArea(C.QMainWindow_DockWidgetArea(ptr.Pointer(), PointerFromQDockWidget(dockwidget)))
	}
	return 0
}

func (ptr *QMainWindow) ToolBarArea(toolbar QToolBar_ITF) core.Qt__ToolBarArea {
	if ptr.Pointer() != nil {
		return core.Qt__ToolBarArea(C.QMainWindow_ToolBarArea(ptr.Pointer(), PointerFromQToolBar(toolbar)))
	}
	return 0
}

func (ptr *QMainWindow) ToolButtonStyle() core.Qt__ToolButtonStyle {
	if ptr.Pointer() != nil {
		return core.Qt__ToolButtonStyle(C.QMainWindow_ToolButtonStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMainWindow) DocumentMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMainWindow_DocumentMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMainWindow) IsAnimated() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMainWindow_IsAnimated(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMainWindow) IsDockNestingEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMainWindow_IsDockNestingEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMainWindow) ToolBarBreak(toolbar QToolBar_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMainWindow_ToolBarBreak(ptr.Pointer(), PointerFromQToolBar(toolbar))) != 0
	}
	return false
}

func (ptr *QMainWindow) UnifiedTitleAndToolBarOnMac() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMainWindow_UnifiedTitleAndToolBarOnMac(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMainWindow) __resizeDocks_docks_atList(i int) *QDockWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQDockWidgetFromPointer(C.QMainWindow___resizeDocks_docks_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) __resizeDocks_docks_setList(i QDockWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow___resizeDocks_docks_setList(ptr.Pointer(), PointerFromQDockWidget(i))
	}
}

func (ptr *QMainWindow) __resizeDocks_docks_newList() unsafe.Pointer {
	return C.QMainWindow___resizeDocks_docks_newList(ptr.Pointer())
}

func (ptr *QMainWindow) __resizeDocks_sizes_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMainWindow___resizeDocks_sizes_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QMainWindow) __resizeDocks_sizes_setList(i int) {
	if ptr.Pointer() != nil {
		C.QMainWindow___resizeDocks_sizes_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QMainWindow) __resizeDocks_sizes_newList() unsafe.Pointer {
	return C.QMainWindow___resizeDocks_sizes_newList(ptr.Pointer())
}

func (ptr *QMainWindow) __tabifiedDockWidgets_atList(i int) *QDockWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQDockWidgetFromPointer(C.QMainWindow___tabifiedDockWidgets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMainWindow) __tabifiedDockWidgets_setList(i QDockWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMainWindow___tabifiedDockWidgets_setList(ptr.Pointer(), PointerFromQDockWidget(i))
	}
}

func (ptr *QMainWindow) __tabifiedDockWidgets_newList() unsafe.Pointer {
	return C.QMainWindow___tabifiedDockWidgets_newList(ptr.Pointer())
}

type QMdiArea struct {
	QAbstractScrollArea
}

type QMdiArea_ITF interface {
	QAbstractScrollArea_ITF
	QMdiArea_PTR() *QMdiArea
}

func (ptr *QMdiArea) QMdiArea_PTR() *QMdiArea {
	return ptr
}

func (ptr *QMdiArea) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractScrollArea_PTR().Pointer()
	}
	return nil
}

func (ptr *QMdiArea) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractScrollArea_PTR().SetPointer(p)
	}
}

func PointerFromQMdiArea(ptr QMdiArea_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMdiArea_PTR().Pointer()
	}
	return nil
}

func NewQMdiAreaFromPointer(ptr unsafe.Pointer) (n *QMdiArea) {
	n = new(QMdiArea)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QMdiArea__AreaOption
//QMdiArea::AreaOption
type QMdiArea__AreaOption int64

const (
	QMdiArea__DontMaximizeSubWindowOnActivation QMdiArea__AreaOption = QMdiArea__AreaOption(0x1)
)

//go:generate stringer -type=QMdiArea__ViewMode
//QMdiArea::ViewMode
type QMdiArea__ViewMode int64

const (
	QMdiArea__SubWindowView QMdiArea__ViewMode = QMdiArea__ViewMode(0)
	QMdiArea__TabbedView    QMdiArea__ViewMode = QMdiArea__ViewMode(1)
)

//go:generate stringer -type=QMdiArea__WindowOrder
//QMdiArea::WindowOrder
type QMdiArea__WindowOrder int64

const (
	QMdiArea__CreationOrder          QMdiArea__WindowOrder = QMdiArea__WindowOrder(0)
	QMdiArea__StackingOrder          QMdiArea__WindowOrder = QMdiArea__WindowOrder(1)
	QMdiArea__ActivationHistoryOrder QMdiArea__WindowOrder = QMdiArea__WindowOrder(2)
)

func NewQMdiArea(parent QWidget_ITF) *QMdiArea {
	tmpValue := NewQMdiAreaFromPointer(C.QMdiArea_NewQMdiArea(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QMdiArea) AddSubWindow(widget QWidget_ITF, windowFlags core.Qt__WindowType) *QMdiSubWindow {
	if ptr.Pointer() != nil {
		tmpValue := NewQMdiSubWindowFromPointer(C.QMdiArea_AddSubWindow(ptr.Pointer(), PointerFromQWidget(widget), C.longlong(windowFlags)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQMdiArea_ActivateNextSubWindow
func callbackQMdiArea_ActivateNextSubWindow(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "activateNextSubWindow"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiAreaFromPointer(ptr).ActivateNextSubWindowDefault()
	}
}

func (ptr *QMdiArea) ConnectActivateNextSubWindow(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "activateNextSubWindow"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "activateNextSubWindow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "activateNextSubWindow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectActivateNextSubWindow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "activateNextSubWindow")
	}
}

func (ptr *QMdiArea) ActivateNextSubWindow() {
	if ptr.Pointer() != nil {
		C.QMdiArea_ActivateNextSubWindow(ptr.Pointer())
	}
}

func (ptr *QMdiArea) ActivateNextSubWindowDefault() {
	if ptr.Pointer() != nil {
		C.QMdiArea_ActivateNextSubWindowDefault(ptr.Pointer())
	}
}

//export callbackQMdiArea_ActivatePreviousSubWindow
func callbackQMdiArea_ActivatePreviousSubWindow(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "activatePreviousSubWindow"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiAreaFromPointer(ptr).ActivatePreviousSubWindowDefault()
	}
}

func (ptr *QMdiArea) ConnectActivatePreviousSubWindow(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "activatePreviousSubWindow"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "activatePreviousSubWindow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "activatePreviousSubWindow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectActivatePreviousSubWindow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "activatePreviousSubWindow")
	}
}

func (ptr *QMdiArea) ActivatePreviousSubWindow() {
	if ptr.Pointer() != nil {
		C.QMdiArea_ActivatePreviousSubWindow(ptr.Pointer())
	}
}

func (ptr *QMdiArea) ActivatePreviousSubWindowDefault() {
	if ptr.Pointer() != nil {
		C.QMdiArea_ActivatePreviousSubWindowDefault(ptr.Pointer())
	}
}

//export callbackQMdiArea_CascadeSubWindows
func callbackQMdiArea_CascadeSubWindows(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "cascadeSubWindows"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiAreaFromPointer(ptr).CascadeSubWindowsDefault()
	}
}

func (ptr *QMdiArea) ConnectCascadeSubWindows(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "cascadeSubWindows"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "cascadeSubWindows", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cascadeSubWindows", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectCascadeSubWindows() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "cascadeSubWindows")
	}
}

func (ptr *QMdiArea) CascadeSubWindows() {
	if ptr.Pointer() != nil {
		C.QMdiArea_CascadeSubWindows(ptr.Pointer())
	}
}

func (ptr *QMdiArea) CascadeSubWindowsDefault() {
	if ptr.Pointer() != nil {
		C.QMdiArea_CascadeSubWindowsDefault(ptr.Pointer())
	}
}

//export callbackQMdiArea_CloseActiveSubWindow
func callbackQMdiArea_CloseActiveSubWindow(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "closeActiveSubWindow"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiAreaFromPointer(ptr).CloseActiveSubWindowDefault()
	}
}

func (ptr *QMdiArea) ConnectCloseActiveSubWindow(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "closeActiveSubWindow"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "closeActiveSubWindow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "closeActiveSubWindow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectCloseActiveSubWindow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "closeActiveSubWindow")
	}
}

func (ptr *QMdiArea) CloseActiveSubWindow() {
	if ptr.Pointer() != nil {
		C.QMdiArea_CloseActiveSubWindow(ptr.Pointer())
	}
}

func (ptr *QMdiArea) CloseActiveSubWindowDefault() {
	if ptr.Pointer() != nil {
		C.QMdiArea_CloseActiveSubWindowDefault(ptr.Pointer())
	}
}

//export callbackQMdiArea_CloseAllSubWindows
func callbackQMdiArea_CloseAllSubWindows(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "closeAllSubWindows"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiAreaFromPointer(ptr).CloseAllSubWindowsDefault()
	}
}

func (ptr *QMdiArea) ConnectCloseAllSubWindows(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "closeAllSubWindows"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "closeAllSubWindows", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "closeAllSubWindows", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectCloseAllSubWindows() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "closeAllSubWindows")
	}
}

func (ptr *QMdiArea) CloseAllSubWindows() {
	if ptr.Pointer() != nil {
		C.QMdiArea_CloseAllSubWindows(ptr.Pointer())
	}
}

func (ptr *QMdiArea) CloseAllSubWindowsDefault() {
	if ptr.Pointer() != nil {
		C.QMdiArea_CloseAllSubWindowsDefault(ptr.Pointer())
	}
}

func (ptr *QMdiArea) RemoveSubWindow(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiArea_RemoveSubWindow(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QMdiArea) SetActivationOrder(order QMdiArea__WindowOrder) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetActivationOrder(ptr.Pointer(), C.longlong(order))
	}
}

//export callbackQMdiArea_SetActiveSubWindow
func callbackQMdiArea_SetActiveSubWindow(ptr unsafe.Pointer, window unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setActiveSubWindow"); signal != nil {
		(*(*func(*QMdiSubWindow))(signal))(NewQMdiSubWindowFromPointer(window))
	} else {
		NewQMdiAreaFromPointer(ptr).SetActiveSubWindowDefault(NewQMdiSubWindowFromPointer(window))
	}
}

func (ptr *QMdiArea) ConnectSetActiveSubWindow(f func(window *QMdiSubWindow)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setActiveSubWindow"); signal != nil {
			f := func(window *QMdiSubWindow) {
				(*(*func(*QMdiSubWindow))(signal))(window)
				f(window)
			}
			qt.ConnectSignal(ptr.Pointer(), "setActiveSubWindow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setActiveSubWindow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectSetActiveSubWindow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setActiveSubWindow")
	}
}

func (ptr *QMdiArea) SetActiveSubWindow(window QMdiSubWindow_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetActiveSubWindow(ptr.Pointer(), PointerFromQMdiSubWindow(window))
	}
}

func (ptr *QMdiArea) SetActiveSubWindowDefault(window QMdiSubWindow_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetActiveSubWindowDefault(ptr.Pointer(), PointerFromQMdiSubWindow(window))
	}
}

func (ptr *QMdiArea) SetBackground(background gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetBackground(ptr.Pointer(), gui.PointerFromQBrush(background))
	}
}

func (ptr *QMdiArea) SetDocumentMode(enabled bool) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetDocumentMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QMdiArea) SetOption(option QMdiArea__AreaOption, on bool) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetOption(ptr.Pointer(), C.longlong(option), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QMdiArea) SetTabPosition(position QTabWidget__TabPosition) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetTabPosition(ptr.Pointer(), C.longlong(position))
	}
}

func (ptr *QMdiArea) SetTabShape(shape QTabWidget__TabShape) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetTabShape(ptr.Pointer(), C.longlong(shape))
	}
}

func (ptr *QMdiArea) SetTabsClosable(closable bool) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetTabsClosable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(closable))))
	}
}

func (ptr *QMdiArea) SetTabsMovable(movable bool) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetTabsMovable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(movable))))
	}
}

func (ptr *QMdiArea) SetViewMode(mode QMdiArea__ViewMode) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetViewMode(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQMdiArea_SetupViewport
func callbackQMdiArea_SetupViewport(ptr unsafe.Pointer, viewport unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setupViewport"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(viewport))
	} else {
		NewQMdiAreaFromPointer(ptr).SetupViewportDefault(NewQWidgetFromPointer(viewport))
	}
}

func (ptr *QMdiArea) ConnectSetupViewport(f func(viewport *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setupViewport"); signal != nil {
			f := func(viewport *QWidget) {
				(*(*func(*QWidget))(signal))(viewport)
				f(viewport)
			}
			qt.ConnectSignal(ptr.Pointer(), "setupViewport", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setupViewport", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectSetupViewport() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setupViewport")
	}
}

func (ptr *QMdiArea) SetupViewport(viewport QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetupViewport(ptr.Pointer(), PointerFromQWidget(viewport))
	}
}

func (ptr *QMdiArea) SetupViewportDefault(viewport QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SetupViewportDefault(ptr.Pointer(), PointerFromQWidget(viewport))
	}
}

//export callbackQMdiArea_SubWindowActivated
func callbackQMdiArea_SubWindowActivated(ptr unsafe.Pointer, window unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "subWindowActivated"); signal != nil {
		(*(*func(*QMdiSubWindow))(signal))(NewQMdiSubWindowFromPointer(window))
	}

}

func (ptr *QMdiArea) ConnectSubWindowActivated(f func(window *QMdiSubWindow)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "subWindowActivated") {
			C.QMdiArea_ConnectSubWindowActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "subWindowActivated"); signal != nil {
			f := func(window *QMdiSubWindow) {
				(*(*func(*QMdiSubWindow))(signal))(window)
				f(window)
			}
			qt.ConnectSignal(ptr.Pointer(), "subWindowActivated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "subWindowActivated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectSubWindowActivated() {
	if ptr.Pointer() != nil {
		C.QMdiArea_DisconnectSubWindowActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "subWindowActivated")
	}
}

func (ptr *QMdiArea) SubWindowActivated(window QMdiSubWindow_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiArea_SubWindowActivated(ptr.Pointer(), PointerFromQMdiSubWindow(window))
	}
}

//export callbackQMdiArea_TileSubWindows
func callbackQMdiArea_TileSubWindows(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "tileSubWindows"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiAreaFromPointer(ptr).TileSubWindowsDefault()
	}
}

func (ptr *QMdiArea) ConnectTileSubWindows(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "tileSubWindows"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "tileSubWindows", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tileSubWindows", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectTileSubWindows() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "tileSubWindows")
	}
}

func (ptr *QMdiArea) TileSubWindows() {
	if ptr.Pointer() != nil {
		C.QMdiArea_TileSubWindows(ptr.Pointer())
	}
}

func (ptr *QMdiArea) TileSubWindowsDefault() {
	if ptr.Pointer() != nil {
		C.QMdiArea_TileSubWindowsDefault(ptr.Pointer())
	}
}

//export callbackQMdiArea_DestroyQMdiArea
func callbackQMdiArea_DestroyQMdiArea(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QMdiArea"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiAreaFromPointer(ptr).DestroyQMdiAreaDefault()
	}
}

func (ptr *QMdiArea) ConnectDestroyQMdiArea(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QMdiArea"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QMdiArea", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QMdiArea", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiArea) DisconnectDestroyQMdiArea() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QMdiArea")
	}
}

func (ptr *QMdiArea) DestroyQMdiArea() {
	if ptr.Pointer() != nil {
		C.QMdiArea_DestroyQMdiArea(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMdiArea) DestroyQMdiAreaDefault() {
	if ptr.Pointer() != nil {
		C.QMdiArea_DestroyQMdiAreaDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMdiArea) Background() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QMdiArea_Background(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QMdiArea) SubWindowList(order QMdiArea__WindowOrder) []*QMdiSubWindow {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QMdiSubWindow {
			out := make([]*QMdiSubWindow, int(l.len))
			tmpList := NewQMdiAreaFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__subWindowList_atList(i)
			}
			return out
		}(C.QMdiArea_SubWindowList(ptr.Pointer(), C.longlong(order)))
	}
	return make([]*QMdiSubWindow, 0)
}

func (ptr *QMdiArea) ViewMode() QMdiArea__ViewMode {
	if ptr.Pointer() != nil {
		return QMdiArea__ViewMode(C.QMdiArea_ViewMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMdiArea) ActivationOrder() QMdiArea__WindowOrder {
	if ptr.Pointer() != nil {
		return QMdiArea__WindowOrder(C.QMdiArea_ActivationOrder(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMdiArea) ActiveSubWindow() *QMdiSubWindow {
	if ptr.Pointer() != nil {
		tmpValue := NewQMdiSubWindowFromPointer(C.QMdiArea_ActiveSubWindow(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMdiArea) CurrentSubWindow() *QMdiSubWindow {
	if ptr.Pointer() != nil {
		tmpValue := NewQMdiSubWindowFromPointer(C.QMdiArea_CurrentSubWindow(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMdiArea) TabPosition() QTabWidget__TabPosition {
	if ptr.Pointer() != nil {
		return QTabWidget__TabPosition(C.QMdiArea_TabPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMdiArea) TabShape() QTabWidget__TabShape {
	if ptr.Pointer() != nil {
		return QTabWidget__TabShape(C.QMdiArea_TabShape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMdiArea) DocumentMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMdiArea_DocumentMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMdiArea) TabsClosable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMdiArea_TabsClosable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMdiArea) TabsMovable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMdiArea_TabsMovable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMdiArea) TestOption(option QMdiArea__AreaOption) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMdiArea_TestOption(ptr.Pointer(), C.longlong(option))) != 0
	}
	return false
}

func (ptr *QMdiArea) __subWindowList_atList(i int) *QMdiSubWindow {
	if ptr.Pointer() != nil {
		tmpValue := NewQMdiSubWindowFromPointer(C.QMdiArea___subWindowList_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMdiArea) __subWindowList_setList(i QMdiSubWindow_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiArea___subWindowList_setList(ptr.Pointer(), PointerFromQMdiSubWindow(i))
	}
}

func (ptr *QMdiArea) __subWindowList_newList() unsafe.Pointer {
	return C.QMdiArea___subWindowList_newList(ptr.Pointer())
}

type QMdiSubWindow struct {
	QWidget
}

type QMdiSubWindow_ITF interface {
	QWidget_ITF
	QMdiSubWindow_PTR() *QMdiSubWindow
}

func (ptr *QMdiSubWindow) QMdiSubWindow_PTR() *QMdiSubWindow {
	return ptr
}

func (ptr *QMdiSubWindow) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QMdiSubWindow) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQMdiSubWindow(ptr QMdiSubWindow_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMdiSubWindow_PTR().Pointer()
	}
	return nil
}

func NewQMdiSubWindowFromPointer(ptr unsafe.Pointer) (n *QMdiSubWindow) {
	n = new(QMdiSubWindow)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QMdiSubWindow__SubWindowOption
//QMdiSubWindow::SubWindowOption
type QMdiSubWindow__SubWindowOption int64

const (
	QMdiSubWindow__AllowOutsideAreaHorizontally QMdiSubWindow__SubWindowOption = QMdiSubWindow__SubWindowOption(0x1)
	QMdiSubWindow__AllowOutsideAreaVertically   QMdiSubWindow__SubWindowOption = QMdiSubWindow__SubWindowOption(0x2)
	QMdiSubWindow__RubberBandResize             QMdiSubWindow__SubWindowOption = QMdiSubWindow__SubWindowOption(0x4)
	QMdiSubWindow__RubberBandMove               QMdiSubWindow__SubWindowOption = QMdiSubWindow__SubWindowOption(0x8)
)

func NewQMdiSubWindow(parent QWidget_ITF, flags core.Qt__WindowType) *QMdiSubWindow {
	tmpValue := NewQMdiSubWindowFromPointer(C.QMdiSubWindow_NewQMdiSubWindow(PointerFromQWidget(parent), C.longlong(flags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQMdiSubWindow_AboutToActivate
func callbackQMdiSubWindow_AboutToActivate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "aboutToActivate"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QMdiSubWindow) ConnectAboutToActivate(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "aboutToActivate") {
			C.QMdiSubWindow_ConnectAboutToActivate(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "aboutToActivate"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "aboutToActivate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "aboutToActivate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiSubWindow) DisconnectAboutToActivate() {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_DisconnectAboutToActivate(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "aboutToActivate")
	}
}

func (ptr *QMdiSubWindow) AboutToActivate() {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_AboutToActivate(ptr.Pointer())
	}
}

func (ptr *QMdiSubWindow) SetKeyboardPageStep(step int) {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_SetKeyboardPageStep(ptr.Pointer(), C.int(int32(step)))
	}
}

func (ptr *QMdiSubWindow) SetKeyboardSingleStep(step int) {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_SetKeyboardSingleStep(ptr.Pointer(), C.int(int32(step)))
	}
}

func (ptr *QMdiSubWindow) SetOption(option QMdiSubWindow__SubWindowOption, on bool) {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_SetOption(ptr.Pointer(), C.longlong(option), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QMdiSubWindow) SetSystemMenu(systemMenu QMenu_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_SetSystemMenu(ptr.Pointer(), PointerFromQMenu(systemMenu))
	}
}

func (ptr *QMdiSubWindow) SetWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_SetWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQMdiSubWindow_ShowShaded
func callbackQMdiSubWindow_ShowShaded(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showShaded"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiSubWindowFromPointer(ptr).ShowShadedDefault()
	}
}

func (ptr *QMdiSubWindow) ConnectShowShaded(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showShaded"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "showShaded", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showShaded", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiSubWindow) DisconnectShowShaded() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showShaded")
	}
}

func (ptr *QMdiSubWindow) ShowShaded() {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_ShowShaded(ptr.Pointer())
	}
}

func (ptr *QMdiSubWindow) ShowShadedDefault() {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_ShowShadedDefault(ptr.Pointer())
	}
}

//export callbackQMdiSubWindow_ShowSystemMenu
func callbackQMdiSubWindow_ShowSystemMenu(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showSystemMenu"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiSubWindowFromPointer(ptr).ShowSystemMenuDefault()
	}
}

func (ptr *QMdiSubWindow) ConnectShowSystemMenu(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showSystemMenu"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "showSystemMenu", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showSystemMenu", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiSubWindow) DisconnectShowSystemMenu() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showSystemMenu")
	}
}

func (ptr *QMdiSubWindow) ShowSystemMenu() {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_ShowSystemMenu(ptr.Pointer())
	}
}

func (ptr *QMdiSubWindow) ShowSystemMenuDefault() {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_ShowSystemMenuDefault(ptr.Pointer())
	}
}

//export callbackQMdiSubWindow_WindowStateChanged
func callbackQMdiSubWindow_WindowStateChanged(ptr unsafe.Pointer, oldState C.longlong, newState C.longlong) {
	if signal := qt.GetSignal(ptr, "windowStateChanged"); signal != nil {
		(*(*func(core.Qt__WindowState, core.Qt__WindowState))(signal))(core.Qt__WindowState(oldState), core.Qt__WindowState(newState))
	}

}

func (ptr *QMdiSubWindow) ConnectWindowStateChanged(f func(oldState core.Qt__WindowState, newState core.Qt__WindowState)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "windowStateChanged") {
			C.QMdiSubWindow_ConnectWindowStateChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "windowStateChanged"); signal != nil {
			f := func(oldState core.Qt__WindowState, newState core.Qt__WindowState) {
				(*(*func(core.Qt__WindowState, core.Qt__WindowState))(signal))(oldState, newState)
				f(oldState, newState)
			}
			qt.ConnectSignal(ptr.Pointer(), "windowStateChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "windowStateChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiSubWindow) DisconnectWindowStateChanged() {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_DisconnectWindowStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "windowStateChanged")
	}
}

func (ptr *QMdiSubWindow) WindowStateChanged(oldState core.Qt__WindowState, newState core.Qt__WindowState) {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_WindowStateChanged(ptr.Pointer(), C.longlong(oldState), C.longlong(newState))
	}
}

//export callbackQMdiSubWindow_DestroyQMdiSubWindow
func callbackQMdiSubWindow_DestroyQMdiSubWindow(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QMdiSubWindow"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMdiSubWindowFromPointer(ptr).DestroyQMdiSubWindowDefault()
	}
}

func (ptr *QMdiSubWindow) ConnectDestroyQMdiSubWindow(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QMdiSubWindow"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QMdiSubWindow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QMdiSubWindow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMdiSubWindow) DisconnectDestroyQMdiSubWindow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QMdiSubWindow")
	}
}

func (ptr *QMdiSubWindow) DestroyQMdiSubWindow() {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_DestroyQMdiSubWindow(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMdiSubWindow) DestroyQMdiSubWindowDefault() {
	if ptr.Pointer() != nil {
		C.QMdiSubWindow_DestroyQMdiSubWindowDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMdiSubWindow) MdiArea() *QMdiArea {
	if ptr.Pointer() != nil {
		tmpValue := NewQMdiAreaFromPointer(C.QMdiSubWindow_MdiArea(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMdiSubWindow) SystemMenu() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QMdiSubWindow_SystemMenu(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMdiSubWindow) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QMdiSubWindow_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMdiSubWindow) IsShaded() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMdiSubWindow_IsShaded(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMdiSubWindow) TestOption(option QMdiSubWindow__SubWindowOption) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMdiSubWindow_TestOption(ptr.Pointer(), C.longlong(option))) != 0
	}
	return false
}

func (ptr *QMdiSubWindow) KeyboardPageStep() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMdiSubWindow_KeyboardPageStep(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMdiSubWindow) KeyboardSingleStep() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMdiSubWindow_KeyboardSingleStep(ptr.Pointer())))
	}
	return 0
}

type QMenu struct {
	QWidget
}

type QMenu_ITF interface {
	QWidget_ITF
	QMenu_PTR() *QMenu
}

func (ptr *QMenu) QMenu_PTR() *QMenu {
	return ptr
}

func (ptr *QMenu) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QMenu) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQMenu(ptr QMenu_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMenu_PTR().Pointer()
	}
	return nil
}

func NewQMenuFromPointer(ptr unsafe.Pointer) (n *QMenu) {
	n = new(QMenu)
	n.SetPointer(ptr)
	return
}
func (ptr *QMenu) AddAction2(icon gui.QIcon_ITF, text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QMenu_AddAction2(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) AddAction4(icon gui.QIcon_ITF, text string, receiver core.QObject_ITF, member string, shortcut gui.QKeySequence_ITF) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		tmpValue := NewQActionFromPointer(C.QMenu_AddAction4(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQObject(receiver), memberC, gui.PointerFromQKeySequence(shortcut)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) AddAction(text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QMenu_AddAction(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) AddAction3(text string, receiver core.QObject_ITF, member string, shortcut gui.QKeySequence_ITF) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		tmpValue := NewQActionFromPointer(C.QMenu_AddAction3(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQObject(receiver), memberC, gui.PointerFromQKeySequence(shortcut)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) AddMenu(menu QMenu_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_AddMenu(ptr.Pointer(), PointerFromQMenu(menu)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) AddSection2(icon gui.QIcon_ITF, text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QMenu_AddSection2(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) AddSection(text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QMenu_AddSection(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) AddSeparator() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_AddSeparator(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) Exec() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_Exec(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func QMenu_Exec3(actions []*QAction, pos core.QPoint_ITF, at QAction_ITF, parent QWidget_ITF) *QAction {
	tmpValue := NewQActionFromPointer(C.QMenu_QMenu_Exec3(func() unsafe.Pointer {
		tmpList := NewQMenuFromPointer(NewQMenuFromPointer(nil).__exec_actions_newList3())
		for _, v := range actions {
			tmpList.__exec_actions_setList3(v)
		}
		return tmpList.Pointer()
	}(), core.PointerFromQPoint(pos), PointerFromQAction(at), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QMenu) Exec3(actions []*QAction, pos core.QPoint_ITF, at QAction_ITF, parent QWidget_ITF) *QAction {
	tmpValue := NewQActionFromPointer(C.QMenu_QMenu_Exec3(func() unsafe.Pointer {
		tmpList := NewQMenuFromPointer(NewQMenuFromPointer(nil).__exec_actions_newList3())
		for _, v := range actions {
			tmpList.__exec_actions_setList3(v)
		}
		return tmpList.Pointer()
	}(), core.PointerFromQPoint(pos), PointerFromQAction(at), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QMenu) Exec2(p core.QPoint_ITF, action QAction_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_Exec2(ptr.Pointer(), core.PointerFromQPoint(p), PointerFromQAction(action)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) InsertMenu(before QAction_ITF, menu QMenu_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_InsertMenu(ptr.Pointer(), PointerFromQAction(before), PointerFromQMenu(menu)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) InsertSection2(before QAction_ITF, icon gui.QIcon_ITF, text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QMenu_InsertSection2(ptr.Pointer(), PointerFromQAction(before), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) InsertSection(before QAction_ITF, text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QMenu_InsertSection(ptr.Pointer(), PointerFromQAction(before), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) InsertSeparator(before QAction_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_InsertSeparator(ptr.Pointer(), PointerFromQAction(before)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) AddMenu3(icon gui.QIcon_ITF, title string) *QMenu {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		tmpValue := NewQMenuFromPointer(C.QMenu_AddMenu3(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) AddMenu2(title string) *QMenu {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		tmpValue := NewQMenuFromPointer(C.QMenu_AddMenu2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQMenu(parent QWidget_ITF) *QMenu {
	tmpValue := NewQMenuFromPointer(C.QMenu_NewQMenu(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQMenu2(title string, parent QWidget_ITF) *QMenu {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	tmpValue := NewQMenuFromPointer(C.QMenu_NewQMenu2(C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQMenu_AboutToHide
func callbackQMenu_AboutToHide(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "aboutToHide"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QMenu) ConnectAboutToHide(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "aboutToHide") {
			C.QMenu_ConnectAboutToHide(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "aboutToHide"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "aboutToHide", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "aboutToHide", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMenu) DisconnectAboutToHide() {
	if ptr.Pointer() != nil {
		C.QMenu_DisconnectAboutToHide(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "aboutToHide")
	}
}

func (ptr *QMenu) AboutToHide() {
	if ptr.Pointer() != nil {
		C.QMenu_AboutToHide(ptr.Pointer())
	}
}

//export callbackQMenu_AboutToShow
func callbackQMenu_AboutToShow(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "aboutToShow"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QMenu) ConnectAboutToShow(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "aboutToShow") {
			C.QMenu_ConnectAboutToShow(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "aboutToShow"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "aboutToShow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "aboutToShow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMenu) DisconnectAboutToShow() {
	if ptr.Pointer() != nil {
		C.QMenu_DisconnectAboutToShow(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "aboutToShow")
	}
}

func (ptr *QMenu) AboutToShow() {
	if ptr.Pointer() != nil {
		C.QMenu_AboutToShow(ptr.Pointer())
	}
}

func (ptr *QMenu) Clear() {
	if ptr.Pointer() != nil {
		C.QMenu_Clear(ptr.Pointer())
	}
}

func (ptr *QMenu) HideTearOffMenu() {
	if ptr.Pointer() != nil {
		C.QMenu_HideTearOffMenu(ptr.Pointer())
	}
}

//export callbackQMenu_Hovered
func callbackQMenu_Hovered(ptr unsafe.Pointer, action unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hovered"); signal != nil {
		(*(*func(*QAction))(signal))(NewQActionFromPointer(action))
	}

}

func (ptr *QMenu) ConnectHovered(f func(action *QAction)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "hovered") {
			C.QMenu_ConnectHovered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "hovered"); signal != nil {
			f := func(action *QAction) {
				(*(*func(*QAction))(signal))(action)
				f(action)
			}
			qt.ConnectSignal(ptr.Pointer(), "hovered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hovered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMenu) DisconnectHovered() {
	if ptr.Pointer() != nil {
		C.QMenu_DisconnectHovered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "hovered")
	}
}

func (ptr *QMenu) Hovered(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenu_Hovered(ptr.Pointer(), PointerFromQAction(action))
	}
}

func (ptr *QMenu) Popup(p core.QPoint_ITF, atAction QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenu_Popup(ptr.Pointer(), core.PointerFromQPoint(p), PointerFromQAction(atAction))
	}
}

func (ptr *QMenu) SetActiveAction(act QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenu_SetActiveAction(ptr.Pointer(), PointerFromQAction(act))
	}
}

func (ptr *QMenu) SetAsDockMenu() {
	if ptr.Pointer() != nil {
		C.QMenu_SetAsDockMenu(ptr.Pointer())
	}
}

func (ptr *QMenu) SetDefaultAction(act QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenu_SetDefaultAction(ptr.Pointer(), PointerFromQAction(act))
	}
}

func (ptr *QMenu) SetIcon(icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QMenu_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QMenu) SetSeparatorsCollapsible(collapse bool) {
	if ptr.Pointer() != nil {
		C.QMenu_SetSeparatorsCollapsible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(collapse))))
	}
}

func (ptr *QMenu) SetTearOffEnabled(vbo bool) {
	if ptr.Pointer() != nil {
		C.QMenu_SetTearOffEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QMenu) SetTitle(title string) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		C.QMenu_SetTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
	}
}

func (ptr *QMenu) SetToolTipsVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QMenu_SetToolTipsVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QMenu) ShowTearOffMenu2() {
	if ptr.Pointer() != nil {
		C.QMenu_ShowTearOffMenu2(ptr.Pointer())
	}
}

func (ptr *QMenu) ShowTearOffMenu(pos core.QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QMenu_ShowTearOffMenu(ptr.Pointer(), core.PointerFromQPoint(pos))
	}
}

//export callbackQMenu_Triggered
func callbackQMenu_Triggered(ptr unsafe.Pointer, action unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "triggered"); signal != nil {
		(*(*func(*QAction))(signal))(NewQActionFromPointer(action))
	}

}

func (ptr *QMenu) ConnectTriggered(f func(action *QAction)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "triggered") {
			C.QMenu_ConnectTriggered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "triggered"); signal != nil {
			f := func(action *QAction) {
				(*(*func(*QAction))(signal))(action)
				f(action)
			}
			qt.ConnectSignal(ptr.Pointer(), "triggered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "triggered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMenu) DisconnectTriggered() {
	if ptr.Pointer() != nil {
		C.QMenu_DisconnectTriggered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "triggered")
	}
}

func (ptr *QMenu) Triggered(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenu_Triggered(ptr.Pointer(), PointerFromQAction(action))
	}
}

//export callbackQMenu_DestroyQMenu
func callbackQMenu_DestroyQMenu(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QMenu"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMenuFromPointer(ptr).DestroyQMenuDefault()
	}
}

func (ptr *QMenu) ConnectDestroyQMenu(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QMenu"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QMenu", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QMenu", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMenu) DisconnectDestroyQMenu() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QMenu")
	}
}

func (ptr *QMenu) DestroyQMenu() {
	if ptr.Pointer() != nil {
		C.QMenu_DestroyQMenu(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMenu) DestroyQMenuDefault() {
	if ptr.Pointer() != nil {
		C.QMenu_DestroyQMenuDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMenu) ActionAt(pt core.QPoint_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_ActionAt(ptr.Pointer(), core.PointerFromQPoint(pt)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) ActiveAction() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_ActiveAction(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) DefaultAction() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_DefaultAction(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) MenuAction() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu_MenuAction(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QMenu_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) ActionGeometry(act QAction_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QMenu_ActionGeometry(ptr.Pointer(), PointerFromQAction(act)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) Title() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMenu_Title(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMenu) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMenu_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMenu) IsTearOffEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMenu_IsTearOffEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMenu) IsTearOffMenuVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMenu_IsTearOffMenuVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMenu) SeparatorsCollapsible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMenu_SeparatorsCollapsible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMenu) ToolTipsVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMenu_ToolTipsVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMenu) ColumnCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QMenu_ColumnCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QMenu) InitStyleOption(option QStyleOptionMenuItem_ITF, action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenu_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionMenuItem(option), PointerFromQAction(action))
	}
}

func (ptr *QMenu) __exec_actions_atList3(i int) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenu___exec_actions_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenu) __exec_actions_setList3(i QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenu___exec_actions_setList3(ptr.Pointer(), PointerFromQAction(i))
	}
}

func (ptr *QMenu) __exec_actions_newList3() unsafe.Pointer {
	return C.QMenu___exec_actions_newList3(ptr.Pointer())
}

type QMenuBar struct {
	QWidget
}

type QMenuBar_ITF interface {
	QWidget_ITF
	QMenuBar_PTR() *QMenuBar
}

func (ptr *QMenuBar) QMenuBar_PTR() *QMenuBar {
	return ptr
}

func (ptr *QMenuBar) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QMenuBar) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQMenuBar(ptr QMenuBar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMenuBar_PTR().Pointer()
	}
	return nil
}

func NewQMenuBarFromPointer(ptr unsafe.Pointer) (n *QMenuBar) {
	n = new(QMenuBar)
	n.SetPointer(ptr)
	return
}
func (ptr *QMenuBar) AddAction(text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QMenuBar_AddAction(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) AddAction2(text string, receiver core.QObject_ITF, member string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		tmpValue := NewQActionFromPointer(C.QMenuBar_AddAction2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQObject(receiver), memberC))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) AddMenu(menu QMenu_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenuBar_AddMenu(ptr.Pointer(), PointerFromQMenu(menu)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) AddSeparator() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenuBar_AddSeparator(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) InsertMenu(before QAction_ITF, menu QMenu_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenuBar_InsertMenu(ptr.Pointer(), PointerFromQAction(before), PointerFromQMenu(menu)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) InsertSeparator(before QAction_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenuBar_InsertSeparator(ptr.Pointer(), PointerFromQAction(before)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) AddMenu3(icon gui.QIcon_ITF, title string) *QMenu {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		tmpValue := NewQMenuFromPointer(C.QMenuBar_AddMenu3(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) AddMenu2(title string) *QMenu {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		tmpValue := NewQMenuFromPointer(C.QMenuBar_AddMenu2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQMenuBar(parent QWidget_ITF) *QMenuBar {
	tmpValue := NewQMenuBarFromPointer(C.QMenuBar_NewQMenuBar(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QMenuBar) Clear() {
	if ptr.Pointer() != nil {
		C.QMenuBar_Clear(ptr.Pointer())
	}
}

//export callbackQMenuBar_Hovered
func callbackQMenuBar_Hovered(ptr unsafe.Pointer, action unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hovered"); signal != nil {
		(*(*func(*QAction))(signal))(NewQActionFromPointer(action))
	}

}

func (ptr *QMenuBar) ConnectHovered(f func(action *QAction)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "hovered") {
			C.QMenuBar_ConnectHovered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "hovered"); signal != nil {
			f := func(action *QAction) {
				(*(*func(*QAction))(signal))(action)
				f(action)
			}
			qt.ConnectSignal(ptr.Pointer(), "hovered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hovered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMenuBar) DisconnectHovered() {
	if ptr.Pointer() != nil {
		C.QMenuBar_DisconnectHovered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "hovered")
	}
}

func (ptr *QMenuBar) Hovered(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenuBar_Hovered(ptr.Pointer(), PointerFromQAction(action))
	}
}

func (ptr *QMenuBar) SetActiveAction(act QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenuBar_SetActiveAction(ptr.Pointer(), PointerFromQAction(act))
	}
}

func (ptr *QMenuBar) SetCornerWidget(widget QWidget_ITF, corner core.Qt__Corner) {
	if ptr.Pointer() != nil {
		C.QMenuBar_SetCornerWidget(ptr.Pointer(), PointerFromQWidget(widget), C.longlong(corner))
	}
}

func (ptr *QMenuBar) SetDefaultUp(vbo bool) {
	if ptr.Pointer() != nil {
		C.QMenuBar_SetDefaultUp(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QMenuBar) SetNativeMenuBar(nativeMenuBar bool) {
	if ptr.Pointer() != nil {
		C.QMenuBar_SetNativeMenuBar(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(nativeMenuBar))))
	}
}

//export callbackQMenuBar_Triggered
func callbackQMenuBar_Triggered(ptr unsafe.Pointer, action unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "triggered"); signal != nil {
		(*(*func(*QAction))(signal))(NewQActionFromPointer(action))
	}

}

func (ptr *QMenuBar) ConnectTriggered(f func(action *QAction)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "triggered") {
			C.QMenuBar_ConnectTriggered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "triggered"); signal != nil {
			f := func(action *QAction) {
				(*(*func(*QAction))(signal))(action)
				f(action)
			}
			qt.ConnectSignal(ptr.Pointer(), "triggered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "triggered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMenuBar) DisconnectTriggered() {
	if ptr.Pointer() != nil {
		C.QMenuBar_DisconnectTriggered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "triggered")
	}
}

func (ptr *QMenuBar) Triggered(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenuBar_Triggered(ptr.Pointer(), PointerFromQAction(action))
	}
}

//export callbackQMenuBar_DestroyQMenuBar
func callbackQMenuBar_DestroyQMenuBar(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QMenuBar"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMenuBarFromPointer(ptr).DestroyQMenuBarDefault()
	}
}

func (ptr *QMenuBar) ConnectDestroyQMenuBar(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QMenuBar"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QMenuBar", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QMenuBar", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMenuBar) DisconnectDestroyQMenuBar() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QMenuBar")
	}
}

func (ptr *QMenuBar) DestroyQMenuBar() {
	if ptr.Pointer() != nil {
		C.QMenuBar_DestroyQMenuBar(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMenuBar) DestroyQMenuBarDefault() {
	if ptr.Pointer() != nil {
		C.QMenuBar_DestroyQMenuBarDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMenuBar) ActionAt(pt core.QPoint_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenuBar_ActionAt(ptr.Pointer(), core.PointerFromQPoint(pt)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) ActiveAction() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QMenuBar_ActiveAction(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) ActionGeometry(act QAction_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QMenuBar_ActionGeometry(ptr.Pointer(), PointerFromQAction(act)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) CornerWidget(corner core.Qt__Corner) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QMenuBar_CornerWidget(ptr.Pointer(), C.longlong(corner)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMenuBar) IsDefaultUp() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMenuBar_IsDefaultUp(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMenuBar) IsNativeMenuBar() bool {
	if ptr.Pointer() != nil {
		return int8(C.QMenuBar_IsNativeMenuBar(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QMenuBar) InitStyleOption(option QStyleOptionMenuItem_ITF, action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QMenuBar_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionMenuItem(option), PointerFromQAction(action))
	}
}

type QMessageBox struct {
	QDialog
}

type QMessageBox_ITF interface {
	QDialog_ITF
	QMessageBox_PTR() *QMessageBox
}

func (ptr *QMessageBox) QMessageBox_PTR() *QMessageBox {
	return ptr
}

func (ptr *QMessageBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QDialog_PTR().Pointer()
	}
	return nil
}

func (ptr *QMessageBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QDialog_PTR().SetPointer(p)
	}
}

func PointerFromQMessageBox(ptr QMessageBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMessageBox_PTR().Pointer()
	}
	return nil
}

func NewQMessageBoxFromPointer(ptr unsafe.Pointer) (n *QMessageBox) {
	n = new(QMessageBox)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QMessageBox__ButtonRole
//QMessageBox::ButtonRole
type QMessageBox__ButtonRole int64

const (
	QMessageBox__InvalidRole     QMessageBox__ButtonRole = QMessageBox__ButtonRole(-1)
	QMessageBox__AcceptRole      QMessageBox__ButtonRole = QMessageBox__ButtonRole(0)
	QMessageBox__RejectRole      QMessageBox__ButtonRole = QMessageBox__ButtonRole(1)
	QMessageBox__DestructiveRole QMessageBox__ButtonRole = QMessageBox__ButtonRole(2)
	QMessageBox__ActionRole      QMessageBox__ButtonRole = QMessageBox__ButtonRole(3)
	QMessageBox__HelpRole        QMessageBox__ButtonRole = QMessageBox__ButtonRole(4)
	QMessageBox__YesRole         QMessageBox__ButtonRole = QMessageBox__ButtonRole(5)
	QMessageBox__NoRole          QMessageBox__ButtonRole = QMessageBox__ButtonRole(6)
	QMessageBox__ResetRole       QMessageBox__ButtonRole = QMessageBox__ButtonRole(7)
	QMessageBox__ApplyRole       QMessageBox__ButtonRole = QMessageBox__ButtonRole(8)
	QMessageBox__NRoles          QMessageBox__ButtonRole = QMessageBox__ButtonRole(9)
)

//go:generate stringer -type=QMessageBox__Icon
//QMessageBox::Icon
type QMessageBox__Icon int64

const (
	QMessageBox__NoIcon      QMessageBox__Icon = QMessageBox__Icon(0)
	QMessageBox__Information QMessageBox__Icon = QMessageBox__Icon(1)
	QMessageBox__Warning     QMessageBox__Icon = QMessageBox__Icon(2)
	QMessageBox__Critical    QMessageBox__Icon = QMessageBox__Icon(3)
	QMessageBox__Question    QMessageBox__Icon = QMessageBox__Icon(4)
)

//go:generate stringer -type=QMessageBox__StandardButton
//QMessageBox::StandardButton
type QMessageBox__StandardButton int64

var (
	QMessageBox__NoButton        QMessageBox__StandardButton = QMessageBox__StandardButton(0x00000000)
	QMessageBox__Ok              QMessageBox__StandardButton = QMessageBox__StandardButton(0x00000400)
	QMessageBox__Save            QMessageBox__StandardButton = QMessageBox__StandardButton(0x00000800)
	QMessageBox__SaveAll         QMessageBox__StandardButton = QMessageBox__StandardButton(0x00001000)
	QMessageBox__Open            QMessageBox__StandardButton = QMessageBox__StandardButton(0x00002000)
	QMessageBox__Yes             QMessageBox__StandardButton = QMessageBox__StandardButton(0x00004000)
	QMessageBox__YesToAll        QMessageBox__StandardButton = QMessageBox__StandardButton(0x00008000)
	QMessageBox__No              QMessageBox__StandardButton = QMessageBox__StandardButton(0x00010000)
	QMessageBox__NoToAll         QMessageBox__StandardButton = QMessageBox__StandardButton(0x00020000)
	QMessageBox__Abort           QMessageBox__StandardButton = QMessageBox__StandardButton(0x00040000)
	QMessageBox__Retry           QMessageBox__StandardButton = QMessageBox__StandardButton(0x00080000)
	QMessageBox__Ignore          QMessageBox__StandardButton = QMessageBox__StandardButton(0x00100000)
	QMessageBox__Close           QMessageBox__StandardButton = QMessageBox__StandardButton(0x00200000)
	QMessageBox__Cancel          QMessageBox__StandardButton = QMessageBox__StandardButton(0x00400000)
	QMessageBox__Discard         QMessageBox__StandardButton = QMessageBox__StandardButton(0x00800000)
	QMessageBox__Help            QMessageBox__StandardButton = QMessageBox__StandardButton(0x01000000)
	QMessageBox__Apply           QMessageBox__StandardButton = QMessageBox__StandardButton(0x02000000)
	QMessageBox__Reset           QMessageBox__StandardButton = QMessageBox__StandardButton(0x04000000)
	QMessageBox__RestoreDefaults QMessageBox__StandardButton = QMessageBox__StandardButton(0x08000000)
	QMessageBox__FirstButton     QMessageBox__StandardButton = QMessageBox__StandardButton(QMessageBox__Ok)
	QMessageBox__LastButton      QMessageBox__StandardButton = QMessageBox__StandardButton(QMessageBox__RestoreDefaults)
	QMessageBox__YesAll          QMessageBox__StandardButton = QMessageBox__StandardButton(QMessageBox__YesToAll)
	QMessageBox__NoAll           QMessageBox__StandardButton = QMessageBox__StandardButton(QMessageBox__NoToAll)
	QMessageBox__Default         QMessageBox__StandardButton = QMessageBox__StandardButton(0x00000100)
	QMessageBox__Escape          QMessageBox__StandardButton = QMessageBox__StandardButton(0x00000200)
	QMessageBox__FlagMask        QMessageBox__StandardButton = QMessageBox__StandardButton(0x00000300)
	QMessageBox__ButtonMask      QMessageBox__StandardButton = QMessageBox__StandardButton(C.QMessageBox_ButtonMask_Type())
)

func NewQMessageBox2(icon QMessageBox__Icon, title string, text string, buttons QMessageBox__StandardButton, parent QWidget_ITF, ff core.Qt__WindowType) *QMessageBox {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQMessageBoxFromPointer(C.QMessageBox_NewQMessageBox2(C.longlong(icon), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQMessageBox(parent QWidget_ITF) *QMessageBox {
	tmpValue := NewQMessageBoxFromPointer(C.QMessageBox_NewQMessageBox(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QMessageBox_Critical(parent QWidget_ITF, title string, text string, buttons QMessageBox__StandardButton, defaultButton QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Critical(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), C.longlong(defaultButton)))
}

func (ptr *QMessageBox) Critical(parent QWidget_ITF, title string, text string, buttons QMessageBox__StandardButton, defaultButton QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Critical(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), C.longlong(defaultButton)))
}

func QMessageBox_Information4(parent QWidget_ITF, title string, text string, button0 QMessageBox__StandardButton, button1 QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Information4(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(button0), C.longlong(button1)))
}

func (ptr *QMessageBox) Information4(parent QWidget_ITF, title string, text string, button0 QMessageBox__StandardButton, button1 QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Information4(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(button0), C.longlong(button1)))
}

func QMessageBox_Information(parent QWidget_ITF, title string, text string, buttons QMessageBox__StandardButton, defaultButton QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Information(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), C.longlong(defaultButton)))
}

func (ptr *QMessageBox) Information(parent QWidget_ITF, title string, text string, buttons QMessageBox__StandardButton, defaultButton QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Information(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), C.longlong(defaultButton)))
}

func QMessageBox_Question(parent QWidget_ITF, title string, text string, buttons QMessageBox__StandardButton, defaultButton QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Question(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), C.longlong(defaultButton)))
}

func (ptr *QMessageBox) Question(parent QWidget_ITF, title string, text string, buttons QMessageBox__StandardButton, defaultButton QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Question(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), C.longlong(defaultButton)))
}

func QMessageBox_Warning(parent QWidget_ITF, title string, text string, buttons QMessageBox__StandardButton, defaultButton QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Warning(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), C.longlong(defaultButton)))
}

func (ptr *QMessageBox) Warning(parent QWidget_ITF, title string, text string, buttons QMessageBox__StandardButton, defaultButton QMessageBox__StandardButton) QMessageBox__StandardButton {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return QMessageBox__StandardButton(C.QMessageBox_QMessageBox_Warning(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(buttons), C.longlong(defaultButton)))
}

func (ptr *QMessageBox) AddButton3(button QMessageBox__StandardButton) *QPushButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQPushButtonFromPointer(C.QMessageBox_AddButton3(ptr.Pointer(), C.longlong(button)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMessageBox) AddButton2(text string, role QMessageBox__ButtonRole) *QPushButton {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQPushButtonFromPointer(C.QMessageBox_AddButton2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(role)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func QMessageBox_Critical4(parent QWidget_ITF, title string, text string, button0 QMessageBox__StandardButton, button1 QMessageBox__StandardButton) int {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return int(int32(C.QMessageBox_QMessageBox_Critical4(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(button0), C.longlong(button1))))
}

func (ptr *QMessageBox) Critical4(parent QWidget_ITF, title string, text string, button0 QMessageBox__StandardButton, button1 QMessageBox__StandardButton) int {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return int(int32(C.QMessageBox_QMessageBox_Critical4(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(button0), C.longlong(button1))))
}

func QMessageBox_Question4(parent QWidget_ITF, title string, text string, button0 QMessageBox__StandardButton, button1 QMessageBox__StandardButton) int {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return int(int32(C.QMessageBox_QMessageBox_Question4(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(button0), C.longlong(button1))))
}

func (ptr *QMessageBox) Question4(parent QWidget_ITF, title string, text string, button0 QMessageBox__StandardButton, button1 QMessageBox__StandardButton) int {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return int(int32(C.QMessageBox_QMessageBox_Question4(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(button0), C.longlong(button1))))
}

func QMessageBox_Warning4(parent QWidget_ITF, title string, text string, button0 QMessageBox__StandardButton, button1 QMessageBox__StandardButton) int {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return int(int32(C.QMessageBox_QMessageBox_Warning4(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(button0), C.longlong(button1))))
}

func (ptr *QMessageBox) Warning4(parent QWidget_ITF, title string, text string, button0 QMessageBox__StandardButton, button1 QMessageBox__StandardButton) int {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return int(int32(C.QMessageBox_QMessageBox_Warning4(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(button0), C.longlong(button1))))
}

func QMessageBox_About(parent QWidget_ITF, title string, text string) {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QMessageBox_QMessageBox_About(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
}

func (ptr *QMessageBox) About(parent QWidget_ITF, title string, text string) {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QMessageBox_QMessageBox_About(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
}

func QMessageBox_AboutQt(parent QWidget_ITF, title string) {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	C.QMessageBox_QMessageBox_AboutQt(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
}

func (ptr *QMessageBox) AboutQt(parent QWidget_ITF, title string) {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	C.QMessageBox_QMessageBox_AboutQt(PointerFromQWidget(parent), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
}

func (ptr *QMessageBox) AddButton(button QAbstractButton_ITF, role QMessageBox__ButtonRole) {
	if ptr.Pointer() != nil {
		C.QMessageBox_AddButton(ptr.Pointer(), PointerFromQAbstractButton(button), C.longlong(role))
	}
}

//export callbackQMessageBox_ButtonClicked
func callbackQMessageBox_ButtonClicked(ptr unsafe.Pointer, button unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "buttonClicked"); signal != nil {
		(*(*func(*QAbstractButton))(signal))(NewQAbstractButtonFromPointer(button))
	}

}

func (ptr *QMessageBox) ConnectButtonClicked(f func(button *QAbstractButton)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "buttonClicked") {
			C.QMessageBox_ConnectButtonClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "buttonClicked"); signal != nil {
			f := func(button *QAbstractButton) {
				(*(*func(*QAbstractButton))(signal))(button)
				f(button)
			}
			qt.ConnectSignal(ptr.Pointer(), "buttonClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "buttonClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMessageBox) DisconnectButtonClicked() {
	if ptr.Pointer() != nil {
		C.QMessageBox_DisconnectButtonClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "buttonClicked")
	}
}

func (ptr *QMessageBox) ButtonClicked(button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QMessageBox_ButtonClicked(ptr.Pointer(), PointerFromQAbstractButton(button))
	}
}

func (ptr *QMessageBox) Open(receiver core.QObject_ITF, member string) {
	if ptr.Pointer() != nil {
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		C.QMessageBox_Open(ptr.Pointer(), core.PointerFromQObject(receiver), memberC)
	}
}

func (ptr *QMessageBox) RemoveButton(button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QMessageBox_RemoveButton(ptr.Pointer(), PointerFromQAbstractButton(button))
	}
}

func (ptr *QMessageBox) SetCheckBox(cb QCheckBox_ITF) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetCheckBox(ptr.Pointer(), PointerFromQCheckBox(cb))
	}
}

func (ptr *QMessageBox) SetDefaultButton2(button QMessageBox__StandardButton) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetDefaultButton2(ptr.Pointer(), C.longlong(button))
	}
}

func (ptr *QMessageBox) SetDefaultButton(button QPushButton_ITF) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetDefaultButton(ptr.Pointer(), PointerFromQPushButton(button))
	}
}

func (ptr *QMessageBox) SetDetailedText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QMessageBox_SetDetailedText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QMessageBox) SetEscapeButton(button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetEscapeButton(ptr.Pointer(), PointerFromQAbstractButton(button))
	}
}

func (ptr *QMessageBox) SetEscapeButton2(button QMessageBox__StandardButton) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetEscapeButton2(ptr.Pointer(), C.longlong(button))
	}
}

func (ptr *QMessageBox) SetIcon(vqm QMessageBox__Icon) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetIcon(ptr.Pointer(), C.longlong(vqm))
	}
}

func (ptr *QMessageBox) SetIconPixmap(pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetIconPixmap(ptr.Pointer(), gui.PointerFromQPixmap(pixmap))
	}
}

func (ptr *QMessageBox) SetInformativeText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QMessageBox_SetInformativeText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QMessageBox) SetStandardButtons(buttons QMessageBox__StandardButton) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetStandardButtons(ptr.Pointer(), C.longlong(buttons))
	}
}

func (ptr *QMessageBox) SetText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QMessageBox_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QMessageBox) SetTextFormat(format core.Qt__TextFormat) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetTextFormat(ptr.Pointer(), C.longlong(format))
	}
}

func (ptr *QMessageBox) SetTextInteractionFlags(flags core.Qt__TextInteractionFlag) {
	if ptr.Pointer() != nil {
		C.QMessageBox_SetTextInteractionFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QMessageBox) SetWindowTitle(title string) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		C.QMessageBox_SetWindowTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
	}
}

//export callbackQMessageBox_DestroyQMessageBox
func callbackQMessageBox_DestroyQMessageBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QMessageBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMessageBoxFromPointer(ptr).DestroyQMessageBoxDefault()
	}
}

func (ptr *QMessageBox) ConnectDestroyQMessageBox(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QMessageBox"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QMessageBox", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QMessageBox", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMessageBox) DisconnectDestroyQMessageBox() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QMessageBox")
	}
}

func (ptr *QMessageBox) DestroyQMessageBox() {
	if ptr.Pointer() != nil {
		C.QMessageBox_DestroyQMessageBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMessageBox) DestroyQMessageBoxDefault() {
	if ptr.Pointer() != nil {
		C.QMessageBox_DestroyQMessageBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMessageBox) Button(which QMessageBox__StandardButton) *QAbstractButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractButtonFromPointer(C.QMessageBox_Button(ptr.Pointer(), C.longlong(which)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMessageBox) ClickedButton() *QAbstractButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractButtonFromPointer(C.QMessageBox_ClickedButton(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMessageBox) EscapeButton() *QAbstractButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractButtonFromPointer(C.QMessageBox_EscapeButton(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMessageBox) CheckBox() *QCheckBox {
	if ptr.Pointer() != nil {
		tmpValue := NewQCheckBoxFromPointer(C.QMessageBox_CheckBox(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMessageBox) Buttons() []*QAbstractButton {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QAbstractButton {
			out := make([]*QAbstractButton, int(l.len))
			tmpList := NewQMessageBoxFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__buttons_atList(i)
			}
			return out
		}(C.QMessageBox_Buttons(ptr.Pointer()))
	}
	return make([]*QAbstractButton, 0)
}

func (ptr *QMessageBox) ButtonRole(button QAbstractButton_ITF) QMessageBox__ButtonRole {
	if ptr.Pointer() != nil {
		return QMessageBox__ButtonRole(C.QMessageBox_ButtonRole(ptr.Pointer(), PointerFromQAbstractButton(button)))
	}
	return 0
}

func (ptr *QMessageBox) Icon() QMessageBox__Icon {
	if ptr.Pointer() != nil {
		return QMessageBox__Icon(C.QMessageBox_Icon(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMessageBox) StandardButton(button QAbstractButton_ITF) QMessageBox__StandardButton {
	if ptr.Pointer() != nil {
		return QMessageBox__StandardButton(C.QMessageBox_StandardButton(ptr.Pointer(), PointerFromQAbstractButton(button)))
	}
	return 0
}

func (ptr *QMessageBox) StandardButtons() QMessageBox__StandardButton {
	if ptr.Pointer() != nil {
		return QMessageBox__StandardButton(C.QMessageBox_StandardButtons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMessageBox) IconPixmap() *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QMessageBox_IconPixmap(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func (ptr *QMessageBox) DefaultButton() *QPushButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQPushButtonFromPointer(C.QMessageBox_DefaultButton(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMessageBox) DetailedText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMessageBox_DetailedText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMessageBox) InformativeText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMessageBox_InformativeText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMessageBox) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QMessageBox_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QMessageBox) TextFormat() core.Qt__TextFormat {
	if ptr.Pointer() != nil {
		return core.Qt__TextFormat(C.QMessageBox_TextFormat(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMessageBox) TextInteractionFlags() core.Qt__TextInteractionFlag {
	if ptr.Pointer() != nil {
		return core.Qt__TextInteractionFlag(C.QMessageBox_TextInteractionFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMessageBox) __buttons_atList(i int) *QAbstractButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractButtonFromPointer(C.QMessageBox___buttons_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMessageBox) __buttons_setList(i QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QMessageBox___buttons_setList(ptr.Pointer(), PointerFromQAbstractButton(i))
	}
}

func (ptr *QMessageBox) __buttons_newList() unsafe.Pointer {
	return C.QMessageBox___buttons_newList(ptr.Pointer())
}

type QMouseEventTransition struct {
	core.QEventTransition
}

type QMouseEventTransition_ITF interface {
	core.QEventTransition_ITF
	QMouseEventTransition_PTR() *QMouseEventTransition
}

func (ptr *QMouseEventTransition) QMouseEventTransition_PTR() *QMouseEventTransition {
	return ptr
}

func (ptr *QMouseEventTransition) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QEventTransition_PTR().Pointer()
	}
	return nil
}

func (ptr *QMouseEventTransition) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QEventTransition_PTR().SetPointer(p)
	}
}

func PointerFromQMouseEventTransition(ptr QMouseEventTransition_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMouseEventTransition_PTR().Pointer()
	}
	return nil
}

func NewQMouseEventTransitionFromPointer(ptr unsafe.Pointer) (n *QMouseEventTransition) {
	n = new(QMouseEventTransition)
	n.SetPointer(ptr)
	return
}
func NewQMouseEventTransition2(object core.QObject_ITF, ty core.QEvent__Type, button core.Qt__MouseButton, sourceState core.QState_ITF) *QMouseEventTransition {
	tmpValue := NewQMouseEventTransitionFromPointer(C.QMouseEventTransition_NewQMouseEventTransition2(core.PointerFromQObject(object), C.longlong(ty), C.longlong(button), core.PointerFromQState(sourceState)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQMouseEventTransition(sourceState core.QState_ITF) *QMouseEventTransition {
	tmpValue := NewQMouseEventTransitionFromPointer(C.QMouseEventTransition_NewQMouseEventTransition(core.PointerFromQState(sourceState)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QMouseEventTransition_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QMouseEventTransition_QMouseEventTransition_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QMouseEventTransition) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QMouseEventTransition_QMouseEventTransition_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQMouseEventTransition_EventTest
func callbackQMouseEventTransition_EventTest(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventTest"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQMouseEventTransitionFromPointer(ptr).EventTestDefault(core.NewQEventFromPointer(event)))))
}

func (ptr *QMouseEventTransition) EventTestDefault(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMouseEventTransition_EventTestDefault(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQMouseEventTransition_OnTransition
func callbackQMouseEventTransition_OnTransition(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "onTransition"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQMouseEventTransitionFromPointer(ptr).OnTransitionDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QMouseEventTransition) OnTransitionDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_OnTransitionDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QMouseEventTransition) SetButton(button core.Qt__MouseButton) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_SetButton(ptr.Pointer(), C.longlong(button))
	}
}

func (ptr *QMouseEventTransition) SetHitTestPath(path gui.QPainterPath_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_SetHitTestPath(ptr.Pointer(), gui.PointerFromQPainterPath(path))
	}
}

func (ptr *QMouseEventTransition) SetModifierMask(modifierMask core.Qt__KeyboardModifier) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_SetModifierMask(ptr.Pointer(), C.longlong(modifierMask))
	}
}

//export callbackQMouseEventTransition_DestroyQMouseEventTransition
func callbackQMouseEventTransition_DestroyQMouseEventTransition(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QMouseEventTransition"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMouseEventTransitionFromPointer(ptr).DestroyQMouseEventTransitionDefault()
	}
}

func (ptr *QMouseEventTransition) ConnectDestroyQMouseEventTransition(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QMouseEventTransition"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QMouseEventTransition", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QMouseEventTransition", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QMouseEventTransition) DisconnectDestroyQMouseEventTransition() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QMouseEventTransition")
	}
}

func (ptr *QMouseEventTransition) DestroyQMouseEventTransition() {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_DestroyQMouseEventTransition(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMouseEventTransition) DestroyQMouseEventTransitionDefault() {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_DestroyQMouseEventTransitionDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QMouseEventTransition) HitTestPath() *gui.QPainterPath {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPainterPathFromPointer(C.QMouseEventTransition_HitTestPath(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
		return tmpValue
	}
	return nil
}

func (ptr *QMouseEventTransition) ModifierMask() core.Qt__KeyboardModifier {
	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QMouseEventTransition_ModifierMask(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMouseEventTransition) Button() core.Qt__MouseButton {
	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QMouseEventTransition_Button(ptr.Pointer()))
	}
	return 0
}

//export callbackQMouseEventTransition_MetaObject
func callbackQMouseEventTransition_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQMouseEventTransitionFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QMouseEventTransition) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QMouseEventTransition_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMouseEventTransition) __setTargetStates_targets_atList(i int) *core.QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractStateFromPointer(C.QMouseEventTransition___setTargetStates_targets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMouseEventTransition) __setTargetStates_targets_setList(i core.QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition___setTargetStates_targets_setList(ptr.Pointer(), core.PointerFromQAbstractState(i))
	}
}

func (ptr *QMouseEventTransition) __setTargetStates_targets_newList() unsafe.Pointer {
	return C.QMouseEventTransition___setTargetStates_targets_newList(ptr.Pointer())
}

func (ptr *QMouseEventTransition) __animations_atList(i int) *core.QAbstractAnimation {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractAnimationFromPointer(C.QMouseEventTransition___animations_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMouseEventTransition) __animations_setList(i core.QAbstractAnimation_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition___animations_setList(ptr.Pointer(), core.PointerFromQAbstractAnimation(i))
	}
}

func (ptr *QMouseEventTransition) __animations_newList() unsafe.Pointer {
	return C.QMouseEventTransition___animations_newList(ptr.Pointer())
}

func (ptr *QMouseEventTransition) __targetStates_atList(i int) *core.QAbstractState {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQAbstractStateFromPointer(C.QMouseEventTransition___targetStates_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMouseEventTransition) __targetStates_setList(i core.QAbstractState_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition___targetStates_setList(ptr.Pointer(), core.PointerFromQAbstractState(i))
	}
}

func (ptr *QMouseEventTransition) __targetStates_newList() unsafe.Pointer {
	return C.QMouseEventTransition___targetStates_newList(ptr.Pointer())
}

func (ptr *QMouseEventTransition) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QMouseEventTransition___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QMouseEventTransition) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QMouseEventTransition) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QMouseEventTransition___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QMouseEventTransition) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QMouseEventTransition___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMouseEventTransition) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QMouseEventTransition) __findChildren_newList2() unsafe.Pointer {
	return C.QMouseEventTransition___findChildren_newList2(ptr.Pointer())
}

func (ptr *QMouseEventTransition) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QMouseEventTransition___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMouseEventTransition) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QMouseEventTransition) __findChildren_newList3() unsafe.Pointer {
	return C.QMouseEventTransition___findChildren_newList3(ptr.Pointer())
}

func (ptr *QMouseEventTransition) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QMouseEventTransition___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMouseEventTransition) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QMouseEventTransition) __findChildren_newList() unsafe.Pointer {
	return C.QMouseEventTransition___findChildren_newList(ptr.Pointer())
}

func (ptr *QMouseEventTransition) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QMouseEventTransition___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QMouseEventTransition) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QMouseEventTransition) __children_newList() unsafe.Pointer {
	return C.QMouseEventTransition___children_newList(ptr.Pointer())
}

//export callbackQMouseEventTransition_Event
func callbackQMouseEventTransition_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQMouseEventTransitionFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QMouseEventTransition) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMouseEventTransition_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQMouseEventTransition_TargetStateChanged
func callbackQMouseEventTransition_TargetStateChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "targetStateChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQMouseEventTransition_TargetStatesChanged
func callbackQMouseEventTransition_TargetStatesChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "targetStatesChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQMouseEventTransition_Triggered
func callbackQMouseEventTransition_Triggered(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "triggered"); signal != nil {
		(*(*func())(signal))()
	}

}

//export callbackQMouseEventTransition_EventFilter
func callbackQMouseEventTransition_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQMouseEventTransitionFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QMouseEventTransition) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QMouseEventTransition_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQMouseEventTransition_ChildEvent
func callbackQMouseEventTransition_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQMouseEventTransitionFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QMouseEventTransition) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQMouseEventTransition_ConnectNotify
func callbackQMouseEventTransition_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQMouseEventTransitionFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QMouseEventTransition) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQMouseEventTransition_CustomEvent
func callbackQMouseEventTransition_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQMouseEventTransitionFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QMouseEventTransition) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQMouseEventTransition_DeleteLater
func callbackQMouseEventTransition_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQMouseEventTransitionFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QMouseEventTransition) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQMouseEventTransition_Destroyed
func callbackQMouseEventTransition_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQMouseEventTransition_DisconnectNotify
func callbackQMouseEventTransition_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQMouseEventTransitionFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QMouseEventTransition) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQMouseEventTransition_ObjectNameChanged
func callbackQMouseEventTransition_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQMouseEventTransition_TimerEvent
func callbackQMouseEventTransition_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQMouseEventTransitionFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QMouseEventTransition) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QMouseEventTransition_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QOpenGLWidget struct {
	QWidget
}

type QOpenGLWidget_ITF interface {
	QWidget_ITF
	QOpenGLWidget_PTR() *QOpenGLWidget
}

func (ptr *QOpenGLWidget) QOpenGLWidget_PTR() *QOpenGLWidget {
	return ptr
}

func (ptr *QOpenGLWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QOpenGLWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQOpenGLWidget(ptr QOpenGLWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLWidget_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLWidgetFromPointer(ptr unsafe.Pointer) (n *QOpenGLWidget) {
	n = new(QOpenGLWidget)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QOpenGLWidget__UpdateBehavior
//QOpenGLWidget::UpdateBehavior
type QOpenGLWidget__UpdateBehavior int64

const (
	QOpenGLWidget__NoPartialUpdate QOpenGLWidget__UpdateBehavior = QOpenGLWidget__UpdateBehavior(0)
	QOpenGLWidget__PartialUpdate   QOpenGLWidget__UpdateBehavior = QOpenGLWidget__UpdateBehavior(1)
)

func (ptr *QOpenGLWidget) GrabFramebuffer() *gui.QImage {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQImageFromPointer(C.QOpenGLWidget_GrabFramebuffer(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
		return tmpValue
	}
	return nil
}

func NewQOpenGLWidget(parent QWidget_ITF, ff core.Qt__WindowType) *QOpenGLWidget {
	tmpValue := NewQOpenGLWidgetFromPointer(C.QOpenGLWidget_NewQOpenGLWidget(PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQOpenGLWidget_AboutToCompose
func callbackQOpenGLWidget_AboutToCompose(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "aboutToCompose"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QOpenGLWidget) ConnectAboutToCompose(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "aboutToCompose") {
			C.QOpenGLWidget_ConnectAboutToCompose(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "aboutToCompose"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "aboutToCompose", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "aboutToCompose", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QOpenGLWidget) DisconnectAboutToCompose() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_DisconnectAboutToCompose(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "aboutToCompose")
	}
}

func (ptr *QOpenGLWidget) AboutToCompose() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_AboutToCompose(ptr.Pointer())
	}
}

//export callbackQOpenGLWidget_AboutToResize
func callbackQOpenGLWidget_AboutToResize(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "aboutToResize"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QOpenGLWidget) ConnectAboutToResize(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "aboutToResize") {
			C.QOpenGLWidget_ConnectAboutToResize(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "aboutToResize"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "aboutToResize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "aboutToResize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QOpenGLWidget) DisconnectAboutToResize() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_DisconnectAboutToResize(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "aboutToResize")
	}
}

func (ptr *QOpenGLWidget) AboutToResize() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_AboutToResize(ptr.Pointer())
	}
}

func (ptr *QOpenGLWidget) DoneCurrent() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_DoneCurrent(ptr.Pointer())
	}
}

//export callbackQOpenGLWidget_FrameSwapped
func callbackQOpenGLWidget_FrameSwapped(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "frameSwapped"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QOpenGLWidget) ConnectFrameSwapped(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "frameSwapped") {
			C.QOpenGLWidget_ConnectFrameSwapped(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "frameSwapped"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "frameSwapped", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "frameSwapped", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QOpenGLWidget) DisconnectFrameSwapped() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_DisconnectFrameSwapped(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "frameSwapped")
	}
}

func (ptr *QOpenGLWidget) FrameSwapped() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_FrameSwapped(ptr.Pointer())
	}
}

//export callbackQOpenGLWidget_InitializeGL
func callbackQOpenGLWidget_InitializeGL(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "initializeGL"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQOpenGLWidgetFromPointer(ptr).InitializeGLDefault()
	}
}

func (ptr *QOpenGLWidget) ConnectInitializeGL(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "initializeGL"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "initializeGL", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "initializeGL", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QOpenGLWidget) DisconnectInitializeGL() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "initializeGL")
	}
}

func (ptr *QOpenGLWidget) InitializeGL() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_InitializeGL(ptr.Pointer())
	}
}

func (ptr *QOpenGLWidget) InitializeGLDefault() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_InitializeGLDefault(ptr.Pointer())
	}
}

func (ptr *QOpenGLWidget) MakeCurrent() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_MakeCurrent(ptr.Pointer())
	}
}

//export callbackQOpenGLWidget_PaintGL
func callbackQOpenGLWidget_PaintGL(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paintGL"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQOpenGLWidgetFromPointer(ptr).PaintGLDefault()
	}
}

func (ptr *QOpenGLWidget) ConnectPaintGL(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paintGL"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "paintGL", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paintGL", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QOpenGLWidget) DisconnectPaintGL() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paintGL")
	}
}

func (ptr *QOpenGLWidget) PaintGL() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_PaintGL(ptr.Pointer())
	}
}

func (ptr *QOpenGLWidget) PaintGLDefault() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_PaintGLDefault(ptr.Pointer())
	}
}

//export callbackQOpenGLWidget_ResizeGL
func callbackQOpenGLWidget_ResizeGL(ptr unsafe.Pointer, w C.int, h C.int) {
	if signal := qt.GetSignal(ptr, "resizeGL"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(w)), int(int32(h)))
	} else {
		NewQOpenGLWidgetFromPointer(ptr).ResizeGLDefault(int(int32(w)), int(int32(h)))
	}
}

func (ptr *QOpenGLWidget) ConnectResizeGL(f func(w int, h int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resizeGL"); signal != nil {
			f := func(w int, h int) {
				(*(*func(int, int))(signal))(w, h)
				f(w, h)
			}
			qt.ConnectSignal(ptr.Pointer(), "resizeGL", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resizeGL", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QOpenGLWidget) DisconnectResizeGL() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resizeGL")
	}
}

func (ptr *QOpenGLWidget) ResizeGL(w int, h int) {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_ResizeGL(ptr.Pointer(), C.int(int32(w)), C.int(int32(h)))
	}
}

func (ptr *QOpenGLWidget) ResizeGLDefault(w int, h int) {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_ResizeGLDefault(ptr.Pointer(), C.int(int32(w)), C.int(int32(h)))
	}
}

//export callbackQOpenGLWidget_Resized
func callbackQOpenGLWidget_Resized(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resized"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QOpenGLWidget) ConnectResized(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "resized") {
			C.QOpenGLWidget_ConnectResized(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "resized"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "resized", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resized", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QOpenGLWidget) DisconnectResized() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_DisconnectResized(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "resized")
	}
}

func (ptr *QOpenGLWidget) Resized() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_Resized(ptr.Pointer())
	}
}

func (ptr *QOpenGLWidget) SetFormat(format gui.QSurfaceFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_SetFormat(ptr.Pointer(), gui.PointerFromQSurfaceFormat(format))
	}
}

func (ptr *QOpenGLWidget) SetTextureFormat(texFormat uint) {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_SetTextureFormat(ptr.Pointer(), C.uint(uint32(texFormat)))
	}
}

func (ptr *QOpenGLWidget) SetUpdateBehavior(updateBehavior QOpenGLWidget__UpdateBehavior) {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_SetUpdateBehavior(ptr.Pointer(), C.longlong(updateBehavior))
	}
}

//export callbackQOpenGLWidget_DestroyQOpenGLWidget
func callbackQOpenGLWidget_DestroyQOpenGLWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QOpenGLWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQOpenGLWidgetFromPointer(ptr).DestroyQOpenGLWidgetDefault()
	}
}

func (ptr *QOpenGLWidget) ConnectDestroyQOpenGLWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QOpenGLWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QOpenGLWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QOpenGLWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QOpenGLWidget) DisconnectDestroyQOpenGLWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QOpenGLWidget")
	}
}

func (ptr *QOpenGLWidget) DestroyQOpenGLWidget() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_DestroyQOpenGLWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QOpenGLWidget) DestroyQOpenGLWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QOpenGLWidget_DestroyQOpenGLWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QOpenGLWidget) TextureFormat() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QOpenGLWidget_TextureFormat(ptr.Pointer())))
	}
	return 0
}

func (ptr *QOpenGLWidget) DefaultFramebufferObject() uint {
	if ptr.Pointer() != nil {
		return uint(uint32(C.QOpenGLWidget_DefaultFramebufferObject(ptr.Pointer())))
	}
	return 0
}

func (ptr *QOpenGLWidget) Context() *gui.QOpenGLContext {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQOpenGLContextFromPointer(C.QOpenGLWidget_Context(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QOpenGLWidget) UpdateBehavior() QOpenGLWidget__UpdateBehavior {
	if ptr.Pointer() != nil {
		return QOpenGLWidget__UpdateBehavior(C.QOpenGLWidget_UpdateBehavior(ptr.Pointer()))
	}
	return 0
}

func (ptr *QOpenGLWidget) Format() *gui.QSurfaceFormat {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQSurfaceFormatFromPointer(C.QOpenGLWidget_Format(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QSurfaceFormat).DestroyQSurfaceFormat)
		return tmpValue
	}
	return nil
}

func (ptr *QOpenGLWidget) IsValid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QOpenGLWidget_IsValid(ptr.Pointer())) != 0
	}
	return false
}

type QPanGesture struct {
	QGesture
}

type QPanGesture_ITF interface {
	QGesture_ITF
	QPanGesture_PTR() *QPanGesture
}

func (ptr *QPanGesture) QPanGesture_PTR() *QPanGesture {
	return ptr
}

func (ptr *QPanGesture) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGesture_PTR().Pointer()
	}
	return nil
}

func (ptr *QPanGesture) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGesture_PTR().SetPointer(p)
	}
}

func PointerFromQPanGesture(ptr QPanGesture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPanGesture_PTR().Pointer()
	}
	return nil
}

func NewQPanGestureFromPointer(ptr unsafe.Pointer) (n *QPanGesture) {
	n = new(QPanGesture)
	n.SetPointer(ptr)
	return
}
func (ptr *QPanGesture) SetAcceleration(value float64) {
	if ptr.Pointer() != nil {
		C.QPanGesture_SetAcceleration(ptr.Pointer(), C.double(value))
	}
}

func (ptr *QPanGesture) SetLastOffset(value core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QPanGesture_SetLastOffset(ptr.Pointer(), core.PointerFromQPointF(value))
	}
}

func (ptr *QPanGesture) SetOffset(value core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QPanGesture_SetOffset(ptr.Pointer(), core.PointerFromQPointF(value))
	}
}

//export callbackQPanGesture_DestroyQPanGesture
func callbackQPanGesture_DestroyQPanGesture(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QPanGesture"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPanGestureFromPointer(ptr).DestroyQPanGestureDefault()
	}
}

func (ptr *QPanGesture) ConnectDestroyQPanGesture(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QPanGesture"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QPanGesture", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QPanGesture", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPanGesture) DisconnectDestroyQPanGesture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QPanGesture")
	}
}

func (ptr *QPanGesture) DestroyQPanGesture() {
	if ptr.Pointer() != nil {
		C.QPanGesture_DestroyQPanGesture(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPanGesture) DestroyQPanGestureDefault() {
	if ptr.Pointer() != nil {
		C.QPanGesture_DestroyQPanGestureDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPanGesture) Delta() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QPanGesture_Delta(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QPanGesture) LastOffset() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QPanGesture_LastOffset(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QPanGesture) Offset() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QPanGesture_Offset(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QPanGesture) Acceleration() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPanGesture_Acceleration(ptr.Pointer()))
	}
	return 0
}

type QPinchGesture struct {
	QGesture
}

type QPinchGesture_ITF interface {
	QGesture_ITF
	QPinchGesture_PTR() *QPinchGesture
}

func (ptr *QPinchGesture) QPinchGesture_PTR() *QPinchGesture {
	return ptr
}

func (ptr *QPinchGesture) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGesture_PTR().Pointer()
	}
	return nil
}

func (ptr *QPinchGesture) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGesture_PTR().SetPointer(p)
	}
}

func PointerFromQPinchGesture(ptr QPinchGesture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPinchGesture_PTR().Pointer()
	}
	return nil
}

func NewQPinchGestureFromPointer(ptr unsafe.Pointer) (n *QPinchGesture) {
	n = new(QPinchGesture)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QPinchGesture__ChangeFlag
//QPinchGesture::ChangeFlag
type QPinchGesture__ChangeFlag int64

const (
	QPinchGesture__ScaleFactorChanged   QPinchGesture__ChangeFlag = QPinchGesture__ChangeFlag(0x1)
	QPinchGesture__RotationAngleChanged QPinchGesture__ChangeFlag = QPinchGesture__ChangeFlag(0x2)
	QPinchGesture__CenterPointChanged   QPinchGesture__ChangeFlag = QPinchGesture__ChangeFlag(0x4)
)

func (ptr *QPinchGesture) SetCenterPoint(value core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetCenterPoint(ptr.Pointer(), core.PointerFromQPointF(value))
	}
}

func (ptr *QPinchGesture) SetChangeFlags(value QPinchGesture__ChangeFlag) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetChangeFlags(ptr.Pointer(), C.longlong(value))
	}
}

func (ptr *QPinchGesture) SetLastCenterPoint(value core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetLastCenterPoint(ptr.Pointer(), core.PointerFromQPointF(value))
	}
}

func (ptr *QPinchGesture) SetLastRotationAngle(value float64) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetLastRotationAngle(ptr.Pointer(), C.double(value))
	}
}

func (ptr *QPinchGesture) SetLastScaleFactor(value float64) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetLastScaleFactor(ptr.Pointer(), C.double(value))
	}
}

func (ptr *QPinchGesture) SetRotationAngle(value float64) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetRotationAngle(ptr.Pointer(), C.double(value))
	}
}

func (ptr *QPinchGesture) SetScaleFactor(value float64) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetScaleFactor(ptr.Pointer(), C.double(value))
	}
}

func (ptr *QPinchGesture) SetStartCenterPoint(value core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetStartCenterPoint(ptr.Pointer(), core.PointerFromQPointF(value))
	}
}

func (ptr *QPinchGesture) SetTotalChangeFlags(value QPinchGesture__ChangeFlag) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetTotalChangeFlags(ptr.Pointer(), C.longlong(value))
	}
}

func (ptr *QPinchGesture) SetTotalRotationAngle(value float64) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetTotalRotationAngle(ptr.Pointer(), C.double(value))
	}
}

func (ptr *QPinchGesture) SetTotalScaleFactor(value float64) {
	if ptr.Pointer() != nil {
		C.QPinchGesture_SetTotalScaleFactor(ptr.Pointer(), C.double(value))
	}
}

//export callbackQPinchGesture_DestroyQPinchGesture
func callbackQPinchGesture_DestroyQPinchGesture(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QPinchGesture"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPinchGestureFromPointer(ptr).DestroyQPinchGestureDefault()
	}
}

func (ptr *QPinchGesture) ConnectDestroyQPinchGesture(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QPinchGesture"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QPinchGesture", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QPinchGesture", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPinchGesture) DisconnectDestroyQPinchGesture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QPinchGesture")
	}
}

func (ptr *QPinchGesture) DestroyQPinchGesture() {
	if ptr.Pointer() != nil {
		C.QPinchGesture_DestroyQPinchGesture(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPinchGesture) DestroyQPinchGestureDefault() {
	if ptr.Pointer() != nil {
		C.QPinchGesture_DestroyQPinchGestureDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPinchGesture) ChangeFlags() QPinchGesture__ChangeFlag {
	if ptr.Pointer() != nil {
		return QPinchGesture__ChangeFlag(C.QPinchGesture_ChangeFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPinchGesture) TotalChangeFlags() QPinchGesture__ChangeFlag {
	if ptr.Pointer() != nil {
		return QPinchGesture__ChangeFlag(C.QPinchGesture_TotalChangeFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPinchGesture) CenterPoint() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QPinchGesture_CenterPoint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QPinchGesture) LastCenterPoint() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QPinchGesture_LastCenterPoint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QPinchGesture) StartCenterPoint() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QPinchGesture_StartCenterPoint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QPinchGesture) LastRotationAngle() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPinchGesture_LastRotationAngle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPinchGesture) LastScaleFactor() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPinchGesture_LastScaleFactor(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPinchGesture) RotationAngle() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPinchGesture_RotationAngle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPinchGesture) ScaleFactor() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPinchGesture_ScaleFactor(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPinchGesture) TotalRotationAngle() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPinchGesture_TotalRotationAngle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPinchGesture) TotalScaleFactor() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPinchGesture_TotalScaleFactor(ptr.Pointer()))
	}
	return 0
}

type QPlainTextDocumentLayout struct {
	gui.QAbstractTextDocumentLayout
}

type QPlainTextDocumentLayout_ITF interface {
	gui.QAbstractTextDocumentLayout_ITF
	QPlainTextDocumentLayout_PTR() *QPlainTextDocumentLayout
}

func (ptr *QPlainTextDocumentLayout) QPlainTextDocumentLayout_PTR() *QPlainTextDocumentLayout {
	return ptr
}

func (ptr *QPlainTextDocumentLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractTextDocumentLayout_PTR().Pointer()
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractTextDocumentLayout_PTR().SetPointer(p)
	}
}

func PointerFromQPlainTextDocumentLayout(ptr QPlainTextDocumentLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPlainTextDocumentLayout_PTR().Pointer()
	}
	return nil
}

func NewQPlainTextDocumentLayoutFromPointer(ptr unsafe.Pointer) (n *QPlainTextDocumentLayout) {
	n = new(QPlainTextDocumentLayout)
	n.SetPointer(ptr)
	return
}
func NewQPlainTextDocumentLayout(document gui.QTextDocument_ITF) *QPlainTextDocumentLayout {
	tmpValue := NewQPlainTextDocumentLayoutFromPointer(C.QPlainTextDocumentLayout_NewQPlainTextDocumentLayout(gui.PointerFromQTextDocument(document)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QPlainTextDocumentLayout_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QPlainTextDocumentLayout_QPlainTextDocumentLayout_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QPlainTextDocumentLayout) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QPlainTextDocumentLayout_QPlainTextDocumentLayout_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQPlainTextDocumentLayout_DocumentChanged
func callbackQPlainTextDocumentLayout_DocumentChanged(ptr unsafe.Pointer, from C.int, charsRemoved C.int, charsAdded C.int) {
	if signal := qt.GetSignal(ptr, "documentChanged"); signal != nil {
		(*(*func(int, int, int))(signal))(int(int32(from)), int(int32(charsRemoved)), int(int32(charsAdded)))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).DocumentChangedDefault(int(int32(from)), int(int32(charsRemoved)), int(int32(charsAdded)))
	}
}

func (ptr *QPlainTextDocumentLayout) ConnectDocumentChanged(f func(from int, charsRemoved int, charsAdded int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "documentChanged"); signal != nil {
			f := func(from int, charsRemoved int, charsAdded int) {
				(*(*func(int, int, int))(signal))(from, charsRemoved, charsAdded)
				f(from, charsRemoved, charsAdded)
			}
			qt.ConnectSignal(ptr.Pointer(), "documentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "documentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextDocumentLayout) DisconnectDocumentChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "documentChanged")
	}
}

func (ptr *QPlainTextDocumentLayout) DocumentChanged(from int, charsRemoved int, charsAdded int) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_DocumentChanged(ptr.Pointer(), C.int(int32(from)), C.int(int32(charsRemoved)), C.int(int32(charsAdded)))
	}
}

func (ptr *QPlainTextDocumentLayout) DocumentChangedDefault(from int, charsRemoved int, charsAdded int) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_DocumentChangedDefault(ptr.Pointer(), C.int(int32(from)), C.int(int32(charsRemoved)), C.int(int32(charsAdded)))
	}
}

//export callbackQPlainTextDocumentLayout_Draw
func callbackQPlainTextDocumentLayout_Draw(ptr unsafe.Pointer, vqp unsafe.Pointer, vpa unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "draw"); signal != nil {
		(*(*func(*gui.QPainter, *gui.QAbstractTextDocumentLayout_PaintContext))(signal))(gui.NewQPainterFromPointer(vqp), gui.NewQAbstractTextDocumentLayout_PaintContextFromPointer(vpa))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).DrawDefault(gui.NewQPainterFromPointer(vqp), gui.NewQAbstractTextDocumentLayout_PaintContextFromPointer(vpa))
	}
}

func (ptr *QPlainTextDocumentLayout) ConnectDraw(f func(vqp *gui.QPainter, vpa *gui.QAbstractTextDocumentLayout_PaintContext)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "draw"); signal != nil {
			f := func(vqp *gui.QPainter, vpa *gui.QAbstractTextDocumentLayout_PaintContext) {
				(*(*func(*gui.QPainter, *gui.QAbstractTextDocumentLayout_PaintContext))(signal))(vqp, vpa)
				f(vqp, vpa)
			}
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "draw", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextDocumentLayout) DisconnectDraw() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "draw")
	}
}

func (ptr *QPlainTextDocumentLayout) Draw(vqp gui.QPainter_ITF, vpa gui.QAbstractTextDocumentLayout_PaintContext_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_Draw(ptr.Pointer(), gui.PointerFromQPainter(vqp), gui.PointerFromQAbstractTextDocumentLayout_PaintContext(vpa))
	}
}

func (ptr *QPlainTextDocumentLayout) DrawDefault(vqp gui.QPainter_ITF, vpa gui.QAbstractTextDocumentLayout_PaintContext_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_DrawDefault(ptr.Pointer(), gui.PointerFromQPainter(vqp), gui.PointerFromQAbstractTextDocumentLayout_PaintContext(vpa))
	}
}

func (ptr *QPlainTextDocumentLayout) RequestUpdate() {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_RequestUpdate(ptr.Pointer())
	}
}

func (ptr *QPlainTextDocumentLayout) SetCursorWidth(width int) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_SetCursorWidth(ptr.Pointer(), C.int(int32(width)))
	}
}

//export callbackQPlainTextDocumentLayout_DestroyQPlainTextDocumentLayout
func callbackQPlainTextDocumentLayout_DestroyQPlainTextDocumentLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QPlainTextDocumentLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).DestroyQPlainTextDocumentLayoutDefault()
	}
}

func (ptr *QPlainTextDocumentLayout) ConnectDestroyQPlainTextDocumentLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QPlainTextDocumentLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QPlainTextDocumentLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QPlainTextDocumentLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextDocumentLayout) DisconnectDestroyQPlainTextDocumentLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QPlainTextDocumentLayout")
	}
}

func (ptr *QPlainTextDocumentLayout) DestroyQPlainTextDocumentLayout() {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_DestroyQPlainTextDocumentLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPlainTextDocumentLayout) DestroyQPlainTextDocumentLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_DestroyQPlainTextDocumentLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQPlainTextDocumentLayout_BlockBoundingRect
func callbackQPlainTextDocumentLayout_BlockBoundingRect(ptr unsafe.Pointer, block unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "blockBoundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func(*gui.QTextBlock) *core.QRectF)(signal))(gui.NewQTextBlockFromPointer(block)))
	}

	return core.PointerFromQRectF(NewQPlainTextDocumentLayoutFromPointer(ptr).BlockBoundingRectDefault(gui.NewQTextBlockFromPointer(block)))
}

func (ptr *QPlainTextDocumentLayout) ConnectBlockBoundingRect(f func(block *gui.QTextBlock) *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "blockBoundingRect"); signal != nil {
			f := func(block *gui.QTextBlock) *core.QRectF {
				(*(*func(*gui.QTextBlock) *core.QRectF)(signal))(block)
				return f(block)
			}
			qt.ConnectSignal(ptr.Pointer(), "blockBoundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "blockBoundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextDocumentLayout) DisconnectBlockBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "blockBoundingRect")
	}
}

func (ptr *QPlainTextDocumentLayout) BlockBoundingRect(block gui.QTextBlock_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QPlainTextDocumentLayout_BlockBoundingRect(ptr.Pointer(), gui.PointerFromQTextBlock(block)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) BlockBoundingRectDefault(block gui.QTextBlock_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QPlainTextDocumentLayout_BlockBoundingRectDefault(ptr.Pointer(), gui.PointerFromQTextBlock(block)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQPlainTextDocumentLayout_FrameBoundingRect
func callbackQPlainTextDocumentLayout_FrameBoundingRect(ptr unsafe.Pointer, vqt unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "frameBoundingRect"); signal != nil {
		return core.PointerFromQRectF((*(*func(*gui.QTextFrame) *core.QRectF)(signal))(gui.NewQTextFrameFromPointer(vqt)))
	}

	return core.PointerFromQRectF(NewQPlainTextDocumentLayoutFromPointer(ptr).FrameBoundingRectDefault(gui.NewQTextFrameFromPointer(vqt)))
}

func (ptr *QPlainTextDocumentLayout) ConnectFrameBoundingRect(f func(vqt *gui.QTextFrame) *core.QRectF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "frameBoundingRect"); signal != nil {
			f := func(vqt *gui.QTextFrame) *core.QRectF {
				(*(*func(*gui.QTextFrame) *core.QRectF)(signal))(vqt)
				return f(vqt)
			}
			qt.ConnectSignal(ptr.Pointer(), "frameBoundingRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "frameBoundingRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextDocumentLayout) DisconnectFrameBoundingRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "frameBoundingRect")
	}
}

func (ptr *QPlainTextDocumentLayout) FrameBoundingRect(vqt gui.QTextFrame_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QPlainTextDocumentLayout_FrameBoundingRect(ptr.Pointer(), gui.PointerFromQTextFrame(vqt)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) FrameBoundingRectDefault(vqt gui.QTextFrame_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QPlainTextDocumentLayout_FrameBoundingRectDefault(ptr.Pointer(), gui.PointerFromQTextFrame(vqt)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

//export callbackQPlainTextDocumentLayout_DocumentSize
func callbackQPlainTextDocumentLayout_DocumentSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "documentSize"); signal != nil {
		return core.PointerFromQSizeF((*(*func() *core.QSizeF)(signal))())
	}

	return core.PointerFromQSizeF(NewQPlainTextDocumentLayoutFromPointer(ptr).DocumentSizeDefault())
}

func (ptr *QPlainTextDocumentLayout) ConnectDocumentSize(f func() *core.QSizeF) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "documentSize"); signal != nil {
			f := func() *core.QSizeF {
				(*(*func() *core.QSizeF)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "documentSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "documentSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextDocumentLayout) DisconnectDocumentSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "documentSize")
	}
}

func (ptr *QPlainTextDocumentLayout) DocumentSize() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QPlainTextDocumentLayout_DocumentSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) DocumentSizeDefault() *core.QSizeF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFFromPointer(C.QPlainTextDocumentLayout_DocumentSizeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
		return tmpValue
	}
	return nil
}

//export callbackQPlainTextDocumentLayout_MetaObject
func callbackQPlainTextDocumentLayout_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQPlainTextDocumentLayoutFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QPlainTextDocumentLayout) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QPlainTextDocumentLayout_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) CursorWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPlainTextDocumentLayout_CursorWidth(ptr.Pointer())))
	}
	return 0
}

//export callbackQPlainTextDocumentLayout_HitTest
func callbackQPlainTextDocumentLayout_HitTest(ptr unsafe.Pointer, vqp unsafe.Pointer, vqt C.longlong) C.int {
	if signal := qt.GetSignal(ptr, "hitTest"); signal != nil {
		return C.int(int32((*(*func(*core.QPointF, core.Qt__HitTestAccuracy) int)(signal))(core.NewQPointFFromPointer(vqp), core.Qt__HitTestAccuracy(vqt))))
	}

	return C.int(int32(NewQPlainTextDocumentLayoutFromPointer(ptr).HitTestDefault(core.NewQPointFFromPointer(vqp), core.Qt__HitTestAccuracy(vqt))))
}

func (ptr *QPlainTextDocumentLayout) ConnectHitTest(f func(vqp *core.QPointF, vqt core.Qt__HitTestAccuracy) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hitTest"); signal != nil {
			f := func(vqp *core.QPointF, vqt core.Qt__HitTestAccuracy) int {
				(*(*func(*core.QPointF, core.Qt__HitTestAccuracy) int)(signal))(vqp, vqt)
				return f(vqp, vqt)
			}
			qt.ConnectSignal(ptr.Pointer(), "hitTest", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hitTest", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextDocumentLayout) DisconnectHitTest() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hitTest")
	}
}

func (ptr *QPlainTextDocumentLayout) HitTest(vqp core.QPointF_ITF, vqt core.Qt__HitTestAccuracy) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPlainTextDocumentLayout_HitTest(ptr.Pointer(), core.PointerFromQPointF(vqp), C.longlong(vqt))))
	}
	return 0
}

func (ptr *QPlainTextDocumentLayout) HitTestDefault(vqp core.QPointF_ITF, vqt core.Qt__HitTestAccuracy) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPlainTextDocumentLayout_HitTestDefault(ptr.Pointer(), core.PointerFromQPointF(vqp), C.longlong(vqt))))
	}
	return 0
}

//export callbackQPlainTextDocumentLayout_PageCount
func callbackQPlainTextDocumentLayout_PageCount(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "pageCount"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQPlainTextDocumentLayoutFromPointer(ptr).PageCountDefault()))
}

func (ptr *QPlainTextDocumentLayout) ConnectPageCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "pageCount"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "pageCount", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "pageCount", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextDocumentLayout) DisconnectPageCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "pageCount")
	}
}

func (ptr *QPlainTextDocumentLayout) PageCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPlainTextDocumentLayout_PageCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPlainTextDocumentLayout) PageCountDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPlainTextDocumentLayout_PageCountDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPlainTextDocumentLayout) EnsureBlockLayout(block gui.QTextBlock_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_EnsureBlockLayout(ptr.Pointer(), gui.PointerFromQTextBlock(block))
	}
}

func (ptr *QPlainTextDocumentLayout) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QPlainTextDocumentLayout___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QPlainTextDocumentLayout) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QPlainTextDocumentLayout___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QPlainTextDocumentLayout) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QPlainTextDocumentLayout___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QPlainTextDocumentLayout) __findChildren_newList2() unsafe.Pointer {
	return C.QPlainTextDocumentLayout___findChildren_newList2(ptr.Pointer())
}

func (ptr *QPlainTextDocumentLayout) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QPlainTextDocumentLayout___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QPlainTextDocumentLayout) __findChildren_newList3() unsafe.Pointer {
	return C.QPlainTextDocumentLayout___findChildren_newList3(ptr.Pointer())
}

func (ptr *QPlainTextDocumentLayout) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QPlainTextDocumentLayout___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QPlainTextDocumentLayout) __findChildren_newList() unsafe.Pointer {
	return C.QPlainTextDocumentLayout___findChildren_newList(ptr.Pointer())
}

func (ptr *QPlainTextDocumentLayout) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QPlainTextDocumentLayout___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextDocumentLayout) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QPlainTextDocumentLayout) __children_newList() unsafe.Pointer {
	return C.QPlainTextDocumentLayout___children_newList(ptr.Pointer())
}

//export callbackQPlainTextDocumentLayout_DocumentSizeChanged
func callbackQPlainTextDocumentLayout_DocumentSizeChanged(ptr unsafe.Pointer, newSize unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "documentSizeChanged"); signal != nil {
		(*(*func(*core.QSizeF))(signal))(core.NewQSizeFFromPointer(newSize))
	}

}

//export callbackQPlainTextDocumentLayout_DrawInlineObject
func callbackQPlainTextDocumentLayout_DrawInlineObject(ptr unsafe.Pointer, painter unsafe.Pointer, rect unsafe.Pointer, object unsafe.Pointer, posInDocument C.int, format unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawInlineObject"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRectF, *gui.QTextInlineObject, int, *gui.QTextFormat))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect), gui.NewQTextInlineObjectFromPointer(object), int(int32(posInDocument)), gui.NewQTextFormatFromPointer(format))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).DrawInlineObjectDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFFromPointer(rect), gui.NewQTextInlineObjectFromPointer(object), int(int32(posInDocument)), gui.NewQTextFormatFromPointer(format))
	}
}

func (ptr *QPlainTextDocumentLayout) DrawInlineObjectDefault(painter gui.QPainter_ITF, rect core.QRectF_ITF, object gui.QTextInlineObject_ITF, posInDocument int, format gui.QTextFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_DrawInlineObjectDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRectF(rect), gui.PointerFromQTextInlineObject(object), C.int(int32(posInDocument)), gui.PointerFromQTextFormat(format))
	}
}

//export callbackQPlainTextDocumentLayout_PageCountChanged
func callbackQPlainTextDocumentLayout_PageCountChanged(ptr unsafe.Pointer, newPages C.int) {
	if signal := qt.GetSignal(ptr, "pageCountChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(newPages)))
	}

}

//export callbackQPlainTextDocumentLayout_PositionInlineObject
func callbackQPlainTextDocumentLayout_PositionInlineObject(ptr unsafe.Pointer, item unsafe.Pointer, posInDocument C.int, format unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "positionInlineObject"); signal != nil {
		(*(*func(*gui.QTextInlineObject, int, *gui.QTextFormat))(signal))(gui.NewQTextInlineObjectFromPointer(item), int(int32(posInDocument)), gui.NewQTextFormatFromPointer(format))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).PositionInlineObjectDefault(gui.NewQTextInlineObjectFromPointer(item), int(int32(posInDocument)), gui.NewQTextFormatFromPointer(format))
	}
}

func (ptr *QPlainTextDocumentLayout) PositionInlineObjectDefault(item gui.QTextInlineObject_ITF, posInDocument int, format gui.QTextFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_PositionInlineObjectDefault(ptr.Pointer(), gui.PointerFromQTextInlineObject(item), C.int(int32(posInDocument)), gui.PointerFromQTextFormat(format))
	}
}

//export callbackQPlainTextDocumentLayout_ResizeInlineObject
func callbackQPlainTextDocumentLayout_ResizeInlineObject(ptr unsafe.Pointer, item unsafe.Pointer, posInDocument C.int, format unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resizeInlineObject"); signal != nil {
		(*(*func(*gui.QTextInlineObject, int, *gui.QTextFormat))(signal))(gui.NewQTextInlineObjectFromPointer(item), int(int32(posInDocument)), gui.NewQTextFormatFromPointer(format))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).ResizeInlineObjectDefault(gui.NewQTextInlineObjectFromPointer(item), int(int32(posInDocument)), gui.NewQTextFormatFromPointer(format))
	}
}

func (ptr *QPlainTextDocumentLayout) ResizeInlineObjectDefault(item gui.QTextInlineObject_ITF, posInDocument int, format gui.QTextFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_ResizeInlineObjectDefault(ptr.Pointer(), gui.PointerFromQTextInlineObject(item), C.int(int32(posInDocument)), gui.PointerFromQTextFormat(format))
	}
}

//export callbackQPlainTextDocumentLayout_Update
func callbackQPlainTextDocumentLayout_Update(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "update"); signal != nil {
		(*(*func(*core.QRectF))(signal))(core.NewQRectFFromPointer(rect))
	}

}

//export callbackQPlainTextDocumentLayout_UpdateBlock
func callbackQPlainTextDocumentLayout_UpdateBlock(ptr unsafe.Pointer, block unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateBlock"); signal != nil {
		(*(*func(*gui.QTextBlock))(signal))(gui.NewQTextBlockFromPointer(block))
	}

}

//export callbackQPlainTextDocumentLayout_Event
func callbackQPlainTextDocumentLayout_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQPlainTextDocumentLayoutFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QPlainTextDocumentLayout) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextDocumentLayout_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQPlainTextDocumentLayout_EventFilter
func callbackQPlainTextDocumentLayout_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQPlainTextDocumentLayoutFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QPlainTextDocumentLayout) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextDocumentLayout_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQPlainTextDocumentLayout_ChildEvent
func callbackQPlainTextDocumentLayout_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QPlainTextDocumentLayout) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQPlainTextDocumentLayout_ConnectNotify
func callbackQPlainTextDocumentLayout_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QPlainTextDocumentLayout) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQPlainTextDocumentLayout_CustomEvent
func callbackQPlainTextDocumentLayout_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QPlainTextDocumentLayout) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQPlainTextDocumentLayout_DeleteLater
func callbackQPlainTextDocumentLayout_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QPlainTextDocumentLayout) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQPlainTextDocumentLayout_Destroyed
func callbackQPlainTextDocumentLayout_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQPlainTextDocumentLayout_DisconnectNotify
func callbackQPlainTextDocumentLayout_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QPlainTextDocumentLayout) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQPlainTextDocumentLayout_ObjectNameChanged
func callbackQPlainTextDocumentLayout_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQPlainTextDocumentLayout_TimerEvent
func callbackQPlainTextDocumentLayout_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQPlainTextDocumentLayoutFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QPlainTextDocumentLayout) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextDocumentLayout_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QPlainTextEdit struct {
	QAbstractScrollArea
}

type QPlainTextEdit_ITF interface {
	QAbstractScrollArea_ITF
	QPlainTextEdit_PTR() *QPlainTextEdit
}

func (ptr *QPlainTextEdit) QPlainTextEdit_PTR() *QPlainTextEdit {
	return ptr
}

func (ptr *QPlainTextEdit) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractScrollArea_PTR().Pointer()
	}
	return nil
}

func (ptr *QPlainTextEdit) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractScrollArea_PTR().SetPointer(p)
	}
}

func PointerFromQPlainTextEdit(ptr QPlainTextEdit_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPlainTextEdit_PTR().Pointer()
	}
	return nil
}

func NewQPlainTextEditFromPointer(ptr unsafe.Pointer) (n *QPlainTextEdit) {
	n = new(QPlainTextEdit)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QPlainTextEdit__LineWrapMode
//QPlainTextEdit::LineWrapMode
type QPlainTextEdit__LineWrapMode int64

const (
	QPlainTextEdit__NoWrap      QPlainTextEdit__LineWrapMode = QPlainTextEdit__LineWrapMode(0)
	QPlainTextEdit__WidgetWidth QPlainTextEdit__LineWrapMode = QPlainTextEdit__LineWrapMode(1)
)

func (ptr *QPlainTextEdit) CreateStandardContextMenu() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QPlainTextEdit_CreateStandardContextMenu(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) CreateStandardContextMenu2(position core.QPoint_ITF) *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QPlainTextEdit_CreateStandardContextMenu2(ptr.Pointer(), core.PointerFromQPoint(position)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQPlainTextEdit(parent QWidget_ITF) *QPlainTextEdit {
	tmpValue := NewQPlainTextEditFromPointer(C.QPlainTextEdit_NewQPlainTextEdit(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQPlainTextEdit2(text string, parent QWidget_ITF) *QPlainTextEdit {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQPlainTextEditFromPointer(C.QPlainTextEdit_NewQPlainTextEdit2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQPlainTextEdit_LoadResource
func callbackQPlainTextEdit_LoadResource(ptr unsafe.Pointer, ty C.int, name unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "loadResource"); signal != nil {
		return core.PointerFromQVariant((*(*func(int, *core.QUrl) *core.QVariant)(signal))(int(int32(ty)), core.NewQUrlFromPointer(name)))
	}

	return core.PointerFromQVariant(NewQPlainTextEditFromPointer(ptr).LoadResourceDefault(int(int32(ty)), core.NewQUrlFromPointer(name)))
}

func (ptr *QPlainTextEdit) ConnectLoadResource(f func(ty int, name *core.QUrl) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "loadResource"); signal != nil {
			f := func(ty int, name *core.QUrl) *core.QVariant {
				(*(*func(int, *core.QUrl) *core.QVariant)(signal))(ty, name)
				return f(ty, name)
			}
			qt.ConnectSignal(ptr.Pointer(), "loadResource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "loadResource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectLoadResource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "loadResource")
	}
}

func (ptr *QPlainTextEdit) LoadResource(ty int, name core.QUrl_ITF) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QPlainTextEdit_LoadResource(ptr.Pointer(), C.int(int32(ty)), core.PointerFromQUrl(name)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) LoadResourceDefault(ty int, name core.QUrl_ITF) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QPlainTextEdit_LoadResourceDefault(ptr.Pointer(), C.int(int32(ty)), core.PointerFromQUrl(name)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) Find2(exp core.QRegExp_ITF, options gui.QTextDocument__FindFlag) bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_Find2(ptr.Pointer(), core.PointerFromQRegExp(exp), C.longlong(options))) != 0
	}
	return false
}

func (ptr *QPlainTextEdit) Find(exp string, options gui.QTextDocument__FindFlag) bool {
	if ptr.Pointer() != nil {
		var expC *C.char
		if exp != "" {
			expC = C.CString(exp)
			defer C.free(unsafe.Pointer(expC))
		}
		return int8(C.QPlainTextEdit_Find(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: expC, len: C.longlong(len(exp))}, C.longlong(options))) != 0
	}
	return false
}

//export callbackQPlainTextEdit_AppendHtml
func callbackQPlainTextEdit_AppendHtml(ptr unsafe.Pointer, html C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "appendHtml"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(html))
	} else {
		NewQPlainTextEditFromPointer(ptr).AppendHtmlDefault(cGoUnpackString(html))
	}
}

func (ptr *QPlainTextEdit) ConnectAppendHtml(f func(html string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "appendHtml"); signal != nil {
			f := func(html string) {
				(*(*func(string))(signal))(html)
				f(html)
			}
			qt.ConnectSignal(ptr.Pointer(), "appendHtml", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "appendHtml", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectAppendHtml() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "appendHtml")
	}
}

func (ptr *QPlainTextEdit) AppendHtml(html string) {
	if ptr.Pointer() != nil {
		var htmlC *C.char
		if html != "" {
			htmlC = C.CString(html)
			defer C.free(unsafe.Pointer(htmlC))
		}
		C.QPlainTextEdit_AppendHtml(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: htmlC, len: C.longlong(len(html))})
	}
}

func (ptr *QPlainTextEdit) AppendHtmlDefault(html string) {
	if ptr.Pointer() != nil {
		var htmlC *C.char
		if html != "" {
			htmlC = C.CString(html)
			defer C.free(unsafe.Pointer(htmlC))
		}
		C.QPlainTextEdit_AppendHtmlDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: htmlC, len: C.longlong(len(html))})
	}
}

//export callbackQPlainTextEdit_AppendPlainText
func callbackQPlainTextEdit_AppendPlainText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "appendPlainText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQPlainTextEditFromPointer(ptr).AppendPlainTextDefault(cGoUnpackString(text))
	}
}

func (ptr *QPlainTextEdit) ConnectAppendPlainText(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "appendPlainText"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "appendPlainText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "appendPlainText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectAppendPlainText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "appendPlainText")
	}
}

func (ptr *QPlainTextEdit) AppendPlainText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QPlainTextEdit_AppendPlainText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QPlainTextEdit) AppendPlainTextDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QPlainTextEdit_AppendPlainTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQPlainTextEdit_BlockCountChanged
func callbackQPlainTextEdit_BlockCountChanged(ptr unsafe.Pointer, newBlockCount C.int) {
	if signal := qt.GetSignal(ptr, "blockCountChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(newBlockCount)))
	}

}

func (ptr *QPlainTextEdit) ConnectBlockCountChanged(f func(newBlockCount int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "blockCountChanged") {
			C.QPlainTextEdit_ConnectBlockCountChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "blockCountChanged"); signal != nil {
			f := func(newBlockCount int) {
				(*(*func(int))(signal))(newBlockCount)
				f(newBlockCount)
			}
			qt.ConnectSignal(ptr.Pointer(), "blockCountChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "blockCountChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectBlockCountChanged() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DisconnectBlockCountChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "blockCountChanged")
	}
}

func (ptr *QPlainTextEdit) BlockCountChanged(newBlockCount int) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_BlockCountChanged(ptr.Pointer(), C.int(int32(newBlockCount)))
	}
}

//export callbackQPlainTextEdit_CenterCursor
func callbackQPlainTextEdit_CenterCursor(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "centerCursor"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextEditFromPointer(ptr).CenterCursorDefault()
	}
}

func (ptr *QPlainTextEdit) ConnectCenterCursor(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "centerCursor"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "centerCursor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "centerCursor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectCenterCursor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "centerCursor")
	}
}

func (ptr *QPlainTextEdit) CenterCursor() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_CenterCursor(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) CenterCursorDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_CenterCursorDefault(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_Clear
func callbackQPlainTextEdit_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextEditFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QPlainTextEdit) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QPlainTextEdit) Clear() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_Clear(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_ClearDefault(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_Copy
func callbackQPlainTextEdit_Copy(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "copy"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextEditFromPointer(ptr).CopyDefault()
	}
}

func (ptr *QPlainTextEdit) ConnectCopy(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "copy"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "copy", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "copy", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectCopy() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "copy")
	}
}

func (ptr *QPlainTextEdit) Copy() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_Copy(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) CopyDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_CopyDefault(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_CopyAvailable
func callbackQPlainTextEdit_CopyAvailable(ptr unsafe.Pointer, yes C.char) {
	if signal := qt.GetSignal(ptr, "copyAvailable"); signal != nil {
		(*(*func(bool))(signal))(int8(yes) != 0)
	}

}

func (ptr *QPlainTextEdit) ConnectCopyAvailable(f func(yes bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "copyAvailable") {
			C.QPlainTextEdit_ConnectCopyAvailable(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "copyAvailable"); signal != nil {
			f := func(yes bool) {
				(*(*func(bool))(signal))(yes)
				f(yes)
			}
			qt.ConnectSignal(ptr.Pointer(), "copyAvailable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "copyAvailable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectCopyAvailable() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DisconnectCopyAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "copyAvailable")
	}
}

func (ptr *QPlainTextEdit) CopyAvailable(yes bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_CopyAvailable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(yes))))
	}
}

//export callbackQPlainTextEdit_CursorPositionChanged
func callbackQPlainTextEdit_CursorPositionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "cursorPositionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QPlainTextEdit) ConnectCursorPositionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cursorPositionChanged") {
			C.QPlainTextEdit_ConnectCursorPositionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cursorPositionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "cursorPositionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cursorPositionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectCursorPositionChanged() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DisconnectCursorPositionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cursorPositionChanged")
	}
}

func (ptr *QPlainTextEdit) CursorPositionChanged() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_CursorPositionChanged(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_Cut
func callbackQPlainTextEdit_Cut(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "cut"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextEditFromPointer(ptr).CutDefault()
	}
}

func (ptr *QPlainTextEdit) ConnectCut(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "cut"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "cut", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cut", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectCut() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "cut")
	}
}

func (ptr *QPlainTextEdit) Cut() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_Cut(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) CutDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_CutDefault(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) EnsureCursorVisible() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_EnsureCursorVisible(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_InsertFromMimeData
func callbackQPlainTextEdit_InsertFromMimeData(ptr unsafe.Pointer, source unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "insertFromMimeData"); signal != nil {
		(*(*func(*core.QMimeData))(signal))(core.NewQMimeDataFromPointer(source))
	} else {
		NewQPlainTextEditFromPointer(ptr).InsertFromMimeDataDefault(core.NewQMimeDataFromPointer(source))
	}
}

func (ptr *QPlainTextEdit) ConnectInsertFromMimeData(f func(source *core.QMimeData)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "insertFromMimeData"); signal != nil {
			f := func(source *core.QMimeData) {
				(*(*func(*core.QMimeData))(signal))(source)
				f(source)
			}
			qt.ConnectSignal(ptr.Pointer(), "insertFromMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "insertFromMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectInsertFromMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "insertFromMimeData")
	}
}

func (ptr *QPlainTextEdit) InsertFromMimeData(source core.QMimeData_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_InsertFromMimeData(ptr.Pointer(), core.PointerFromQMimeData(source))
	}
}

func (ptr *QPlainTextEdit) InsertFromMimeDataDefault(source core.QMimeData_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_InsertFromMimeDataDefault(ptr.Pointer(), core.PointerFromQMimeData(source))
	}
}

//export callbackQPlainTextEdit_InsertPlainText
func callbackQPlainTextEdit_InsertPlainText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "insertPlainText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQPlainTextEditFromPointer(ptr).InsertPlainTextDefault(cGoUnpackString(text))
	}
}

func (ptr *QPlainTextEdit) ConnectInsertPlainText(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "insertPlainText"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "insertPlainText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "insertPlainText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectInsertPlainText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "insertPlainText")
	}
}

func (ptr *QPlainTextEdit) InsertPlainText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QPlainTextEdit_InsertPlainText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QPlainTextEdit) InsertPlainTextDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QPlainTextEdit_InsertPlainTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QPlainTextEdit) MergeCurrentCharFormat(modifier gui.QTextCharFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_MergeCurrentCharFormat(ptr.Pointer(), gui.PointerFromQTextCharFormat(modifier))
	}
}

//export callbackQPlainTextEdit_ModificationChanged
func callbackQPlainTextEdit_ModificationChanged(ptr unsafe.Pointer, changed C.char) {
	if signal := qt.GetSignal(ptr, "modificationChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(changed) != 0)
	}

}

func (ptr *QPlainTextEdit) ConnectModificationChanged(f func(changed bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "modificationChanged") {
			C.QPlainTextEdit_ConnectModificationChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "modificationChanged"); signal != nil {
			f := func(changed bool) {
				(*(*func(bool))(signal))(changed)
				f(changed)
			}
			qt.ConnectSignal(ptr.Pointer(), "modificationChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "modificationChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectModificationChanged() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DisconnectModificationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "modificationChanged")
	}
}

func (ptr *QPlainTextEdit) ModificationChanged(changed bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_ModificationChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(changed))))
	}
}

func (ptr *QPlainTextEdit) MoveCursor(operation gui.QTextCursor__MoveOperation, mode gui.QTextCursor__MoveMode) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_MoveCursor(ptr.Pointer(), C.longlong(operation), C.longlong(mode))
	}
}

//export callbackQPlainTextEdit_Paste
func callbackQPlainTextEdit_Paste(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paste"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextEditFromPointer(ptr).PasteDefault()
	}
}

func (ptr *QPlainTextEdit) ConnectPaste(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paste"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "paste", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paste", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectPaste() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paste")
	}
}

func (ptr *QPlainTextEdit) Paste() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_Paste(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) PasteDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_PasteDefault(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_Redo
func callbackQPlainTextEdit_Redo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "redo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextEditFromPointer(ptr).RedoDefault()
	}
}

func (ptr *QPlainTextEdit) ConnectRedo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "redo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectRedo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "redo")
	}
}

func (ptr *QPlainTextEdit) Redo() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_Redo(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) RedoDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_RedoDefault(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_RedoAvailable
func callbackQPlainTextEdit_RedoAvailable(ptr unsafe.Pointer, available C.char) {
	if signal := qt.GetSignal(ptr, "redoAvailable"); signal != nil {
		(*(*func(bool))(signal))(int8(available) != 0)
	}

}

func (ptr *QPlainTextEdit) ConnectRedoAvailable(f func(available bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "redoAvailable") {
			C.QPlainTextEdit_ConnectRedoAvailable(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "redoAvailable"); signal != nil {
			f := func(available bool) {
				(*(*func(bool))(signal))(available)
				f(available)
			}
			qt.ConnectSignal(ptr.Pointer(), "redoAvailable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redoAvailable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectRedoAvailable() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DisconnectRedoAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "redoAvailable")
	}
}

func (ptr *QPlainTextEdit) RedoAvailable(available bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_RedoAvailable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
	}
}

//export callbackQPlainTextEdit_SelectAll
func callbackQPlainTextEdit_SelectAll(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectAll"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextEditFromPointer(ptr).SelectAllDefault()
	}
}

func (ptr *QPlainTextEdit) ConnectSelectAll(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "selectAll"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "selectAll", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectAll", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectSelectAll() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "selectAll")
	}
}

func (ptr *QPlainTextEdit) SelectAll() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SelectAll(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) SelectAllDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SelectAllDefault(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_SelectionChanged
func callbackQPlainTextEdit_SelectionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QPlainTextEdit) ConnectSelectionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "selectionChanged") {
			C.QPlainTextEdit_ConnectSelectionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "selectionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DisconnectSelectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "selectionChanged")
	}
}

func (ptr *QPlainTextEdit) SelectionChanged() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SelectionChanged(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) SetBackgroundVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetBackgroundVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QPlainTextEdit) SetCenterOnScroll(enabled bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetCenterOnScroll(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QPlainTextEdit) SetCurrentCharFormat(format gui.QTextCharFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetCurrentCharFormat(ptr.Pointer(), gui.PointerFromQTextCharFormat(format))
	}
}

func (ptr *QPlainTextEdit) SetCursorWidth(width int) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetCursorWidth(ptr.Pointer(), C.int(int32(width)))
	}
}

func (ptr *QPlainTextEdit) SetDocument(document gui.QTextDocument_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetDocument(ptr.Pointer(), gui.PointerFromQTextDocument(document))
	}
}

func (ptr *QPlainTextEdit) SetDocumentTitle(title string) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		C.QPlainTextEdit_SetDocumentTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
	}
}

func (ptr *QPlainTextEdit) SetLineWrapMode(mode QPlainTextEdit__LineWrapMode) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetLineWrapMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QPlainTextEdit) SetMaximumBlockCount(maximum int) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetMaximumBlockCount(ptr.Pointer(), C.int(int32(maximum)))
	}
}

func (ptr *QPlainTextEdit) SetOverwriteMode(overwrite bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetOverwriteMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(overwrite))))
	}
}

func (ptr *QPlainTextEdit) SetPlaceholderText(placeholderText string) {
	if ptr.Pointer() != nil {
		var placeholderTextC *C.char
		if placeholderText != "" {
			placeholderTextC = C.CString(placeholderText)
			defer C.free(unsafe.Pointer(placeholderTextC))
		}
		C.QPlainTextEdit_SetPlaceholderText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: placeholderTextC, len: C.longlong(len(placeholderText))})
	}
}

//export callbackQPlainTextEdit_SetPlainText
func callbackQPlainTextEdit_SetPlainText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setPlainText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQPlainTextEditFromPointer(ptr).SetPlainTextDefault(cGoUnpackString(text))
	}
}

func (ptr *QPlainTextEdit) ConnectSetPlainText(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setPlainText"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "setPlainText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setPlainText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectSetPlainText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setPlainText")
	}
}

func (ptr *QPlainTextEdit) SetPlainText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QPlainTextEdit_SetPlainText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QPlainTextEdit) SetPlainTextDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QPlainTextEdit_SetPlainTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QPlainTextEdit) SetReadOnly(ro bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetReadOnly(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(ro))))
	}
}

func (ptr *QPlainTextEdit) SetTabChangesFocus(b bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetTabChangesFocus(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QPlainTextEdit) SetTabStopDistance(distance float64) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetTabStopDistance(ptr.Pointer(), C.double(distance))
	}
}

func (ptr *QPlainTextEdit) SetTabStopWidth(width int) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetTabStopWidth(ptr.Pointer(), C.int(int32(width)))
	}
}

func (ptr *QPlainTextEdit) SetTextCursor(cursor gui.QTextCursor_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetTextCursor(ptr.Pointer(), gui.PointerFromQTextCursor(cursor))
	}
}

func (ptr *QPlainTextEdit) SetTextInteractionFlags(flags core.Qt__TextInteractionFlag) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetTextInteractionFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QPlainTextEdit) SetUndoRedoEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetUndoRedoEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QPlainTextEdit) SetWordWrapMode(policy gui.QTextOption__WrapMode) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_SetWordWrapMode(ptr.Pointer(), C.longlong(policy))
	}
}

//export callbackQPlainTextEdit_TextChanged
func callbackQPlainTextEdit_TextChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "textChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QPlainTextEdit) ConnectTextChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "textChanged") {
			C.QPlainTextEdit_ConnectTextChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "textChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "textChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "textChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectTextChanged() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DisconnectTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "textChanged")
	}
}

func (ptr *QPlainTextEdit) TextChanged() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_TextChanged(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_Undo
func callbackQPlainTextEdit_Undo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "undo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextEditFromPointer(ptr).UndoDefault()
	}
}

func (ptr *QPlainTextEdit) ConnectUndo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "undo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectUndo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "undo")
	}
}

func (ptr *QPlainTextEdit) Undo() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_Undo(ptr.Pointer())
	}
}

func (ptr *QPlainTextEdit) UndoDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_UndoDefault(ptr.Pointer())
	}
}

//export callbackQPlainTextEdit_UndoAvailable
func callbackQPlainTextEdit_UndoAvailable(ptr unsafe.Pointer, available C.char) {
	if signal := qt.GetSignal(ptr, "undoAvailable"); signal != nil {
		(*(*func(bool))(signal))(int8(available) != 0)
	}

}

func (ptr *QPlainTextEdit) ConnectUndoAvailable(f func(available bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "undoAvailable") {
			C.QPlainTextEdit_ConnectUndoAvailable(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "undoAvailable"); signal != nil {
			f := func(available bool) {
				(*(*func(bool))(signal))(available)
				f(available)
			}
			qt.ConnectSignal(ptr.Pointer(), "undoAvailable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undoAvailable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectUndoAvailable() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DisconnectUndoAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "undoAvailable")
	}
}

func (ptr *QPlainTextEdit) UndoAvailable(available bool) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_UndoAvailable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
	}
}

//export callbackQPlainTextEdit_UpdateRequest
func callbackQPlainTextEdit_UpdateRequest(ptr unsafe.Pointer, rect unsafe.Pointer, dy C.int) {
	if signal := qt.GetSignal(ptr, "updateRequest"); signal != nil {
		(*(*func(*core.QRect, int))(signal))(core.NewQRectFromPointer(rect), int(int32(dy)))
	}

}

func (ptr *QPlainTextEdit) ConnectUpdateRequest(f func(rect *core.QRect, dy int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "updateRequest") {
			C.QPlainTextEdit_ConnectUpdateRequest(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "updateRequest"); signal != nil {
			f := func(rect *core.QRect, dy int) {
				(*(*func(*core.QRect, int))(signal))(rect, dy)
				f(rect, dy)
			}
			qt.ConnectSignal(ptr.Pointer(), "updateRequest", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateRequest", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectUpdateRequest() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DisconnectUpdateRequest(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "updateRequest")
	}
}

func (ptr *QPlainTextEdit) UpdateRequest(rect core.QRect_ITF, dy int) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_UpdateRequest(ptr.Pointer(), core.PointerFromQRect(rect), C.int(int32(dy)))
	}
}

//export callbackQPlainTextEdit_ZoomIn
func callbackQPlainTextEdit_ZoomIn(ptr unsafe.Pointer, ran C.int) {
	if signal := qt.GetSignal(ptr, "zoomIn"); signal != nil {
		(*(*func(int))(signal))(int(int32(ran)))
	} else {
		NewQPlainTextEditFromPointer(ptr).ZoomInDefault(int(int32(ran)))
	}
}

func (ptr *QPlainTextEdit) ConnectZoomIn(f func(ran int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "zoomIn"); signal != nil {
			f := func(ran int) {
				(*(*func(int))(signal))(ran)
				f(ran)
			}
			qt.ConnectSignal(ptr.Pointer(), "zoomIn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "zoomIn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectZoomIn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "zoomIn")
	}
}

func (ptr *QPlainTextEdit) ZoomIn(ran int) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_ZoomIn(ptr.Pointer(), C.int(int32(ran)))
	}
}

func (ptr *QPlainTextEdit) ZoomInDefault(ran int) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_ZoomInDefault(ptr.Pointer(), C.int(int32(ran)))
	}
}

//export callbackQPlainTextEdit_ZoomOut
func callbackQPlainTextEdit_ZoomOut(ptr unsafe.Pointer, ran C.int) {
	if signal := qt.GetSignal(ptr, "zoomOut"); signal != nil {
		(*(*func(int))(signal))(int(int32(ran)))
	} else {
		NewQPlainTextEditFromPointer(ptr).ZoomOutDefault(int(int32(ran)))
	}
}

func (ptr *QPlainTextEdit) ConnectZoomOut(f func(ran int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "zoomOut"); signal != nil {
			f := func(ran int) {
				(*(*func(int))(signal))(ran)
				f(ran)
			}
			qt.ConnectSignal(ptr.Pointer(), "zoomOut", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "zoomOut", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectZoomOut() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "zoomOut")
	}
}

func (ptr *QPlainTextEdit) ZoomOut(ran int) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_ZoomOut(ptr.Pointer(), C.int(int32(ran)))
	}
}

func (ptr *QPlainTextEdit) ZoomOutDefault(ran int) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_ZoomOutDefault(ptr.Pointer(), C.int(int32(ran)))
	}
}

//export callbackQPlainTextEdit_DestroyQPlainTextEdit
func callbackQPlainTextEdit_DestroyQPlainTextEdit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QPlainTextEdit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPlainTextEditFromPointer(ptr).DestroyQPlainTextEditDefault()
	}
}

func (ptr *QPlainTextEdit) ConnectDestroyQPlainTextEdit(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QPlainTextEdit"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QPlainTextEdit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QPlainTextEdit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectDestroyQPlainTextEdit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QPlainTextEdit")
	}
}

func (ptr *QPlainTextEdit) DestroyQPlainTextEdit() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DestroyQPlainTextEdit(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPlainTextEdit) DestroyQPlainTextEditDefault() {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_DestroyQPlainTextEditDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPlainTextEdit) GetPaintContext() *gui.QAbstractTextDocumentLayout_PaintContext {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQAbstractTextDocumentLayout_PaintContextFromPointer(C.QPlainTextEdit_GetPaintContext(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QAbstractTextDocumentLayout_PaintContext).DestroyQAbstractTextDocumentLayout_PaintContext)
		return tmpValue
	}
	return nil
}

//export callbackQPlainTextEdit_CreateMimeDataFromSelection
func callbackQPlainTextEdit_CreateMimeDataFromSelection(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "createMimeDataFromSelection"); signal != nil {
		return core.PointerFromQMimeData((*(*func() *core.QMimeData)(signal))())
	}

	return core.PointerFromQMimeData(NewQPlainTextEditFromPointer(ptr).CreateMimeDataFromSelectionDefault())
}

func (ptr *QPlainTextEdit) ConnectCreateMimeDataFromSelection(f func() *core.QMimeData) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "createMimeDataFromSelection"); signal != nil {
			f := func() *core.QMimeData {
				(*(*func() *core.QMimeData)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "createMimeDataFromSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "createMimeDataFromSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectCreateMimeDataFromSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "createMimeDataFromSelection")
	}
}

func (ptr *QPlainTextEdit) CreateMimeDataFromSelection() *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QPlainTextEdit_CreateMimeDataFromSelection(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) CreateMimeDataFromSelectionDefault() *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QPlainTextEdit_CreateMimeDataFromSelectionDefault(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) LineWrapMode() QPlainTextEdit__LineWrapMode {
	if ptr.Pointer() != nil {
		return QPlainTextEdit__LineWrapMode(C.QPlainTextEdit_LineWrapMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPlainTextEdit) ContentOffset() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QPlainTextEdit_ContentOffset(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) CursorRect2() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QPlainTextEdit_CursorRect2(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) CursorRect(cursor gui.QTextCursor_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QPlainTextEdit_CursorRect(ptr.Pointer(), gui.PointerFromQTextCursor(cursor)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) BlockBoundingGeometry(block gui.QTextBlock_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QPlainTextEdit_BlockBoundingGeometry(ptr.Pointer(), gui.PointerFromQTextBlock(block)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) BlockBoundingRect(block gui.QTextBlock_ITF) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QPlainTextEdit_BlockBoundingRect(ptr.Pointer(), gui.PointerFromQTextBlock(block)))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) AnchorAt(pos core.QPoint_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QPlainTextEdit_AnchorAt(ptr.Pointer(), core.PointerFromQPoint(pos)))
	}
	return ""
}

func (ptr *QPlainTextEdit) DocumentTitle() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QPlainTextEdit_DocumentTitle(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPlainTextEdit) PlaceholderText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QPlainTextEdit_PlaceholderText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPlainTextEdit) ToPlainText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QPlainTextEdit_ToPlainText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPlainTextEdit) FirstVisibleBlock() *gui.QTextBlock {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextBlockFromPointer(C.QPlainTextEdit_FirstVisibleBlock(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTextBlock).DestroyQTextBlock)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) CurrentCharFormat() *gui.QTextCharFormat {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCharFormatFromPointer(C.QPlainTextEdit_CurrentCharFormat(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCharFormat).DestroyQTextCharFormat)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) CursorForPosition(pos core.QPoint_ITF) *gui.QTextCursor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCursorFromPointer(C.QPlainTextEdit_CursorForPosition(ptr.Pointer(), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCursor).DestroyQTextCursor)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) TextCursor() *gui.QTextCursor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCursorFromPointer(C.QPlainTextEdit_TextCursor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCursor).DestroyQTextCursor)
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) Document() *gui.QTextDocument {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextDocumentFromPointer(C.QPlainTextEdit_Document(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPlainTextEdit) WordWrapMode() gui.QTextOption__WrapMode {
	if ptr.Pointer() != nil {
		return gui.QTextOption__WrapMode(C.QPlainTextEdit_WordWrapMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPlainTextEdit) TextInteractionFlags() core.Qt__TextInteractionFlag {
	if ptr.Pointer() != nil {
		return core.Qt__TextInteractionFlag(C.QPlainTextEdit_TextInteractionFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPlainTextEdit) BackgroundVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_BackgroundVisible(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQPlainTextEdit_CanInsertFromMimeData
func callbackQPlainTextEdit_CanInsertFromMimeData(ptr unsafe.Pointer, source unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "canInsertFromMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QMimeData) bool)(signal))(core.NewQMimeDataFromPointer(source)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQPlainTextEditFromPointer(ptr).CanInsertFromMimeDataDefault(core.NewQMimeDataFromPointer(source)))))
}

func (ptr *QPlainTextEdit) ConnectCanInsertFromMimeData(f func(source *core.QMimeData) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "canInsertFromMimeData"); signal != nil {
			f := func(source *core.QMimeData) bool {
				(*(*func(*core.QMimeData) bool)(signal))(source)
				return f(source)
			}
			qt.ConnectSignal(ptr.Pointer(), "canInsertFromMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canInsertFromMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPlainTextEdit) DisconnectCanInsertFromMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "canInsertFromMimeData")
	}
}

func (ptr *QPlainTextEdit) CanInsertFromMimeData(source core.QMimeData_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_CanInsertFromMimeData(ptr.Pointer(), core.PointerFromQMimeData(source))) != 0
	}
	return false
}

func (ptr *QPlainTextEdit) CanInsertFromMimeDataDefault(source core.QMimeData_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_CanInsertFromMimeDataDefault(ptr.Pointer(), core.PointerFromQMimeData(source))) != 0
	}
	return false
}

func (ptr *QPlainTextEdit) CanPaste() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_CanPaste(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPlainTextEdit) CenterOnScroll() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_CenterOnScroll(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPlainTextEdit) IsReadOnly() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_IsReadOnly(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPlainTextEdit) IsUndoRedoEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_IsUndoRedoEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPlainTextEdit) OverwriteMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_OverwriteMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPlainTextEdit) TabChangesFocus() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPlainTextEdit_TabChangesFocus(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPlainTextEdit) BlockCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPlainTextEdit_BlockCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPlainTextEdit) CursorWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPlainTextEdit_CursorWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPlainTextEdit) MaximumBlockCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPlainTextEdit_MaximumBlockCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPlainTextEdit) TabStopWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QPlainTextEdit_TabStopWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QPlainTextEdit) TabStopDistance() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QPlainTextEdit_TabStopDistance(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPlainTextEdit) Print(printer gui.QPagedPaintDevice_ITF) {
	if ptr.Pointer() != nil {
		C.QPlainTextEdit_Print(ptr.Pointer(), gui.PointerFromQPagedPaintDevice(printer))
	}
}

type QProgressBar struct {
	QWidget
}

type QProgressBar_ITF interface {
	QWidget_ITF
	QProgressBar_PTR() *QProgressBar
}

func (ptr *QProgressBar) QProgressBar_PTR() *QProgressBar {
	return ptr
}

func (ptr *QProgressBar) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QProgressBar) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQProgressBar(ptr QProgressBar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QProgressBar_PTR().Pointer()
	}
	return nil
}

func NewQProgressBarFromPointer(ptr unsafe.Pointer) (n *QProgressBar) {
	n = new(QProgressBar)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QProgressBar__Direction
//QProgressBar::Direction
type QProgressBar__Direction int64

const (
	QProgressBar__TopToBottom QProgressBar__Direction = QProgressBar__Direction(0)
	QProgressBar__BottomToTop QProgressBar__Direction = QProgressBar__Direction(1)
)

func NewQProgressBar(parent QWidget_ITF) *QProgressBar {
	tmpValue := NewQProgressBarFromPointer(C.QProgressBar_NewQProgressBar(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQProgressBar_Reset
func callbackQProgressBar_Reset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "reset"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProgressBarFromPointer(ptr).ResetDefault()
	}
}

func (ptr *QProgressBar) ConnectReset(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "reset"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressBar) DisconnectReset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "reset")
	}
}

func (ptr *QProgressBar) Reset() {
	if ptr.Pointer() != nil {
		C.QProgressBar_Reset(ptr.Pointer())
	}
}

func (ptr *QProgressBar) ResetDefault() {
	if ptr.Pointer() != nil {
		C.QProgressBar_ResetDefault(ptr.Pointer())
	}
}

func (ptr *QProgressBar) ResetFormat() {
	if ptr.Pointer() != nil {
		C.QProgressBar_ResetFormat(ptr.Pointer())
	}
}

func (ptr *QProgressBar) SetAlignment(alignment core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetAlignment(ptr.Pointer(), C.longlong(alignment))
	}
}

func (ptr *QProgressBar) SetFormat(format string) {
	if ptr.Pointer() != nil {
		var formatC *C.char
		if format != "" {
			formatC = C.CString(format)
			defer C.free(unsafe.Pointer(formatC))
		}
		C.QProgressBar_SetFormat(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: formatC, len: C.longlong(len(format))})
	}
}

func (ptr *QProgressBar) SetInvertedAppearance(invert bool) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetInvertedAppearance(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(invert))))
	}
}

//export callbackQProgressBar_SetMaximum
func callbackQProgressBar_SetMaximum(ptr unsafe.Pointer, maximum C.int) {
	if signal := qt.GetSignal(ptr, "setMaximum"); signal != nil {
		(*(*func(int))(signal))(int(int32(maximum)))
	} else {
		NewQProgressBarFromPointer(ptr).SetMaximumDefault(int(int32(maximum)))
	}
}

func (ptr *QProgressBar) ConnectSetMaximum(f func(maximum int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setMaximum"); signal != nil {
			f := func(maximum int) {
				(*(*func(int))(signal))(maximum)
				f(maximum)
			}
			qt.ConnectSignal(ptr.Pointer(), "setMaximum", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setMaximum", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressBar) DisconnectSetMaximum() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setMaximum")
	}
}

func (ptr *QProgressBar) SetMaximum(maximum int) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetMaximum(ptr.Pointer(), C.int(int32(maximum)))
	}
}

func (ptr *QProgressBar) SetMaximumDefault(maximum int) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetMaximumDefault(ptr.Pointer(), C.int(int32(maximum)))
	}
}

//export callbackQProgressBar_SetMinimum
func callbackQProgressBar_SetMinimum(ptr unsafe.Pointer, minimum C.int) {
	if signal := qt.GetSignal(ptr, "setMinimum"); signal != nil {
		(*(*func(int))(signal))(int(int32(minimum)))
	} else {
		NewQProgressBarFromPointer(ptr).SetMinimumDefault(int(int32(minimum)))
	}
}

func (ptr *QProgressBar) ConnectSetMinimum(f func(minimum int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setMinimum"); signal != nil {
			f := func(minimum int) {
				(*(*func(int))(signal))(minimum)
				f(minimum)
			}
			qt.ConnectSignal(ptr.Pointer(), "setMinimum", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setMinimum", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressBar) DisconnectSetMinimum() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setMinimum")
	}
}

func (ptr *QProgressBar) SetMinimum(minimum int) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetMinimum(ptr.Pointer(), C.int(int32(minimum)))
	}
}

func (ptr *QProgressBar) SetMinimumDefault(minimum int) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetMinimumDefault(ptr.Pointer(), C.int(int32(minimum)))
	}
}

//export callbackQProgressBar_SetOrientation
func callbackQProgressBar_SetOrientation(ptr unsafe.Pointer, vqt C.longlong) {
	if signal := qt.GetSignal(ptr, "setOrientation"); signal != nil {
		(*(*func(core.Qt__Orientation))(signal))(core.Qt__Orientation(vqt))
	} else {
		NewQProgressBarFromPointer(ptr).SetOrientationDefault(core.Qt__Orientation(vqt))
	}
}

func (ptr *QProgressBar) ConnectSetOrientation(f func(vqt core.Qt__Orientation)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setOrientation"); signal != nil {
			f := func(vqt core.Qt__Orientation) {
				(*(*func(core.Qt__Orientation))(signal))(vqt)
				f(vqt)
			}
			qt.ConnectSignal(ptr.Pointer(), "setOrientation", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setOrientation", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressBar) DisconnectSetOrientation() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setOrientation")
	}
}

func (ptr *QProgressBar) SetOrientation(vqt core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetOrientation(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QProgressBar) SetOrientationDefault(vqt core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetOrientationDefault(ptr.Pointer(), C.longlong(vqt))
	}
}

//export callbackQProgressBar_SetRange
func callbackQProgressBar_SetRange(ptr unsafe.Pointer, minimum C.int, maximum C.int) {
	if signal := qt.GetSignal(ptr, "setRange"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(minimum)), int(int32(maximum)))
	} else {
		NewQProgressBarFromPointer(ptr).SetRangeDefault(int(int32(minimum)), int(int32(maximum)))
	}
}

func (ptr *QProgressBar) ConnectSetRange(f func(minimum int, maximum int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setRange"); signal != nil {
			f := func(minimum int, maximum int) {
				(*(*func(int, int))(signal))(minimum, maximum)
				f(minimum, maximum)
			}
			qt.ConnectSignal(ptr.Pointer(), "setRange", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setRange", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressBar) DisconnectSetRange() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setRange")
	}
}

func (ptr *QProgressBar) SetRange(minimum int, maximum int) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetRange(ptr.Pointer(), C.int(int32(minimum)), C.int(int32(maximum)))
	}
}

func (ptr *QProgressBar) SetRangeDefault(minimum int, maximum int) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetRangeDefault(ptr.Pointer(), C.int(int32(minimum)), C.int(int32(maximum)))
	}
}

func (ptr *QProgressBar) SetTextDirection(textDirection QProgressBar__Direction) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetTextDirection(ptr.Pointer(), C.longlong(textDirection))
	}
}

func (ptr *QProgressBar) SetTextVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetTextVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQProgressBar_SetValue
func callbackQProgressBar_SetValue(ptr unsafe.Pointer, value C.int) {
	if signal := qt.GetSignal(ptr, "setValue"); signal != nil {
		(*(*func(int))(signal))(int(int32(value)))
	} else {
		NewQProgressBarFromPointer(ptr).SetValueDefault(int(int32(value)))
	}
}

func (ptr *QProgressBar) ConnectSetValue(f func(value int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setValue"); signal != nil {
			f := func(value int) {
				(*(*func(int))(signal))(value)
				f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressBar) DisconnectSetValue() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setValue")
	}
}

func (ptr *QProgressBar) SetValue(value int) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetValue(ptr.Pointer(), C.int(int32(value)))
	}
}

func (ptr *QProgressBar) SetValueDefault(value int) {
	if ptr.Pointer() != nil {
		C.QProgressBar_SetValueDefault(ptr.Pointer(), C.int(int32(value)))
	}
}

//export callbackQProgressBar_ValueChanged
func callbackQProgressBar_ValueChanged(ptr unsafe.Pointer, value C.int) {
	if signal := qt.GetSignal(ptr, "valueChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(value)))
	}

}

func (ptr *QProgressBar) ConnectValueChanged(f func(value int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "valueChanged") {
			C.QProgressBar_ConnectValueChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "valueChanged"); signal != nil {
			f := func(value int) {
				(*(*func(int))(signal))(value)
				f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressBar) DisconnectValueChanged() {
	if ptr.Pointer() != nil {
		C.QProgressBar_DisconnectValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "valueChanged")
	}
}

func (ptr *QProgressBar) ValueChanged(value int) {
	if ptr.Pointer() != nil {
		C.QProgressBar_ValueChanged(ptr.Pointer(), C.int(int32(value)))
	}
}

//export callbackQProgressBar_DestroyQProgressBar
func callbackQProgressBar_DestroyQProgressBar(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QProgressBar"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProgressBarFromPointer(ptr).DestroyQProgressBarDefault()
	}
}

func (ptr *QProgressBar) ConnectDestroyQProgressBar(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QProgressBar"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QProgressBar", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QProgressBar", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressBar) DisconnectDestroyQProgressBar() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QProgressBar")
	}
}

func (ptr *QProgressBar) DestroyQProgressBar() {
	if ptr.Pointer() != nil {
		C.QProgressBar_DestroyQProgressBar(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QProgressBar) DestroyQProgressBarDefault() {
	if ptr.Pointer() != nil {
		C.QProgressBar_DestroyQProgressBarDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QProgressBar) TextDirection() QProgressBar__Direction {
	if ptr.Pointer() != nil {
		return QProgressBar__Direction(C.QProgressBar_TextDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProgressBar) Format() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QProgressBar_Format(ptr.Pointer()))
	}
	return ""
}

//export callbackQProgressBar_Text
func callbackQProgressBar_Text(ptr unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "text"); signal != nil {
		tempVal := (*(*func() string)(signal))()
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQProgressBarFromPointer(ptr).TextDefault()
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QProgressBar) ConnectText(f func() string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "text"); signal != nil {
			f := func() string {
				(*(*func() string)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "text", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "text", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressBar) DisconnectText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "text")
	}
}

func (ptr *QProgressBar) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QProgressBar_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QProgressBar) TextDefault() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QProgressBar_TextDefault(ptr.Pointer()))
	}
	return ""
}

func (ptr *QProgressBar) Alignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QProgressBar_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProgressBar) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QProgressBar_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QProgressBar) InvertedAppearance() bool {
	if ptr.Pointer() != nil {
		return int8(C.QProgressBar_InvertedAppearance(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QProgressBar) IsTextVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QProgressBar_IsTextVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QProgressBar) Maximum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QProgressBar_Maximum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QProgressBar) Minimum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QProgressBar_Minimum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QProgressBar) Value() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QProgressBar_Value(ptr.Pointer())))
	}
	return 0
}

func (ptr *QProgressBar) InitStyleOption(option QStyleOptionProgressBar_ITF) {
	if ptr.Pointer() != nil {
		C.QProgressBar_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionProgressBar(option))
	}
}

type QProgressDialog struct {
	QDialog
}

type QProgressDialog_ITF interface {
	QDialog_ITF
	QProgressDialog_PTR() *QProgressDialog
}

func (ptr *QProgressDialog) QProgressDialog_PTR() *QProgressDialog {
	return ptr
}

func (ptr *QProgressDialog) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QDialog_PTR().Pointer()
	}
	return nil
}

func (ptr *QProgressDialog) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QDialog_PTR().SetPointer(p)
	}
}

func PointerFromQProgressDialog(ptr QProgressDialog_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QProgressDialog_PTR().Pointer()
	}
	return nil
}

func NewQProgressDialogFromPointer(ptr unsafe.Pointer) (n *QProgressDialog) {
	n = new(QProgressDialog)
	n.SetPointer(ptr)
	return
}
func NewQProgressDialog(parent QWidget_ITF, ff core.Qt__WindowType) *QProgressDialog {
	tmpValue := NewQProgressDialogFromPointer(C.QProgressDialog_NewQProgressDialog(PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQProgressDialog2(labelText string, cancelButtonText string, minimum int, maximum int, parent QWidget_ITF, ff core.Qt__WindowType) *QProgressDialog {
	var labelTextC *C.char
	if labelText != "" {
		labelTextC = C.CString(labelText)
		defer C.free(unsafe.Pointer(labelTextC))
	}
	var cancelButtonTextC *C.char
	if cancelButtonText != "" {
		cancelButtonTextC = C.CString(cancelButtonText)
		defer C.free(unsafe.Pointer(cancelButtonTextC))
	}
	tmpValue := NewQProgressDialogFromPointer(C.QProgressDialog_NewQProgressDialog2(C.struct_QtWidgets_PackedString{data: labelTextC, len: C.longlong(len(labelText))}, C.struct_QtWidgets_PackedString{data: cancelButtonTextC, len: C.longlong(len(cancelButtonText))}, C.int(int32(minimum)), C.int(int32(maximum)), PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQProgressDialog_Cancel
func callbackQProgressDialog_Cancel(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "cancel"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProgressDialogFromPointer(ptr).CancelDefault()
	}
}

func (ptr *QProgressDialog) ConnectCancel(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "cancel"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "cancel", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cancel", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectCancel() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "cancel")
	}
}

func (ptr *QProgressDialog) Cancel() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_Cancel(ptr.Pointer())
	}
}

func (ptr *QProgressDialog) CancelDefault() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_CancelDefault(ptr.Pointer())
	}
}

//export callbackQProgressDialog_Canceled
func callbackQProgressDialog_Canceled(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "canceled"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QProgressDialog) ConnectCanceled(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "canceled") {
			C.QProgressDialog_ConnectCanceled(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "canceled"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "canceled", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canceled", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectCanceled() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_DisconnectCanceled(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "canceled")
	}
}

func (ptr *QProgressDialog) Canceled() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_Canceled(ptr.Pointer())
	}
}

//export callbackQProgressDialog_ForceShow
func callbackQProgressDialog_ForceShow(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "forceShow"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProgressDialogFromPointer(ptr).ForceShowDefault()
	}
}

func (ptr *QProgressDialog) ConnectForceShow(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "forceShow"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "forceShow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "forceShow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectForceShow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "forceShow")
	}
}

func (ptr *QProgressDialog) ForceShow() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_ForceShow(ptr.Pointer())
	}
}

func (ptr *QProgressDialog) ForceShowDefault() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_ForceShowDefault(ptr.Pointer())
	}
}

func (ptr *QProgressDialog) Open(receiver core.QObject_ITF, member string) {
	if ptr.Pointer() != nil {
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		C.QProgressDialog_Open(ptr.Pointer(), core.PointerFromQObject(receiver), memberC)
	}
}

//export callbackQProgressDialog_Reset
func callbackQProgressDialog_Reset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "reset"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProgressDialogFromPointer(ptr).ResetDefault()
	}
}

func (ptr *QProgressDialog) ConnectReset(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "reset"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectReset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "reset")
	}
}

func (ptr *QProgressDialog) Reset() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_Reset(ptr.Pointer())
	}
}

func (ptr *QProgressDialog) ResetDefault() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_ResetDefault(ptr.Pointer())
	}
}

func (ptr *QProgressDialog) SetAutoClose(close bool) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetAutoClose(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(close))))
	}
}

func (ptr *QProgressDialog) SetAutoReset(reset bool) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetAutoReset(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(reset))))
	}
}

func (ptr *QProgressDialog) SetBar(bar QProgressBar_ITF) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetBar(ptr.Pointer(), PointerFromQProgressBar(bar))
	}
}

func (ptr *QProgressDialog) SetCancelButton(cancelButton QPushButton_ITF) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetCancelButton(ptr.Pointer(), PointerFromQPushButton(cancelButton))
	}
}

//export callbackQProgressDialog_SetCancelButtonText
func callbackQProgressDialog_SetCancelButtonText(ptr unsafe.Pointer, cancelButtonText C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setCancelButtonText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(cancelButtonText))
	} else {
		NewQProgressDialogFromPointer(ptr).SetCancelButtonTextDefault(cGoUnpackString(cancelButtonText))
	}
}

func (ptr *QProgressDialog) ConnectSetCancelButtonText(f func(cancelButtonText string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCancelButtonText"); signal != nil {
			f := func(cancelButtonText string) {
				(*(*func(string))(signal))(cancelButtonText)
				f(cancelButtonText)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCancelButtonText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCancelButtonText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectSetCancelButtonText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCancelButtonText")
	}
}

func (ptr *QProgressDialog) SetCancelButtonText(cancelButtonText string) {
	if ptr.Pointer() != nil {
		var cancelButtonTextC *C.char
		if cancelButtonText != "" {
			cancelButtonTextC = C.CString(cancelButtonText)
			defer C.free(unsafe.Pointer(cancelButtonTextC))
		}
		C.QProgressDialog_SetCancelButtonText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: cancelButtonTextC, len: C.longlong(len(cancelButtonText))})
	}
}

func (ptr *QProgressDialog) SetCancelButtonTextDefault(cancelButtonText string) {
	if ptr.Pointer() != nil {
		var cancelButtonTextC *C.char
		if cancelButtonText != "" {
			cancelButtonTextC = C.CString(cancelButtonText)
			defer C.free(unsafe.Pointer(cancelButtonTextC))
		}
		C.QProgressDialog_SetCancelButtonTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: cancelButtonTextC, len: C.longlong(len(cancelButtonText))})
	}
}

func (ptr *QProgressDialog) SetLabel(label QLabel_ITF) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetLabel(ptr.Pointer(), PointerFromQLabel(label))
	}
}

//export callbackQProgressDialog_SetLabelText
func callbackQProgressDialog_SetLabelText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setLabelText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQProgressDialogFromPointer(ptr).SetLabelTextDefault(cGoUnpackString(text))
	}
}

func (ptr *QProgressDialog) ConnectSetLabelText(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setLabelText"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "setLabelText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setLabelText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectSetLabelText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setLabelText")
	}
}

func (ptr *QProgressDialog) SetLabelText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QProgressDialog_SetLabelText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QProgressDialog) SetLabelTextDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QProgressDialog_SetLabelTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQProgressDialog_SetMaximum
func callbackQProgressDialog_SetMaximum(ptr unsafe.Pointer, maximum C.int) {
	if signal := qt.GetSignal(ptr, "setMaximum"); signal != nil {
		(*(*func(int))(signal))(int(int32(maximum)))
	} else {
		NewQProgressDialogFromPointer(ptr).SetMaximumDefault(int(int32(maximum)))
	}
}

func (ptr *QProgressDialog) ConnectSetMaximum(f func(maximum int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setMaximum"); signal != nil {
			f := func(maximum int) {
				(*(*func(int))(signal))(maximum)
				f(maximum)
			}
			qt.ConnectSignal(ptr.Pointer(), "setMaximum", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setMaximum", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectSetMaximum() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setMaximum")
	}
}

func (ptr *QProgressDialog) SetMaximum(maximum int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetMaximum(ptr.Pointer(), C.int(int32(maximum)))
	}
}

func (ptr *QProgressDialog) SetMaximumDefault(maximum int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetMaximumDefault(ptr.Pointer(), C.int(int32(maximum)))
	}
}

//export callbackQProgressDialog_SetMinimum
func callbackQProgressDialog_SetMinimum(ptr unsafe.Pointer, minimum C.int) {
	if signal := qt.GetSignal(ptr, "setMinimum"); signal != nil {
		(*(*func(int))(signal))(int(int32(minimum)))
	} else {
		NewQProgressDialogFromPointer(ptr).SetMinimumDefault(int(int32(minimum)))
	}
}

func (ptr *QProgressDialog) ConnectSetMinimum(f func(minimum int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setMinimum"); signal != nil {
			f := func(minimum int) {
				(*(*func(int))(signal))(minimum)
				f(minimum)
			}
			qt.ConnectSignal(ptr.Pointer(), "setMinimum", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setMinimum", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectSetMinimum() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setMinimum")
	}
}

func (ptr *QProgressDialog) SetMinimum(minimum int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetMinimum(ptr.Pointer(), C.int(int32(minimum)))
	}
}

func (ptr *QProgressDialog) SetMinimumDefault(minimum int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetMinimumDefault(ptr.Pointer(), C.int(int32(minimum)))
	}
}

//export callbackQProgressDialog_SetMinimumDuration
func callbackQProgressDialog_SetMinimumDuration(ptr unsafe.Pointer, ms C.int) {
	if signal := qt.GetSignal(ptr, "setMinimumDuration"); signal != nil {
		(*(*func(int))(signal))(int(int32(ms)))
	} else {
		NewQProgressDialogFromPointer(ptr).SetMinimumDurationDefault(int(int32(ms)))
	}
}

func (ptr *QProgressDialog) ConnectSetMinimumDuration(f func(ms int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setMinimumDuration"); signal != nil {
			f := func(ms int) {
				(*(*func(int))(signal))(ms)
				f(ms)
			}
			qt.ConnectSignal(ptr.Pointer(), "setMinimumDuration", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setMinimumDuration", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectSetMinimumDuration() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setMinimumDuration")
	}
}

func (ptr *QProgressDialog) SetMinimumDuration(ms int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetMinimumDuration(ptr.Pointer(), C.int(int32(ms)))
	}
}

func (ptr *QProgressDialog) SetMinimumDurationDefault(ms int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetMinimumDurationDefault(ptr.Pointer(), C.int(int32(ms)))
	}
}

//export callbackQProgressDialog_SetRange
func callbackQProgressDialog_SetRange(ptr unsafe.Pointer, minimum C.int, maximum C.int) {
	if signal := qt.GetSignal(ptr, "setRange"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(minimum)), int(int32(maximum)))
	} else {
		NewQProgressDialogFromPointer(ptr).SetRangeDefault(int(int32(minimum)), int(int32(maximum)))
	}
}

func (ptr *QProgressDialog) ConnectSetRange(f func(minimum int, maximum int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setRange"); signal != nil {
			f := func(minimum int, maximum int) {
				(*(*func(int, int))(signal))(minimum, maximum)
				f(minimum, maximum)
			}
			qt.ConnectSignal(ptr.Pointer(), "setRange", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setRange", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectSetRange() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setRange")
	}
}

func (ptr *QProgressDialog) SetRange(minimum int, maximum int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetRange(ptr.Pointer(), C.int(int32(minimum)), C.int(int32(maximum)))
	}
}

func (ptr *QProgressDialog) SetRangeDefault(minimum int, maximum int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetRangeDefault(ptr.Pointer(), C.int(int32(minimum)), C.int(int32(maximum)))
	}
}

//export callbackQProgressDialog_SetValue
func callbackQProgressDialog_SetValue(ptr unsafe.Pointer, progress C.int) {
	if signal := qt.GetSignal(ptr, "setValue"); signal != nil {
		(*(*func(int))(signal))(int(int32(progress)))
	} else {
		NewQProgressDialogFromPointer(ptr).SetValueDefault(int(int32(progress)))
	}
}

func (ptr *QProgressDialog) ConnectSetValue(f func(progress int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setValue"); signal != nil {
			f := func(progress int) {
				(*(*func(int))(signal))(progress)
				f(progress)
			}
			qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectSetValue() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setValue")
	}
}

func (ptr *QProgressDialog) SetValue(progress int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetValue(ptr.Pointer(), C.int(int32(progress)))
	}
}

func (ptr *QProgressDialog) SetValueDefault(progress int) {
	if ptr.Pointer() != nil {
		C.QProgressDialog_SetValueDefault(ptr.Pointer(), C.int(int32(progress)))
	}
}

//export callbackQProgressDialog_DestroyQProgressDialog
func callbackQProgressDialog_DestroyQProgressDialog(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QProgressDialog"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProgressDialogFromPointer(ptr).DestroyQProgressDialogDefault()
	}
}

func (ptr *QProgressDialog) ConnectDestroyQProgressDialog(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QProgressDialog"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QProgressDialog", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QProgressDialog", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProgressDialog) DisconnectDestroyQProgressDialog() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QProgressDialog")
	}
}

func (ptr *QProgressDialog) DestroyQProgressDialog() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_DestroyQProgressDialog(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QProgressDialog) DestroyQProgressDialogDefault() {
	if ptr.Pointer() != nil {
		C.QProgressDialog_DestroyQProgressDialogDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QProgressDialog) LabelText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QProgressDialog_LabelText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QProgressDialog) AutoClose() bool {
	if ptr.Pointer() != nil {
		return int8(C.QProgressDialog_AutoClose(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QProgressDialog) AutoReset() bool {
	if ptr.Pointer() != nil {
		return int8(C.QProgressDialog_AutoReset(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QProgressDialog) WasCanceled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QProgressDialog_WasCanceled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QProgressDialog) Maximum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QProgressDialog_Maximum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QProgressDialog) Minimum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QProgressDialog_Minimum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QProgressDialog) MinimumDuration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QProgressDialog_MinimumDuration(ptr.Pointer())))
	}
	return 0
}

func (ptr *QProgressDialog) Value() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QProgressDialog_Value(ptr.Pointer())))
	}
	return 0
}

type QProxyStyle struct {
	QCommonStyle
}

type QProxyStyle_ITF interface {
	QCommonStyle_ITF
	QProxyStyle_PTR() *QProxyStyle
}

func (ptr *QProxyStyle) QProxyStyle_PTR() *QProxyStyle {
	return ptr
}

func (ptr *QProxyStyle) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QCommonStyle_PTR().Pointer()
	}
	return nil
}

func (ptr *QProxyStyle) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QCommonStyle_PTR().SetPointer(p)
	}
}

func PointerFromQProxyStyle(ptr QProxyStyle_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QProxyStyle_PTR().Pointer()
	}
	return nil
}

func NewQProxyStyleFromPointer(ptr unsafe.Pointer) (n *QProxyStyle) {
	n = new(QProxyStyle)
	n.SetPointer(ptr)
	return
}
func NewQProxyStyle(style QStyle_ITF) *QProxyStyle {
	tmpValue := NewQProxyStyleFromPointer(C.QProxyStyle_NewQProxyStyle(PointerFromQStyle(style)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQProxyStyle2(key string) *QProxyStyle {
	var keyC *C.char
	if key != "" {
		keyC = C.CString(key)
		defer C.free(unsafe.Pointer(keyC))
	}
	tmpValue := NewQProxyStyleFromPointer(C.QProxyStyle_NewQProxyStyle2(C.struct_QtWidgets_PackedString{data: keyC, len: C.longlong(len(key))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QProxyStyle) SetBaseStyle(style QStyle_ITF) {
	if ptr.Pointer() != nil {
		C.QProxyStyle_SetBaseStyle(ptr.Pointer(), PointerFromQStyle(style))
	}
}

//export callbackQProxyStyle_DestroyQProxyStyle
func callbackQProxyStyle_DestroyQProxyStyle(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QProxyStyle"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQProxyStyleFromPointer(ptr).DestroyQProxyStyleDefault()
	}
}

func (ptr *QProxyStyle) ConnectDestroyQProxyStyle(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QProxyStyle"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QProxyStyle", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QProxyStyle", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProxyStyle) DisconnectDestroyQProxyStyle() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QProxyStyle")
	}
}

func (ptr *QProxyStyle) DestroyQProxyStyle() {
	if ptr.Pointer() != nil {
		C.QProxyStyle_DestroyQProxyStyle(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QProxyStyle) DestroyQProxyStyleDefault() {
	if ptr.Pointer() != nil {
		C.QProxyStyle_DestroyQProxyStyleDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQProxyStyle_StandardIcon
func callbackQProxyStyle_StandardIcon(ptr unsafe.Pointer, standardIcon C.longlong, option unsafe.Pointer, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "standardIcon"); signal != nil {
		return gui.PointerFromQIcon((*(*func(QStyle__StandardPixmap, *QStyleOption, *QWidget) *gui.QIcon)(signal))(QStyle__StandardPixmap(standardIcon), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget)))
	}

	return gui.PointerFromQIcon(NewQProxyStyleFromPointer(ptr).StandardIconDefault(QStyle__StandardPixmap(standardIcon), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget)))
}

func (ptr *QProxyStyle) ConnectStandardIcon(f func(standardIcon QStyle__StandardPixmap, option *QStyleOption, widget *QWidget) *gui.QIcon) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "standardIcon"); signal != nil {
			f := func(standardIcon QStyle__StandardPixmap, option *QStyleOption, widget *QWidget) *gui.QIcon {
				(*(*func(QStyle__StandardPixmap, *QStyleOption, *QWidget) *gui.QIcon)(signal))(standardIcon, option, widget)
				return f(standardIcon, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "standardIcon", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "standardIcon", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QProxyStyle) DisconnectStandardIcon() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "standardIcon")
	}
}

func (ptr *QProxyStyle) StandardIcon(standardIcon QStyle__StandardPixmap, option QStyleOption_ITF, widget QWidget_ITF) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QProxyStyle_StandardIcon(ptr.Pointer(), C.longlong(standardIcon), PointerFromQStyleOption(option), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QProxyStyle) StandardIconDefault(standardIcon QStyle__StandardPixmap, option QStyleOption_ITF, widget QWidget_ITF) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QProxyStyle_StandardIconDefault(ptr.Pointer(), C.longlong(standardIcon), PointerFromQStyleOption(option), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QProxyStyle) BaseStyle() *QStyle {
	if ptr.Pointer() != nil {
		tmpValue := NewQStyleFromPointer(C.QProxyStyle_BaseStyle(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

type QPushButton struct {
	QAbstractButton
}

type QPushButton_ITF interface {
	QAbstractButton_ITF
	QPushButton_PTR() *QPushButton
}

func (ptr *QPushButton) QPushButton_PTR() *QPushButton {
	return ptr
}

func (ptr *QPushButton) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractButton_PTR().Pointer()
	}
	return nil
}

func (ptr *QPushButton) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractButton_PTR().SetPointer(p)
	}
}

func PointerFromQPushButton(ptr QPushButton_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPushButton_PTR().Pointer()
	}
	return nil
}

func NewQPushButtonFromPointer(ptr unsafe.Pointer) (n *QPushButton) {
	n = new(QPushButton)
	n.SetPointer(ptr)
	return
}
func NewQPushButton(parent QWidget_ITF) *QPushButton {
	tmpValue := NewQPushButtonFromPointer(C.QPushButton_NewQPushButton(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQPushButton3(icon gui.QIcon_ITF, text string, parent QWidget_ITF) *QPushButton {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQPushButtonFromPointer(C.QPushButton_NewQPushButton3(gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQPushButton2(text string, parent QWidget_ITF) *QPushButton {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQPushButtonFromPointer(C.QPushButton_NewQPushButton2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQPushButton_PaintEvent
func callbackQPushButton_PaintEvent(ptr unsafe.Pointer, vqp unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paintEvent"); signal != nil {
		(*(*func(*gui.QPaintEvent))(signal))(gui.NewQPaintEventFromPointer(vqp))
	} else {
		NewQPushButtonFromPointer(ptr).PaintEventDefault(gui.NewQPaintEventFromPointer(vqp))
	}
}

func (ptr *QPushButton) ConnectPaintEvent(f func(vqp *gui.QPaintEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paintEvent"); signal != nil {
			f := func(vqp *gui.QPaintEvent) {
				(*(*func(*gui.QPaintEvent))(signal))(vqp)
				f(vqp)
			}
			qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPushButton) DisconnectPaintEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paintEvent")
	}
}

func (ptr *QPushButton) PaintEvent(vqp gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QPushButton_PaintEvent(ptr.Pointer(), gui.PointerFromQPaintEvent(vqp))
	}
}

func (ptr *QPushButton) PaintEventDefault(vqp gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QPushButton_PaintEventDefault(ptr.Pointer(), gui.PointerFromQPaintEvent(vqp))
	}
}

func (ptr *QPushButton) SetAutoDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QPushButton_SetAutoDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QPushButton) SetDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QPushButton_SetDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QPushButton) SetFlat(vbo bool) {
	if ptr.Pointer() != nil {
		C.QPushButton_SetFlat(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QPushButton) SetMenu(menu QMenu_ITF) {
	if ptr.Pointer() != nil {
		C.QPushButton_SetMenu(ptr.Pointer(), PointerFromQMenu(menu))
	}
}

//export callbackQPushButton_ShowMenu
func callbackQPushButton_ShowMenu(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showMenu"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPushButtonFromPointer(ptr).ShowMenuDefault()
	}
}

func (ptr *QPushButton) ConnectShowMenu(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMenu"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "showMenu", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMenu", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPushButton) DisconnectShowMenu() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMenu")
	}
}

func (ptr *QPushButton) ShowMenu() {
	if ptr.Pointer() != nil {
		C.QPushButton_ShowMenu(ptr.Pointer())
	}
}

func (ptr *QPushButton) ShowMenuDefault() {
	if ptr.Pointer() != nil {
		C.QPushButton_ShowMenuDefault(ptr.Pointer())
	}
}

//export callbackQPushButton_DestroyQPushButton
func callbackQPushButton_DestroyQPushButton(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QPushButton"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQPushButtonFromPointer(ptr).DestroyQPushButtonDefault()
	}
}

func (ptr *QPushButton) ConnectDestroyQPushButton(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QPushButton"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QPushButton", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QPushButton", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QPushButton) DisconnectDestroyQPushButton() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QPushButton")
	}
}

func (ptr *QPushButton) DestroyQPushButton() {
	if ptr.Pointer() != nil {
		C.QPushButton_DestroyQPushButton(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPushButton) DestroyQPushButtonDefault() {
	if ptr.Pointer() != nil {
		C.QPushButton_DestroyQPushButtonDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QPushButton) Menu() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QPushButton_Menu(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QPushButton) AutoDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPushButton_AutoDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPushButton) IsDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPushButton_IsDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPushButton) IsFlat() bool {
	if ptr.Pointer() != nil {
		return int8(C.QPushButton_IsFlat(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QPushButton) InitStyleOption(option QStyleOptionButton_ITF) {
	if ptr.Pointer() != nil {
		C.QPushButton_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionButton(option))
	}
}

type QRadioButton struct {
	QAbstractButton
}

type QRadioButton_ITF interface {
	QAbstractButton_ITF
	QRadioButton_PTR() *QRadioButton
}

func (ptr *QRadioButton) QRadioButton_PTR() *QRadioButton {
	return ptr
}

func (ptr *QRadioButton) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractButton_PTR().Pointer()
	}
	return nil
}

func (ptr *QRadioButton) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractButton_PTR().SetPointer(p)
	}
}

func PointerFromQRadioButton(ptr QRadioButton_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRadioButton_PTR().Pointer()
	}
	return nil
}

func NewQRadioButtonFromPointer(ptr unsafe.Pointer) (n *QRadioButton) {
	n = new(QRadioButton)
	n.SetPointer(ptr)
	return
}
func NewQRadioButton(parent QWidget_ITF) *QRadioButton {
	tmpValue := NewQRadioButtonFromPointer(C.QRadioButton_NewQRadioButton(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQRadioButton2(text string, parent QWidget_ITF) *QRadioButton {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQRadioButtonFromPointer(C.QRadioButton_NewQRadioButton2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQRadioButton_PaintEvent
func callbackQRadioButton_PaintEvent(ptr unsafe.Pointer, vqp unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paintEvent"); signal != nil {
		(*(*func(*gui.QPaintEvent))(signal))(gui.NewQPaintEventFromPointer(vqp))
	} else {
		NewQRadioButtonFromPointer(ptr).PaintEventDefault(gui.NewQPaintEventFromPointer(vqp))
	}
}

func (ptr *QRadioButton) ConnectPaintEvent(f func(vqp *gui.QPaintEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paintEvent"); signal != nil {
			f := func(vqp *gui.QPaintEvent) {
				(*(*func(*gui.QPaintEvent))(signal))(vqp)
				f(vqp)
			}
			qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QRadioButton) DisconnectPaintEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paintEvent")
	}
}

func (ptr *QRadioButton) PaintEvent(vqp gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QRadioButton_PaintEvent(ptr.Pointer(), gui.PointerFromQPaintEvent(vqp))
	}
}

func (ptr *QRadioButton) PaintEventDefault(vqp gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QRadioButton_PaintEventDefault(ptr.Pointer(), gui.PointerFromQPaintEvent(vqp))
	}
}

//export callbackQRadioButton_DestroyQRadioButton
func callbackQRadioButton_DestroyQRadioButton(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QRadioButton"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQRadioButtonFromPointer(ptr).DestroyQRadioButtonDefault()
	}
}

func (ptr *QRadioButton) ConnectDestroyQRadioButton(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QRadioButton"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QRadioButton", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QRadioButton", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QRadioButton) DisconnectDestroyQRadioButton() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QRadioButton")
	}
}

func (ptr *QRadioButton) DestroyQRadioButton() {
	if ptr.Pointer() != nil {
		C.QRadioButton_DestroyQRadioButton(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QRadioButton) DestroyQRadioButtonDefault() {
	if ptr.Pointer() != nil {
		C.QRadioButton_DestroyQRadioButtonDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QRadioButton) InitStyleOption(option QStyleOptionButton_ITF) {
	if ptr.Pointer() != nil {
		C.QRadioButton_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionButton(option))
	}
}

type QRubberBand struct {
	QWidget
}

type QRubberBand_ITF interface {
	QWidget_ITF
	QRubberBand_PTR() *QRubberBand
}

func (ptr *QRubberBand) QRubberBand_PTR() *QRubberBand {
	return ptr
}

func (ptr *QRubberBand) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QRubberBand) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQRubberBand(ptr QRubberBand_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRubberBand_PTR().Pointer()
	}
	return nil
}

func NewQRubberBandFromPointer(ptr unsafe.Pointer) (n *QRubberBand) {
	n = new(QRubberBand)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QRubberBand__Shape
//QRubberBand::Shape
type QRubberBand__Shape int64

const (
	QRubberBand__Line      QRubberBand__Shape = QRubberBand__Shape(0)
	QRubberBand__Rectangle QRubberBand__Shape = QRubberBand__Shape(1)
)

func NewQRubberBand(s QRubberBand__Shape, p QWidget_ITF) *QRubberBand {
	tmpValue := NewQRubberBandFromPointer(C.QRubberBand_NewQRubberBand(C.longlong(s), PointerFromQWidget(p)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQRubberBand_DestroyQRubberBand
func callbackQRubberBand_DestroyQRubberBand(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QRubberBand"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQRubberBandFromPointer(ptr).DestroyQRubberBandDefault()
	}
}

func (ptr *QRubberBand) ConnectDestroyQRubberBand(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QRubberBand"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QRubberBand", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QRubberBand", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QRubberBand) DisconnectDestroyQRubberBand() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QRubberBand")
	}
}

func (ptr *QRubberBand) DestroyQRubberBand() {
	if ptr.Pointer() != nil {
		C.QRubberBand_DestroyQRubberBand(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QRubberBand) DestroyQRubberBandDefault() {
	if ptr.Pointer() != nil {
		C.QRubberBand_DestroyQRubberBandDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QRubberBand) Shape() QRubberBand__Shape {
	if ptr.Pointer() != nil {
		return QRubberBand__Shape(C.QRubberBand_Shape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRubberBand) InitStyleOption(option QStyleOptionRubberBand_ITF) {
	if ptr.Pointer() != nil {
		C.QRubberBand_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionRubberBand(option))
	}
}

type QScrollArea struct {
	QAbstractScrollArea
}

type QScrollArea_ITF interface {
	QAbstractScrollArea_ITF
	QScrollArea_PTR() *QScrollArea
}

func (ptr *QScrollArea) QScrollArea_PTR() *QScrollArea {
	return ptr
}

func (ptr *QScrollArea) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractScrollArea_PTR().Pointer()
	}
	return nil
}

func (ptr *QScrollArea) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractScrollArea_PTR().SetPointer(p)
	}
}

func PointerFromQScrollArea(ptr QScrollArea_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScrollArea_PTR().Pointer()
	}
	return nil
}

func NewQScrollAreaFromPointer(ptr unsafe.Pointer) (n *QScrollArea) {
	n = new(QScrollArea)
	n.SetPointer(ptr)
	return
}
func NewQScrollArea(parent QWidget_ITF) *QScrollArea {
	tmpValue := NewQScrollAreaFromPointer(C.QScrollArea_NewQScrollArea(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QScrollArea) TakeWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QScrollArea_TakeWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QScrollArea) EnsureVisible(x int, y int, xmargin int, ymargin int) {
	if ptr.Pointer() != nil {
		C.QScrollArea_EnsureVisible(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)), C.int(int32(xmargin)), C.int(int32(ymargin)))
	}
}

func (ptr *QScrollArea) EnsureWidgetVisible(childWidget QWidget_ITF, xmargin int, ymargin int) {
	if ptr.Pointer() != nil {
		C.QScrollArea_EnsureWidgetVisible(ptr.Pointer(), PointerFromQWidget(childWidget), C.int(int32(xmargin)), C.int(int32(ymargin)))
	}
}

func (ptr *QScrollArea) SetAlignment(vqt core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QScrollArea_SetAlignment(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QScrollArea) SetWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QScrollArea_SetWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QScrollArea) SetWidgetResizable(resizable bool) {
	if ptr.Pointer() != nil {
		C.QScrollArea_SetWidgetResizable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(resizable))))
	}
}

//export callbackQScrollArea_DestroyQScrollArea
func callbackQScrollArea_DestroyQScrollArea(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QScrollArea"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQScrollAreaFromPointer(ptr).DestroyQScrollAreaDefault()
	}
}

func (ptr *QScrollArea) ConnectDestroyQScrollArea(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QScrollArea"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QScrollArea", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QScrollArea", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScrollArea) DisconnectDestroyQScrollArea() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QScrollArea")
	}
}

func (ptr *QScrollArea) DestroyQScrollArea() {
	if ptr.Pointer() != nil {
		C.QScrollArea_DestroyQScrollArea(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QScrollArea) DestroyQScrollAreaDefault() {
	if ptr.Pointer() != nil {
		C.QScrollArea_DestroyQScrollAreaDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QScrollArea) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QScrollArea_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QScrollArea) Alignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QScrollArea_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScrollArea) WidgetResizable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QScrollArea_WidgetResizable(ptr.Pointer())) != 0
	}
	return false
}

type QScrollBar struct {
	QAbstractSlider
}

type QScrollBar_ITF interface {
	QAbstractSlider_ITF
	QScrollBar_PTR() *QScrollBar
}

func (ptr *QScrollBar) QScrollBar_PTR() *QScrollBar {
	return ptr
}

func (ptr *QScrollBar) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractSlider_PTR().Pointer()
	}
	return nil
}

func (ptr *QScrollBar) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractSlider_PTR().SetPointer(p)
	}
}

func PointerFromQScrollBar(ptr QScrollBar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScrollBar_PTR().Pointer()
	}
	return nil
}

func NewQScrollBarFromPointer(ptr unsafe.Pointer) (n *QScrollBar) {
	n = new(QScrollBar)
	n.SetPointer(ptr)
	return
}
func NewQScrollBar(parent QWidget_ITF) *QScrollBar {
	tmpValue := NewQScrollBarFromPointer(C.QScrollBar_NewQScrollBar(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQScrollBar2(orientation core.Qt__Orientation, parent QWidget_ITF) *QScrollBar {
	tmpValue := NewQScrollBarFromPointer(C.QScrollBar_NewQScrollBar2(C.longlong(orientation), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQScrollBar_DestroyQScrollBar
func callbackQScrollBar_DestroyQScrollBar(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QScrollBar"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQScrollBarFromPointer(ptr).DestroyQScrollBarDefault()
	}
}

func (ptr *QScrollBar) ConnectDestroyQScrollBar(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QScrollBar"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QScrollBar", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QScrollBar", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScrollBar) DisconnectDestroyQScrollBar() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QScrollBar")
	}
}

func (ptr *QScrollBar) DestroyQScrollBar() {
	if ptr.Pointer() != nil {
		C.QScrollBar_DestroyQScrollBar(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QScrollBar) DestroyQScrollBarDefault() {
	if ptr.Pointer() != nil {
		C.QScrollBar_DestroyQScrollBarDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QScrollBar) InitStyleOption(option QStyleOptionSlider_ITF) {
	if ptr.Pointer() != nil {
		C.QScrollBar_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionSlider(option))
	}
}

type QScroller struct {
	core.QObject
}

type QScroller_ITF interface {
	core.QObject_ITF
	QScroller_PTR() *QScroller
}

func (ptr *QScroller) QScroller_PTR() *QScroller {
	return ptr
}

func (ptr *QScroller) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QScroller) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQScroller(ptr QScroller_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScroller_PTR().Pointer()
	}
	return nil
}

func NewQScrollerFromPointer(ptr unsafe.Pointer) (n *QScroller) {
	n = new(QScroller)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QScroller__Input
//QScroller::Input
type QScroller__Input int64

const (
	QScroller__InputPress   QScroller__Input = QScroller__Input(1)
	QScroller__InputMove    QScroller__Input = QScroller__Input(2)
	QScroller__InputRelease QScroller__Input = QScroller__Input(3)
)

//go:generate stringer -type=QScroller__ScrollerGestureType
//QScroller::ScrollerGestureType
type QScroller__ScrollerGestureType int64

const (
	QScroller__TouchGesture             QScroller__ScrollerGestureType = QScroller__ScrollerGestureType(0)
	QScroller__LeftMouseButtonGesture   QScroller__ScrollerGestureType = QScroller__ScrollerGestureType(1)
	QScroller__RightMouseButtonGesture  QScroller__ScrollerGestureType = QScroller__ScrollerGestureType(2)
	QScroller__MiddleMouseButtonGesture QScroller__ScrollerGestureType = QScroller__ScrollerGestureType(3)
)

//go:generate stringer -type=QScroller__State
//QScroller::State
type QScroller__State int64

const (
	QScroller__Inactive  QScroller__State = QScroller__State(0)
	QScroller__Pressed   QScroller__State = QScroller__State(1)
	QScroller__Dragging  QScroller__State = QScroller__State(2)
	QScroller__Scrolling QScroller__State = QScroller__State(3)
)

func QScroller_ActiveScrollers() []*QScroller {
	return func(l C.struct_QtWidgets_PackedList) []*QScroller {
		out := make([]*QScroller, int(l.len))
		tmpList := NewQScrollerFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__activeScrollers_atList(i)
		}
		return out
	}(C.QScroller_QScroller_ActiveScrollers())
}

func (ptr *QScroller) ActiveScrollers() []*QScroller {
	return func(l C.struct_QtWidgets_PackedList) []*QScroller {
		out := make([]*QScroller, int(l.len))
		tmpList := NewQScrollerFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__activeScrollers_atList(i)
		}
		return out
	}(C.QScroller_QScroller_ActiveScrollers())
}

func QScroller_Scroller(target core.QObject_ITF) *QScroller {
	tmpValue := NewQScrollerFromPointer(C.QScroller_QScroller_Scroller(core.PointerFromQObject(target)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QScroller) Scroller(target core.QObject_ITF) *QScroller {
	tmpValue := NewQScrollerFromPointer(C.QScroller_QScroller_Scroller(core.PointerFromQObject(target)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QScroller_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QScroller_QScroller_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QScroller) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QScroller_QScroller_Tr(sC, cC, C.int(int32(n))))
}

func QScroller_GrabGesture(target core.QObject_ITF, scrollGestureType QScroller__ScrollerGestureType) core.Qt__GestureType {
	return core.Qt__GestureType(C.QScroller_QScroller_GrabGesture(core.PointerFromQObject(target), C.longlong(scrollGestureType)))
}

func (ptr *QScroller) GrabGesture(target core.QObject_ITF, scrollGestureType QScroller__ScrollerGestureType) core.Qt__GestureType {
	return core.Qt__GestureType(C.QScroller_QScroller_GrabGesture(core.PointerFromQObject(target), C.longlong(scrollGestureType)))
}

func QScroller_GrabbedGesture(target core.QObject_ITF) core.Qt__GestureType {
	return core.Qt__GestureType(C.QScroller_QScroller_GrabbedGesture(core.PointerFromQObject(target)))
}

func (ptr *QScroller) GrabbedGesture(target core.QObject_ITF) core.Qt__GestureType {
	return core.Qt__GestureType(C.QScroller_QScroller_GrabbedGesture(core.PointerFromQObject(target)))
}

func (ptr *QScroller) HandleInput(input QScroller__Input, position core.QPointF_ITF, timestamp int64) bool {
	if ptr.Pointer() != nil {
		return int8(C.QScroller_HandleInput(ptr.Pointer(), C.longlong(input), core.PointerFromQPointF(position), C.longlong(timestamp))) != 0
	}
	return false
}

func QScroller_HasScroller(target core.QObject_ITF) bool {
	return int8(C.QScroller_QScroller_HasScroller(core.PointerFromQObject(target))) != 0
}

func (ptr *QScroller) HasScroller(target core.QObject_ITF) bool {
	return int8(C.QScroller_QScroller_HasScroller(core.PointerFromQObject(target))) != 0
}

func QScroller_Scroller2(target core.QObject_ITF) *QScroller {
	tmpValue := NewQScrollerFromPointer(C.QScroller_QScroller_Scroller2(core.PointerFromQObject(target)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QScroller) Scroller2(target core.QObject_ITF) *QScroller {
	tmpValue := NewQScrollerFromPointer(C.QScroller_QScroller_Scroller2(core.PointerFromQObject(target)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQScroller_EnsureVisible
func callbackQScroller_EnsureVisible(ptr unsafe.Pointer, rect unsafe.Pointer, xmargin C.double, ymargin C.double) {
	if signal := qt.GetSignal(ptr, "ensureVisible"); signal != nil {
		(*(*func(*core.QRectF, float64, float64))(signal))(core.NewQRectFFromPointer(rect), float64(xmargin), float64(ymargin))
	} else {
		NewQScrollerFromPointer(ptr).EnsureVisibleDefault(core.NewQRectFFromPointer(rect), float64(xmargin), float64(ymargin))
	}
}

func (ptr *QScroller) ConnectEnsureVisible(f func(rect *core.QRectF, xmargin float64, ymargin float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "ensureVisible"); signal != nil {
			f := func(rect *core.QRectF, xmargin float64, ymargin float64) {
				(*(*func(*core.QRectF, float64, float64))(signal))(rect, xmargin, ymargin)
				f(rect, xmargin, ymargin)
			}
			qt.ConnectSignal(ptr.Pointer(), "ensureVisible", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "ensureVisible", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScroller) DisconnectEnsureVisible() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "ensureVisible")
	}
}

func (ptr *QScroller) EnsureVisible(rect core.QRectF_ITF, xmargin float64, ymargin float64) {
	if ptr.Pointer() != nil {
		C.QScroller_EnsureVisible(ptr.Pointer(), core.PointerFromQRectF(rect), C.double(xmargin), C.double(ymargin))
	}
}

func (ptr *QScroller) EnsureVisibleDefault(rect core.QRectF_ITF, xmargin float64, ymargin float64) {
	if ptr.Pointer() != nil {
		C.QScroller_EnsureVisibleDefault(ptr.Pointer(), core.PointerFromQRectF(rect), C.double(xmargin), C.double(ymargin))
	}
}

//export callbackQScroller_EnsureVisible2
func callbackQScroller_EnsureVisible2(ptr unsafe.Pointer, rect unsafe.Pointer, xmargin C.double, ymargin C.double, scrollTime C.int) {
	if signal := qt.GetSignal(ptr, "ensureVisible2"); signal != nil {
		(*(*func(*core.QRectF, float64, float64, int))(signal))(core.NewQRectFFromPointer(rect), float64(xmargin), float64(ymargin), int(int32(scrollTime)))
	} else {
		NewQScrollerFromPointer(ptr).EnsureVisible2Default(core.NewQRectFFromPointer(rect), float64(xmargin), float64(ymargin), int(int32(scrollTime)))
	}
}

func (ptr *QScroller) ConnectEnsureVisible2(f func(rect *core.QRectF, xmargin float64, ymargin float64, scrollTime int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "ensureVisible2"); signal != nil {
			f := func(rect *core.QRectF, xmargin float64, ymargin float64, scrollTime int) {
				(*(*func(*core.QRectF, float64, float64, int))(signal))(rect, xmargin, ymargin, scrollTime)
				f(rect, xmargin, ymargin, scrollTime)
			}
			qt.ConnectSignal(ptr.Pointer(), "ensureVisible2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "ensureVisible2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScroller) DisconnectEnsureVisible2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "ensureVisible2")
	}
}

func (ptr *QScroller) EnsureVisible2(rect core.QRectF_ITF, xmargin float64, ymargin float64, scrollTime int) {
	if ptr.Pointer() != nil {
		C.QScroller_EnsureVisible2(ptr.Pointer(), core.PointerFromQRectF(rect), C.double(xmargin), C.double(ymargin), C.int(int32(scrollTime)))
	}
}

func (ptr *QScroller) EnsureVisible2Default(rect core.QRectF_ITF, xmargin float64, ymargin float64, scrollTime int) {
	if ptr.Pointer() != nil {
		C.QScroller_EnsureVisible2Default(ptr.Pointer(), core.PointerFromQRectF(rect), C.double(xmargin), C.double(ymargin), C.int(int32(scrollTime)))
	}
}

//export callbackQScroller_ResendPrepareEvent
func callbackQScroller_ResendPrepareEvent(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resendPrepareEvent"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQScrollerFromPointer(ptr).ResendPrepareEventDefault()
	}
}

func (ptr *QScroller) ConnectResendPrepareEvent(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resendPrepareEvent"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "resendPrepareEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resendPrepareEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScroller) DisconnectResendPrepareEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resendPrepareEvent")
	}
}

func (ptr *QScroller) ResendPrepareEvent() {
	if ptr.Pointer() != nil {
		C.QScroller_ResendPrepareEvent(ptr.Pointer())
	}
}

func (ptr *QScroller) ResendPrepareEventDefault() {
	if ptr.Pointer() != nil {
		C.QScroller_ResendPrepareEventDefault(ptr.Pointer())
	}
}

//export callbackQScroller_ScrollTo
func callbackQScroller_ScrollTo(ptr unsafe.Pointer, pos unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "scrollTo"); signal != nil {
		(*(*func(*core.QPointF))(signal))(core.NewQPointFFromPointer(pos))
	} else {
		NewQScrollerFromPointer(ptr).ScrollToDefault(core.NewQPointFFromPointer(pos))
	}
}

func (ptr *QScroller) ConnectScrollTo(f func(pos *core.QPointF)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "scrollTo"); signal != nil {
			f := func(pos *core.QPointF) {
				(*(*func(*core.QPointF))(signal))(pos)
				f(pos)
			}
			qt.ConnectSignal(ptr.Pointer(), "scrollTo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scrollTo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScroller) DisconnectScrollTo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "scrollTo")
	}
}

func (ptr *QScroller) ScrollTo(pos core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_ScrollTo(ptr.Pointer(), core.PointerFromQPointF(pos))
	}
}

func (ptr *QScroller) ScrollToDefault(pos core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_ScrollToDefault(ptr.Pointer(), core.PointerFromQPointF(pos))
	}
}

//export callbackQScroller_ScrollTo2
func callbackQScroller_ScrollTo2(ptr unsafe.Pointer, pos unsafe.Pointer, scrollTime C.int) {
	if signal := qt.GetSignal(ptr, "scrollTo2"); signal != nil {
		(*(*func(*core.QPointF, int))(signal))(core.NewQPointFFromPointer(pos), int(int32(scrollTime)))
	} else {
		NewQScrollerFromPointer(ptr).ScrollTo2Default(core.NewQPointFFromPointer(pos), int(int32(scrollTime)))
	}
}

func (ptr *QScroller) ConnectScrollTo2(f func(pos *core.QPointF, scrollTime int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "scrollTo2"); signal != nil {
			f := func(pos *core.QPointF, scrollTime int) {
				(*(*func(*core.QPointF, int))(signal))(pos, scrollTime)
				f(pos, scrollTime)
			}
			qt.ConnectSignal(ptr.Pointer(), "scrollTo2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scrollTo2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScroller) DisconnectScrollTo2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "scrollTo2")
	}
}

func (ptr *QScroller) ScrollTo2(pos core.QPointF_ITF, scrollTime int) {
	if ptr.Pointer() != nil {
		C.QScroller_ScrollTo2(ptr.Pointer(), core.PointerFromQPointF(pos), C.int(int32(scrollTime)))
	}
}

func (ptr *QScroller) ScrollTo2Default(pos core.QPointF_ITF, scrollTime int) {
	if ptr.Pointer() != nil {
		C.QScroller_ScrollTo2Default(ptr.Pointer(), core.PointerFromQPointF(pos), C.int(int32(scrollTime)))
	}
}

//export callbackQScroller_ScrollerPropertiesChanged
func callbackQScroller_ScrollerPropertiesChanged(ptr unsafe.Pointer, newProperties unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "scrollerPropertiesChanged"); signal != nil {
		(*(*func(*QScrollerProperties))(signal))(NewQScrollerPropertiesFromPointer(newProperties))
	}

}

func (ptr *QScroller) ConnectScrollerPropertiesChanged(f func(newProperties *QScrollerProperties)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "scrollerPropertiesChanged") {
			C.QScroller_ConnectScrollerPropertiesChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "scrollerPropertiesChanged"); signal != nil {
			f := func(newProperties *QScrollerProperties) {
				(*(*func(*QScrollerProperties))(signal))(newProperties)
				f(newProperties)
			}
			qt.ConnectSignal(ptr.Pointer(), "scrollerPropertiesChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scrollerPropertiesChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScroller) DisconnectScrollerPropertiesChanged() {
	if ptr.Pointer() != nil {
		C.QScroller_DisconnectScrollerPropertiesChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "scrollerPropertiesChanged")
	}
}

func (ptr *QScroller) ScrollerPropertiesChanged(newProperties QScrollerProperties_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_ScrollerPropertiesChanged(ptr.Pointer(), PointerFromQScrollerProperties(newProperties))
	}
}

//export callbackQScroller_SetScrollerProperties
func callbackQScroller_SetScrollerProperties(ptr unsafe.Pointer, prop unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setScrollerProperties"); signal != nil {
		(*(*func(*QScrollerProperties))(signal))(NewQScrollerPropertiesFromPointer(prop))
	} else {
		NewQScrollerFromPointer(ptr).SetScrollerPropertiesDefault(NewQScrollerPropertiesFromPointer(prop))
	}
}

func (ptr *QScroller) ConnectSetScrollerProperties(f func(prop *QScrollerProperties)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setScrollerProperties"); signal != nil {
			f := func(prop *QScrollerProperties) {
				(*(*func(*QScrollerProperties))(signal))(prop)
				f(prop)
			}
			qt.ConnectSignal(ptr.Pointer(), "setScrollerProperties", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setScrollerProperties", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScroller) DisconnectSetScrollerProperties() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setScrollerProperties")
	}
}

func (ptr *QScroller) SetScrollerProperties(prop QScrollerProperties_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_SetScrollerProperties(ptr.Pointer(), PointerFromQScrollerProperties(prop))
	}
}

func (ptr *QScroller) SetScrollerPropertiesDefault(prop QScrollerProperties_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_SetScrollerPropertiesDefault(ptr.Pointer(), PointerFromQScrollerProperties(prop))
	}
}

func (ptr *QScroller) SetSnapPositionsX(positions []float64) {
	if ptr.Pointer() != nil {
		C.QScroller_SetSnapPositionsX(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQScrollerFromPointer(NewQScrollerFromPointer(nil).__setSnapPositionsX_positions_newList())
			for _, v := range positions {
				tmpList.__setSnapPositionsX_positions_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QScroller) SetSnapPositionsX2(first float64, interval float64) {
	if ptr.Pointer() != nil {
		C.QScroller_SetSnapPositionsX2(ptr.Pointer(), C.double(first), C.double(interval))
	}
}

func (ptr *QScroller) SetSnapPositionsY(positions []float64) {
	if ptr.Pointer() != nil {
		C.QScroller_SetSnapPositionsY(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQScrollerFromPointer(NewQScrollerFromPointer(nil).__setSnapPositionsY_positions_newList())
			for _, v := range positions {
				tmpList.__setSnapPositionsY_positions_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QScroller) SetSnapPositionsY2(first float64, interval float64) {
	if ptr.Pointer() != nil {
		C.QScroller_SetSnapPositionsY2(ptr.Pointer(), C.double(first), C.double(interval))
	}
}

//export callbackQScroller_StateChanged
func callbackQScroller_StateChanged(ptr unsafe.Pointer, newState C.longlong) {
	if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
		(*(*func(QScroller__State))(signal))(QScroller__State(newState))
	}

}

func (ptr *QScroller) ConnectStateChanged(f func(newState QScroller__State)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
			C.QScroller_ConnectStateChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
			f := func(newState QScroller__State) {
				(*(*func(QScroller__State))(signal))(newState)
				f(newState)
			}
			qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScroller) DisconnectStateChanged() {
	if ptr.Pointer() != nil {
		C.QScroller_DisconnectStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
	}
}

func (ptr *QScroller) StateChanged(newState QScroller__State) {
	if ptr.Pointer() != nil {
		C.QScroller_StateChanged(ptr.Pointer(), C.longlong(newState))
	}
}

func (ptr *QScroller) Stop() {
	if ptr.Pointer() != nil {
		C.QScroller_Stop(ptr.Pointer())
	}
}

func QScroller_UngrabGesture(target core.QObject_ITF) {
	C.QScroller_QScroller_UngrabGesture(core.PointerFromQObject(target))
}

func (ptr *QScroller) UngrabGesture(target core.QObject_ITF) {
	C.QScroller_QScroller_UngrabGesture(core.PointerFromQObject(target))
}

func (ptr *QScroller) Target() *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QScroller_Target(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) FinalPosition() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QScroller_FinalPosition(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) PixelPerMeter() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QScroller_PixelPerMeter(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) Velocity() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QScroller_Velocity(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) State() QScroller__State {
	if ptr.Pointer() != nil {
		return QScroller__State(C.QScroller_State(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScroller) ScrollerProperties() *QScrollerProperties {
	if ptr.Pointer() != nil {
		tmpValue := NewQScrollerPropertiesFromPointer(C.QScroller_ScrollerProperties(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QScrollerProperties).DestroyQScrollerProperties)
		return tmpValue
	}
	return nil
}

//export callbackQScroller_MetaObject
func callbackQScroller_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQScrollerFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QScroller) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QScroller_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QScroller) __activeScrollers_atList(i int) *QScroller {
	if ptr.Pointer() != nil {
		tmpValue := NewQScrollerFromPointer(C.QScroller___activeScrollers_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) __activeScrollers_setList(i QScroller_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller___activeScrollers_setList(ptr.Pointer(), PointerFromQScroller(i))
	}
}

func (ptr *QScroller) __activeScrollers_newList() unsafe.Pointer {
	return C.QScroller___activeScrollers_newList(ptr.Pointer())
}

func (ptr *QScroller) __setSnapPositionsX_positions_atList(i int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QScroller___setSnapPositionsX_positions_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return 0
}

func (ptr *QScroller) __setSnapPositionsX_positions_setList(i float64) {
	if ptr.Pointer() != nil {
		C.QScroller___setSnapPositionsX_positions_setList(ptr.Pointer(), C.double(i))
	}
}

func (ptr *QScroller) __setSnapPositionsX_positions_newList() unsafe.Pointer {
	return C.QScroller___setSnapPositionsX_positions_newList(ptr.Pointer())
}

func (ptr *QScroller) __setSnapPositionsY_positions_atList(i int) float64 {
	if ptr.Pointer() != nil {
		return float64(C.QScroller___setSnapPositionsY_positions_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return 0
}

func (ptr *QScroller) __setSnapPositionsY_positions_setList(i float64) {
	if ptr.Pointer() != nil {
		C.QScroller___setSnapPositionsY_positions_setList(ptr.Pointer(), C.double(i))
	}
}

func (ptr *QScroller) __setSnapPositionsY_positions_newList() unsafe.Pointer {
	return C.QScroller___setSnapPositionsY_positions_newList(ptr.Pointer())
}

func (ptr *QScroller) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QScroller___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QScroller) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QScroller___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QScroller) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QScroller___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QScroller) __findChildren_newList2() unsafe.Pointer {
	return C.QScroller___findChildren_newList2(ptr.Pointer())
}

func (ptr *QScroller) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QScroller___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QScroller) __findChildren_newList3() unsafe.Pointer {
	return C.QScroller___findChildren_newList3(ptr.Pointer())
}

func (ptr *QScroller) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QScroller___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QScroller) __findChildren_newList() unsafe.Pointer {
	return C.QScroller___findChildren_newList(ptr.Pointer())
}

func (ptr *QScroller) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QScroller___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QScroller) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QScroller) __children_newList() unsafe.Pointer {
	return C.QScroller___children_newList(ptr.Pointer())
}

//export callbackQScroller_Event
func callbackQScroller_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQScrollerFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QScroller) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QScroller_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQScroller_EventFilter
func callbackQScroller_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQScrollerFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QScroller) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QScroller_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQScroller_ChildEvent
func callbackQScroller_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQScrollerFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QScroller) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQScroller_ConnectNotify
func callbackQScroller_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQScrollerFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QScroller) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQScroller_CustomEvent
func callbackQScroller_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQScrollerFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QScroller) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQScroller_DeleteLater
func callbackQScroller_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQScrollerFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QScroller) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QScroller_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQScroller_Destroyed
func callbackQScroller_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQScroller_DisconnectNotify
func callbackQScroller_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQScrollerFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QScroller) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQScroller_ObjectNameChanged
func callbackQScroller_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQScroller_TimerEvent
func callbackQScroller_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQScrollerFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QScroller) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QScroller_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QScrollerProperties struct {
	ptr unsafe.Pointer
}

type QScrollerProperties_ITF interface {
	QScrollerProperties_PTR() *QScrollerProperties
}

func (ptr *QScrollerProperties) QScrollerProperties_PTR() *QScrollerProperties {
	return ptr
}

func (ptr *QScrollerProperties) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QScrollerProperties) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQScrollerProperties(ptr QScrollerProperties_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScrollerProperties_PTR().Pointer()
	}
	return nil
}

func NewQScrollerPropertiesFromPointer(ptr unsafe.Pointer) (n *QScrollerProperties) {
	n = new(QScrollerProperties)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QScrollerProperties__FrameRates
//QScrollerProperties::FrameRates
type QScrollerProperties__FrameRates int64

const (
	QScrollerProperties__Standard QScrollerProperties__FrameRates = QScrollerProperties__FrameRates(0)
	QScrollerProperties__Fps60    QScrollerProperties__FrameRates = QScrollerProperties__FrameRates(1)
	QScrollerProperties__Fps30    QScrollerProperties__FrameRates = QScrollerProperties__FrameRates(2)
	QScrollerProperties__Fps20    QScrollerProperties__FrameRates = QScrollerProperties__FrameRates(3)
)

//go:generate stringer -type=QScrollerProperties__OvershootPolicy
//QScrollerProperties::OvershootPolicy
type QScrollerProperties__OvershootPolicy int64

const (
	QScrollerProperties__OvershootWhenScrollable QScrollerProperties__OvershootPolicy = QScrollerProperties__OvershootPolicy(0)
	QScrollerProperties__OvershootAlwaysOff      QScrollerProperties__OvershootPolicy = QScrollerProperties__OvershootPolicy(1)
	QScrollerProperties__OvershootAlwaysOn       QScrollerProperties__OvershootPolicy = QScrollerProperties__OvershootPolicy(2)
)

//go:generate stringer -type=QScrollerProperties__ScrollMetric
//QScrollerProperties::ScrollMetric
type QScrollerProperties__ScrollMetric int64

const (
	QScrollerProperties__MousePressEventDelay           QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(0)
	QScrollerProperties__DragStartDistance              QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(1)
	QScrollerProperties__DragVelocitySmoothingFactor    QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(2)
	QScrollerProperties__AxisLockThreshold              QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(3)
	QScrollerProperties__ScrollingCurve                 QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(4)
	QScrollerProperties__DecelerationFactor             QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(5)
	QScrollerProperties__MinimumVelocity                QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(6)
	QScrollerProperties__MaximumVelocity                QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(7)
	QScrollerProperties__MaximumClickThroughVelocity    QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(8)
	QScrollerProperties__AcceleratingFlickMaximumTime   QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(9)
	QScrollerProperties__AcceleratingFlickSpeedupFactor QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(10)
	QScrollerProperties__SnapPositionRatio              QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(11)
	QScrollerProperties__SnapTime                       QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(12)
	QScrollerProperties__OvershootDragResistanceFactor  QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(13)
	QScrollerProperties__OvershootDragDistanceFactor    QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(14)
	QScrollerProperties__OvershootScrollDistanceFactor  QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(15)
	QScrollerProperties__OvershootScrollTime            QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(16)
	QScrollerProperties__HorizontalOvershootPolicy      QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(17)
	QScrollerProperties__VerticalOvershootPolicy        QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(18)
	QScrollerProperties__FrameRate                      QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(19)
	QScrollerProperties__ScrollMetricCount              QScrollerProperties__ScrollMetric = QScrollerProperties__ScrollMetric(20)
)

func NewQScrollerProperties() *QScrollerProperties {
	tmpValue := NewQScrollerPropertiesFromPointer(C.QScrollerProperties_NewQScrollerProperties())
	runtime.SetFinalizer(tmpValue, (*QScrollerProperties).DestroyQScrollerProperties)
	return tmpValue
}

func NewQScrollerProperties2(sp QScrollerProperties_ITF) *QScrollerProperties {
	tmpValue := NewQScrollerPropertiesFromPointer(C.QScrollerProperties_NewQScrollerProperties2(PointerFromQScrollerProperties(sp)))
	runtime.SetFinalizer(tmpValue, (*QScrollerProperties).DestroyQScrollerProperties)
	return tmpValue
}

func QScrollerProperties_SetDefaultScrollerProperties(sp QScrollerProperties_ITF) {
	C.QScrollerProperties_QScrollerProperties_SetDefaultScrollerProperties(PointerFromQScrollerProperties(sp))
}

func (ptr *QScrollerProperties) SetDefaultScrollerProperties(sp QScrollerProperties_ITF) {
	C.QScrollerProperties_QScrollerProperties_SetDefaultScrollerProperties(PointerFromQScrollerProperties(sp))
}

func (ptr *QScrollerProperties) SetScrollMetric(metric QScrollerProperties__ScrollMetric, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QScrollerProperties_SetScrollMetric(ptr.Pointer(), C.longlong(metric), core.PointerFromQVariant(value))
	}
}

func QScrollerProperties_UnsetDefaultScrollerProperties() {
	C.QScrollerProperties_QScrollerProperties_UnsetDefaultScrollerProperties()
}

func (ptr *QScrollerProperties) UnsetDefaultScrollerProperties() {
	C.QScrollerProperties_QScrollerProperties_UnsetDefaultScrollerProperties()
}

//export callbackQScrollerProperties_DestroyQScrollerProperties
func callbackQScrollerProperties_DestroyQScrollerProperties(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QScrollerProperties"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQScrollerPropertiesFromPointer(ptr).DestroyQScrollerPropertiesDefault()
	}
}

func (ptr *QScrollerProperties) ConnectDestroyQScrollerProperties(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QScrollerProperties"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QScrollerProperties", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QScrollerProperties", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QScrollerProperties) DisconnectDestroyQScrollerProperties() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QScrollerProperties")
	}
}

func (ptr *QScrollerProperties) DestroyQScrollerProperties() {
	if ptr.Pointer() != nil {
		C.QScrollerProperties_DestroyQScrollerProperties(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QScrollerProperties) DestroyQScrollerPropertiesDefault() {
	if ptr.Pointer() != nil {
		C.QScrollerProperties_DestroyQScrollerPropertiesDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QScrollerProperties) ScrollMetric(metric QScrollerProperties__ScrollMetric) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QScrollerProperties_ScrollMetric(ptr.Pointer(), C.longlong(metric)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

type QShortcut struct {
	core.QObject
}

type QShortcut_ITF interface {
	core.QObject_ITF
	QShortcut_PTR() *QShortcut
}

func (ptr *QShortcut) QShortcut_PTR() *QShortcut {
	return ptr
}

func (ptr *QShortcut) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QShortcut) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQShortcut(ptr QShortcut_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QShortcut_PTR().Pointer()
	}
	return nil
}

func NewQShortcutFromPointer(ptr unsafe.Pointer) (n *QShortcut) {
	n = new(QShortcut)
	n.SetPointer(ptr)
	return
}
func NewQShortcut(parent QWidget_ITF) *QShortcut {
	tmpValue := NewQShortcutFromPointer(C.QShortcut_NewQShortcut(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQShortcut2(key gui.QKeySequence_ITF, parent QWidget_ITF, member string, ambiguousMember string, context core.Qt__ShortcutContext) *QShortcut {
	var memberC *C.char
	if member != "" {
		memberC = C.CString(member)
		defer C.free(unsafe.Pointer(memberC))
	}
	var ambiguousMemberC *C.char
	if ambiguousMember != "" {
		ambiguousMemberC = C.CString(ambiguousMember)
		defer C.free(unsafe.Pointer(ambiguousMemberC))
	}
	tmpValue := NewQShortcutFromPointer(C.QShortcut_NewQShortcut2(gui.PointerFromQKeySequence(key), PointerFromQWidget(parent), memberC, ambiguousMemberC, C.longlong(context)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QShortcut_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QShortcut_QShortcut_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QShortcut) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QShortcut_QShortcut_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQShortcut_Activated
func callbackQShortcut_Activated(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "activated"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QShortcut) ConnectActivated(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activated") {
			C.QShortcut_ConnectActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "activated"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "activated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "activated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QShortcut) DisconnectActivated() {
	if ptr.Pointer() != nil {
		C.QShortcut_DisconnectActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activated")
	}
}

func (ptr *QShortcut) Activated() {
	if ptr.Pointer() != nil {
		C.QShortcut_Activated(ptr.Pointer())
	}
}

//export callbackQShortcut_ActivatedAmbiguously
func callbackQShortcut_ActivatedAmbiguously(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "activatedAmbiguously"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QShortcut) ConnectActivatedAmbiguously(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activatedAmbiguously") {
			C.QShortcut_ConnectActivatedAmbiguously(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "activatedAmbiguously"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "activatedAmbiguously", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "activatedAmbiguously", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QShortcut) DisconnectActivatedAmbiguously() {
	if ptr.Pointer() != nil {
		C.QShortcut_DisconnectActivatedAmbiguously(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activatedAmbiguously")
	}
}

func (ptr *QShortcut) ActivatedAmbiguously() {
	if ptr.Pointer() != nil {
		C.QShortcut_ActivatedAmbiguously(ptr.Pointer())
	}
}

func (ptr *QShortcut) SetAutoRepeat(on bool) {
	if ptr.Pointer() != nil {
		C.QShortcut_SetAutoRepeat(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QShortcut) SetContext(context core.Qt__ShortcutContext) {
	if ptr.Pointer() != nil {
		C.QShortcut_SetContext(ptr.Pointer(), C.longlong(context))
	}
}

func (ptr *QShortcut) SetEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QShortcut_SetEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QShortcut) SetKey(key gui.QKeySequence_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut_SetKey(ptr.Pointer(), gui.PointerFromQKeySequence(key))
	}
}

func (ptr *QShortcut) SetWhatsThis(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QShortcut_SetWhatsThis(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQShortcut_DestroyQShortcut
func callbackQShortcut_DestroyQShortcut(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QShortcut"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQShortcutFromPointer(ptr).DestroyQShortcutDefault()
	}
}

func (ptr *QShortcut) ConnectDestroyQShortcut(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QShortcut"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QShortcut", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QShortcut", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QShortcut) DisconnectDestroyQShortcut() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QShortcut")
	}
}

func (ptr *QShortcut) DestroyQShortcut() {
	if ptr.Pointer() != nil {
		C.QShortcut_DestroyQShortcut(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QShortcut) DestroyQShortcutDefault() {
	if ptr.Pointer() != nil {
		C.QShortcut_DestroyQShortcutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QShortcut) Key() *gui.QKeySequence {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQKeySequenceFromPointer(C.QShortcut_Key(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QKeySequence).DestroyQKeySequence)
		return tmpValue
	}
	return nil
}

func (ptr *QShortcut) WhatsThis() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QShortcut_WhatsThis(ptr.Pointer()))
	}
	return ""
}

func (ptr *QShortcut) ParentWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QShortcut_ParentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QShortcut) Context() core.Qt__ShortcutContext {
	if ptr.Pointer() != nil {
		return core.Qt__ShortcutContext(C.QShortcut_Context(ptr.Pointer()))
	}
	return 0
}

func (ptr *QShortcut) AutoRepeat() bool {
	if ptr.Pointer() != nil {
		return int8(C.QShortcut_AutoRepeat(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QShortcut) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QShortcut_IsEnabled(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQShortcut_MetaObject
func callbackQShortcut_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQShortcutFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QShortcut) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QShortcut_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QShortcut) Id() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QShortcut_Id(ptr.Pointer())))
	}
	return 0
}

func (ptr *QShortcut) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QShortcut___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QShortcut) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QShortcut) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QShortcut___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QShortcut) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QShortcut___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QShortcut) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QShortcut) __findChildren_newList2() unsafe.Pointer {
	return C.QShortcut___findChildren_newList2(ptr.Pointer())
}

func (ptr *QShortcut) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QShortcut___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QShortcut) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QShortcut) __findChildren_newList3() unsafe.Pointer {
	return C.QShortcut___findChildren_newList3(ptr.Pointer())
}

func (ptr *QShortcut) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QShortcut___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QShortcut) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QShortcut) __findChildren_newList() unsafe.Pointer {
	return C.QShortcut___findChildren_newList(ptr.Pointer())
}

func (ptr *QShortcut) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QShortcut___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QShortcut) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QShortcut) __children_newList() unsafe.Pointer {
	return C.QShortcut___children_newList(ptr.Pointer())
}

//export callbackQShortcut_Event
func callbackQShortcut_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQShortcutFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QShortcut) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QShortcut_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQShortcut_EventFilter
func callbackQShortcut_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQShortcutFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QShortcut) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QShortcut_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQShortcut_ChildEvent
func callbackQShortcut_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQShortcutFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QShortcut) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQShortcut_ConnectNotify
func callbackQShortcut_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQShortcutFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QShortcut) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQShortcut_CustomEvent
func callbackQShortcut_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQShortcutFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QShortcut) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQShortcut_DeleteLater
func callbackQShortcut_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQShortcutFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QShortcut) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QShortcut_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQShortcut_Destroyed
func callbackQShortcut_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQShortcut_DisconnectNotify
func callbackQShortcut_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQShortcutFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QShortcut) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQShortcut_ObjectNameChanged
func callbackQShortcut_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQShortcut_TimerEvent
func callbackQShortcut_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQShortcutFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QShortcut) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QShortcut_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QSizeGrip struct {
	QWidget
}

type QSizeGrip_ITF interface {
	QWidget_ITF
	QSizeGrip_PTR() *QSizeGrip
}

func (ptr *QSizeGrip) QSizeGrip_PTR() *QSizeGrip {
	return ptr
}

func (ptr *QSizeGrip) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QSizeGrip) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQSizeGrip(ptr QSizeGrip_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSizeGrip_PTR().Pointer()
	}
	return nil
}

func NewQSizeGripFromPointer(ptr unsafe.Pointer) (n *QSizeGrip) {
	n = new(QSizeGrip)
	n.SetPointer(ptr)
	return
}
func NewQSizeGrip(parent QWidget_ITF) *QSizeGrip {
	tmpValue := NewQSizeGripFromPointer(C.QSizeGrip_NewQSizeGrip(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQSizeGrip_SetVisible
func callbackQSizeGrip_SetVisible(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(ptr, "setVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(visible) != 0)
	} else {
		NewQSizeGripFromPointer(ptr).SetVisibleDefault(int8(visible) != 0)
	}
}

func (ptr *QSizeGrip) ConnectSetVisible(f func(visible bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setVisible"); signal != nil {
			f := func(visible bool) {
				(*(*func(bool))(signal))(visible)
				f(visible)
			}
			qt.ConnectSignal(ptr.Pointer(), "setVisible", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setVisible", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSizeGrip) DisconnectSetVisible() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setVisible")
	}
}

func (ptr *QSizeGrip) SetVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QSizeGrip_SetVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QSizeGrip) SetVisibleDefault(visible bool) {
	if ptr.Pointer() != nil {
		C.QSizeGrip_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQSizeGrip_DestroyQSizeGrip
func callbackQSizeGrip_DestroyQSizeGrip(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSizeGrip"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSizeGripFromPointer(ptr).DestroyQSizeGripDefault()
	}
}

func (ptr *QSizeGrip) ConnectDestroyQSizeGrip(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSizeGrip"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSizeGrip", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSizeGrip", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSizeGrip) DisconnectDestroyQSizeGrip() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSizeGrip")
	}
}

func (ptr *QSizeGrip) DestroyQSizeGrip() {
	if ptr.Pointer() != nil {
		C.QSizeGrip_DestroyQSizeGrip(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSizeGrip) DestroyQSizeGripDefault() {
	if ptr.Pointer() != nil {
		C.QSizeGrip_DestroyQSizeGripDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QSizePolicy struct {
	ptr unsafe.Pointer
}

type QSizePolicy_ITF interface {
	QSizePolicy_PTR() *QSizePolicy
}

func (ptr *QSizePolicy) QSizePolicy_PTR() *QSizePolicy {
	return ptr
}

func (ptr *QSizePolicy) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QSizePolicy) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQSizePolicy(ptr QSizePolicy_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSizePolicy_PTR().Pointer()
	}
	return nil
}

func NewQSizePolicyFromPointer(ptr unsafe.Pointer) (n *QSizePolicy) {
	n = new(QSizePolicy)
	n.SetPointer(ptr)
	return
}

func (ptr *QSizePolicy) DestroyQSizePolicy() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QSizePolicy__ControlType
//QSizePolicy::ControlType
type QSizePolicy__ControlType int64

const (
	QSizePolicy__DefaultType QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000001)
	QSizePolicy__ButtonBox   QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000002)
	QSizePolicy__CheckBox    QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000004)
	QSizePolicy__ComboBox    QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000008)
	QSizePolicy__Frame       QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000010)
	QSizePolicy__GroupBox    QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000020)
	QSizePolicy__Label       QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000040)
	QSizePolicy__Line        QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000080)
	QSizePolicy__LineEdit    QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000100)
	QSizePolicy__PushButton  QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000200)
	QSizePolicy__RadioButton QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000400)
	QSizePolicy__Slider      QSizePolicy__ControlType = QSizePolicy__ControlType(0x00000800)
	QSizePolicy__SpinBox     QSizePolicy__ControlType = QSizePolicy__ControlType(0x00001000)
	QSizePolicy__TabWidget   QSizePolicy__ControlType = QSizePolicy__ControlType(0x00002000)
	QSizePolicy__ToolButton  QSizePolicy__ControlType = QSizePolicy__ControlType(0x00004000)
)

//go:generate stringer -type=QSizePolicy__Policy
//QSizePolicy::Policy
type QSizePolicy__Policy int64

const (
	QSizePolicy__Fixed            QSizePolicy__Policy = QSizePolicy__Policy(0)
	QSizePolicy__Minimum          QSizePolicy__Policy = QSizePolicy__Policy(QSizePolicy__GrowFlag)
	QSizePolicy__Maximum          QSizePolicy__Policy = QSizePolicy__Policy(QSizePolicy__ShrinkFlag)
	QSizePolicy__Preferred        QSizePolicy__Policy = QSizePolicy__Policy(QSizePolicy__GrowFlag | QSizePolicy__ShrinkFlag)
	QSizePolicy__MinimumExpanding QSizePolicy__Policy = QSizePolicy__Policy(QSizePolicy__GrowFlag | QSizePolicy__ExpandFlag)
	QSizePolicy__Expanding        QSizePolicy__Policy = QSizePolicy__Policy(QSizePolicy__GrowFlag | QSizePolicy__ShrinkFlag | QSizePolicy__ExpandFlag)
	QSizePolicy__Ignored          QSizePolicy__Policy = QSizePolicy__Policy(QSizePolicy__ShrinkFlag | QSizePolicy__GrowFlag | QSizePolicy__IgnoreFlag)
)

//go:generate stringer -type=QSizePolicy__PolicyFlag
//QSizePolicy::PolicyFlag
type QSizePolicy__PolicyFlag int64

const (
	QSizePolicy__GrowFlag   QSizePolicy__PolicyFlag = QSizePolicy__PolicyFlag(1)
	QSizePolicy__ExpandFlag QSizePolicy__PolicyFlag = QSizePolicy__PolicyFlag(2)
	QSizePolicy__ShrinkFlag QSizePolicy__PolicyFlag = QSizePolicy__PolicyFlag(4)
	QSizePolicy__IgnoreFlag QSizePolicy__PolicyFlag = QSizePolicy__PolicyFlag(8)
)

func NewQSizePolicy() *QSizePolicy {
	tmpValue := NewQSizePolicyFromPointer(C.QSizePolicy_NewQSizePolicy())
	runtime.SetFinalizer(tmpValue, (*QSizePolicy).DestroyQSizePolicy)
	return tmpValue
}

func NewQSizePolicy2(horizontal QSizePolicy__Policy, vertical QSizePolicy__Policy, ty QSizePolicy__ControlType) *QSizePolicy {
	tmpValue := NewQSizePolicyFromPointer(C.QSizePolicy_NewQSizePolicy2(C.longlong(horizontal), C.longlong(vertical), C.longlong(ty)))
	runtime.SetFinalizer(tmpValue, (*QSizePolicy).DestroyQSizePolicy)
	return tmpValue
}

func (ptr *QSizePolicy) SetControlType(ty QSizePolicy__ControlType) {
	if ptr.Pointer() != nil {
		C.QSizePolicy_SetControlType(ptr.Pointer(), C.longlong(ty))
	}
}

func (ptr *QSizePolicy) SetHeightForWidth(dependent bool) {
	if ptr.Pointer() != nil {
		C.QSizePolicy_SetHeightForWidth(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(dependent))))
	}
}

func (ptr *QSizePolicy) SetHorizontalPolicy(policy QSizePolicy__Policy) {
	if ptr.Pointer() != nil {
		C.QSizePolicy_SetHorizontalPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QSizePolicy) SetHorizontalStretch(stretchFactor int) {
	if ptr.Pointer() != nil {
		C.QSizePolicy_SetHorizontalStretch(ptr.Pointer(), C.int(int32(stretchFactor)))
	}
}

func (ptr *QSizePolicy) SetRetainSizeWhenHidden(retainSize bool) {
	if ptr.Pointer() != nil {
		C.QSizePolicy_SetRetainSizeWhenHidden(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(retainSize))))
	}
}

func (ptr *QSizePolicy) SetVerticalPolicy(policy QSizePolicy__Policy) {
	if ptr.Pointer() != nil {
		C.QSizePolicy_SetVerticalPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QSizePolicy) SetVerticalStretch(stretchFactor int) {
	if ptr.Pointer() != nil {
		C.QSizePolicy_SetVerticalStretch(ptr.Pointer(), C.int(int32(stretchFactor)))
	}
}

func (ptr *QSizePolicy) SetWidthForHeight(dependent bool) {
	if ptr.Pointer() != nil {
		C.QSizePolicy_SetWidthForHeight(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(dependent))))
	}
}

func (ptr *QSizePolicy) Transpose() {
	if ptr.Pointer() != nil {
		C.QSizePolicy_Transpose(ptr.Pointer())
	}
}

func (ptr *QSizePolicy) Transposed() *QSizePolicy {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizePolicyFromPointer(C.QSizePolicy_Transposed(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSizePolicy).DestroyQSizePolicy)
		return tmpValue
	}
	return nil
}

func (ptr *QSizePolicy) ControlType() QSizePolicy__ControlType {
	if ptr.Pointer() != nil {
		return QSizePolicy__ControlType(C.QSizePolicy_ControlType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSizePolicy) HorizontalPolicy() QSizePolicy__Policy {
	if ptr.Pointer() != nil {
		return QSizePolicy__Policy(C.QSizePolicy_HorizontalPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSizePolicy) VerticalPolicy() QSizePolicy__Policy {
	if ptr.Pointer() != nil {
		return QSizePolicy__Policy(C.QSizePolicy_VerticalPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSizePolicy) ExpandingDirections() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QSizePolicy_ExpandingDirections(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSizePolicy) HasHeightForWidth() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSizePolicy_HasHeightForWidth(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSizePolicy) HasWidthForHeight() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSizePolicy_HasWidthForHeight(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSizePolicy) RetainSizeWhenHidden() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSizePolicy_RetainSizeWhenHidden(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSizePolicy) HorizontalStretch() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSizePolicy_HorizontalStretch(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSizePolicy) VerticalStretch() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSizePolicy_VerticalStretch(ptr.Pointer())))
	}
	return 0
}

type QSlider struct {
	QAbstractSlider
}

type QSlider_ITF interface {
	QAbstractSlider_ITF
	QSlider_PTR() *QSlider
}

func (ptr *QSlider) QSlider_PTR() *QSlider {
	return ptr
}

func (ptr *QSlider) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractSlider_PTR().Pointer()
	}
	return nil
}

func (ptr *QSlider) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractSlider_PTR().SetPointer(p)
	}
}

func PointerFromQSlider(ptr QSlider_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSlider_PTR().Pointer()
	}
	return nil
}

func NewQSliderFromPointer(ptr unsafe.Pointer) (n *QSlider) {
	n = new(QSlider)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QSlider__TickPosition
//QSlider::TickPosition
type QSlider__TickPosition int64

const (
	QSlider__NoTicks        QSlider__TickPosition = QSlider__TickPosition(0)
	QSlider__TicksAbove     QSlider__TickPosition = QSlider__TickPosition(1)
	QSlider__TicksLeft      QSlider__TickPosition = QSlider__TickPosition(QSlider__TicksAbove)
	QSlider__TicksBelow     QSlider__TickPosition = QSlider__TickPosition(2)
	QSlider__TicksRight     QSlider__TickPosition = QSlider__TickPosition(QSlider__TicksBelow)
	QSlider__TicksBothSides QSlider__TickPosition = QSlider__TickPosition(3)
)

func NewQSlider(parent QWidget_ITF) *QSlider {
	tmpValue := NewQSliderFromPointer(C.QSlider_NewQSlider(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSlider2(orientation core.Qt__Orientation, parent QWidget_ITF) *QSlider {
	tmpValue := NewQSliderFromPointer(C.QSlider_NewQSlider2(C.longlong(orientation), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QSlider) SetTickInterval(ti int) {
	if ptr.Pointer() != nil {
		C.QSlider_SetTickInterval(ptr.Pointer(), C.int(int32(ti)))
	}
}

func (ptr *QSlider) SetTickPosition(position QSlider__TickPosition) {
	if ptr.Pointer() != nil {
		C.QSlider_SetTickPosition(ptr.Pointer(), C.longlong(position))
	}
}

//export callbackQSlider_DestroyQSlider
func callbackQSlider_DestroyQSlider(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSlider"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSliderFromPointer(ptr).DestroyQSliderDefault()
	}
}

func (ptr *QSlider) ConnectDestroyQSlider(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSlider"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSlider", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSlider", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSlider) DisconnectDestroyQSlider() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSlider")
	}
}

func (ptr *QSlider) DestroyQSlider() {
	if ptr.Pointer() != nil {
		C.QSlider_DestroyQSlider(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSlider) DestroyQSliderDefault() {
	if ptr.Pointer() != nil {
		C.QSlider_DestroyQSliderDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSlider) TickPosition() QSlider__TickPosition {
	if ptr.Pointer() != nil {
		return QSlider__TickPosition(C.QSlider_TickPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSlider) TickInterval() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSlider_TickInterval(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSlider) InitStyleOption(option QStyleOptionSlider_ITF) {
	if ptr.Pointer() != nil {
		C.QSlider_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionSlider(option))
	}
}

type QSpacerItem struct {
	QLayoutItem
}

type QSpacerItem_ITF interface {
	QLayoutItem_ITF
	QSpacerItem_PTR() *QSpacerItem
}

func (ptr *QSpacerItem) QSpacerItem_PTR() *QSpacerItem {
	return ptr
}

func (ptr *QSpacerItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QLayoutItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QSpacerItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QLayoutItem_PTR().SetPointer(p)
	}
}

func PointerFromQSpacerItem(ptr QSpacerItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSpacerItem_PTR().Pointer()
	}
	return nil
}

func NewQSpacerItemFromPointer(ptr unsafe.Pointer) (n *QSpacerItem) {
	n = new(QSpacerItem)
	n.SetPointer(ptr)
	return
}
func NewQSpacerItem(w int, h int, hPolicy QSizePolicy__Policy, vPolicy QSizePolicy__Policy) *QSpacerItem {
	return NewQSpacerItemFromPointer(C.QSpacerItem_NewQSpacerItem(C.int(int32(w)), C.int(int32(h)), C.longlong(hPolicy), C.longlong(vPolicy)))
}

func (ptr *QSpacerItem) ChangeSize(w int, h int, hPolicy QSizePolicy__Policy, vPolicy QSizePolicy__Policy) {
	if ptr.Pointer() != nil {
		C.QSpacerItem_ChangeSize(ptr.Pointer(), C.int(int32(w)), C.int(int32(h)), C.longlong(hPolicy), C.longlong(vPolicy))
	}
}

//export callbackQSpacerItem_SetGeometry
func callbackQSpacerItem_SetGeometry(ptr unsafe.Pointer, r unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setGeometry"); signal != nil {
		(*(*func(*core.QRect))(signal))(core.NewQRectFromPointer(r))
	} else {
		NewQSpacerItemFromPointer(ptr).SetGeometryDefault(core.NewQRectFromPointer(r))
	}
}

func (ptr *QSpacerItem) ConnectSetGeometry(f func(r *core.QRect)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setGeometry"); signal != nil {
			f := func(r *core.QRect) {
				(*(*func(*core.QRect))(signal))(r)
				f(r)
			}
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpacerItem) DisconnectSetGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setGeometry")
	}
}

func (ptr *QSpacerItem) SetGeometry(r core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QSpacerItem_SetGeometry(ptr.Pointer(), core.PointerFromQRect(r))
	}
}

func (ptr *QSpacerItem) SetGeometryDefault(r core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QSpacerItem_SetGeometryDefault(ptr.Pointer(), core.PointerFromQRect(r))
	}
}

//export callbackQSpacerItem_DestroyQSpacerItem
func callbackQSpacerItem_DestroyQSpacerItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSpacerItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSpacerItemFromPointer(ptr).DestroyQSpacerItemDefault()
	}
}

func (ptr *QSpacerItem) ConnectDestroyQSpacerItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSpacerItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSpacerItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSpacerItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpacerItem) DisconnectDestroyQSpacerItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSpacerItem")
	}
}

func (ptr *QSpacerItem) DestroyQSpacerItem() {
	if ptr.Pointer() != nil {
		C.QSpacerItem_DestroyQSpacerItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSpacerItem) DestroyQSpacerItemDefault() {
	if ptr.Pointer() != nil {
		C.QSpacerItem_DestroyQSpacerItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQSpacerItem_Geometry
func callbackQSpacerItem_Geometry(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "geometry"); signal != nil {
		return core.PointerFromQRect((*(*func() *core.QRect)(signal))())
	}

	return core.PointerFromQRect(NewQSpacerItemFromPointer(ptr).GeometryDefault())
}

func (ptr *QSpacerItem) ConnectGeometry(f func() *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "geometry"); signal != nil {
			f := func() *core.QRect {
				(*(*func() *core.QRect)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "geometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "geometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpacerItem) DisconnectGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "geometry")
	}
}

func (ptr *QSpacerItem) Geometry() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QSpacerItem_Geometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QSpacerItem) GeometryDefault() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QSpacerItem_GeometryDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQSpacerItem_MaximumSize
func callbackQSpacerItem_MaximumSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "maximumSize"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQSpacerItemFromPointer(ptr).MaximumSizeDefault())
}

func (ptr *QSpacerItem) ConnectMaximumSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "maximumSize"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "maximumSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "maximumSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpacerItem) DisconnectMaximumSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "maximumSize")
	}
}

func (ptr *QSpacerItem) MaximumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QSpacerItem_MaximumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSpacerItem) MaximumSizeDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QSpacerItem_MaximumSizeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQSpacerItem_MinimumSize
func callbackQSpacerItem_MinimumSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "minimumSize"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQSpacerItemFromPointer(ptr).MinimumSizeDefault())
}

func (ptr *QSpacerItem) ConnectMinimumSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "minimumSize"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "minimumSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "minimumSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpacerItem) DisconnectMinimumSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "minimumSize")
	}
}

func (ptr *QSpacerItem) MinimumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QSpacerItem_MinimumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSpacerItem) MinimumSizeDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QSpacerItem_MinimumSizeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQSpacerItem_SizeHint
func callbackQSpacerItem_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQSpacerItemFromPointer(ptr).SizeHintDefault())
}

func (ptr *QSpacerItem) ConnectSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpacerItem) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QSpacerItem) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QSpacerItem_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSpacerItem) SizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QSpacerItem_SizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QSpacerItem) SizePolicy() *QSizePolicy {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizePolicyFromPointer(C.QSpacerItem_SizePolicy(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSizePolicy).DestroyQSizePolicy)
		return tmpValue
	}
	return nil
}

//export callbackQSpacerItem_ExpandingDirections
func callbackQSpacerItem_ExpandingDirections(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "expandingDirections"); signal != nil {
		return C.longlong((*(*func() core.Qt__Orientation)(signal))())
	}

	return C.longlong(NewQSpacerItemFromPointer(ptr).ExpandingDirectionsDefault())
}

func (ptr *QSpacerItem) ConnectExpandingDirections(f func() core.Qt__Orientation) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "expandingDirections"); signal != nil {
			f := func() core.Qt__Orientation {
				(*(*func() core.Qt__Orientation)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "expandingDirections", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "expandingDirections", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpacerItem) DisconnectExpandingDirections() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "expandingDirections")
	}
}

func (ptr *QSpacerItem) ExpandingDirections() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QSpacerItem_ExpandingDirections(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSpacerItem) ExpandingDirectionsDefault() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QSpacerItem_ExpandingDirectionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQSpacerItem_IsEmpty
func callbackQSpacerItem_IsEmpty(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isEmpty"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSpacerItemFromPointer(ptr).IsEmptyDefault())))
}

func (ptr *QSpacerItem) ConnectIsEmpty(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isEmpty"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpacerItem) DisconnectIsEmpty() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isEmpty")
	}
}

func (ptr *QSpacerItem) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSpacerItem_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSpacerItem) IsEmptyDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSpacerItem_IsEmptyDefault(ptr.Pointer())) != 0
	}
	return false
}

type QSpinBox struct {
	QAbstractSpinBox
}

type QSpinBox_ITF interface {
	QAbstractSpinBox_ITF
	QSpinBox_PTR() *QSpinBox
}

func (ptr *QSpinBox) QSpinBox_PTR() *QSpinBox {
	return ptr
}

func (ptr *QSpinBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractSpinBox_PTR().Pointer()
	}
	return nil
}

func (ptr *QSpinBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractSpinBox_PTR().SetPointer(p)
	}
}

func PointerFromQSpinBox(ptr QSpinBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSpinBox_PTR().Pointer()
	}
	return nil
}

func NewQSpinBoxFromPointer(ptr unsafe.Pointer) (n *QSpinBox) {
	n = new(QSpinBox)
	n.SetPointer(ptr)
	return
}
func NewQSpinBox(parent QWidget_ITF) *QSpinBox {
	tmpValue := NewQSpinBoxFromPointer(C.QSpinBox_NewQSpinBox(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QSpinBox) SetDisplayIntegerBase(base int) {
	if ptr.Pointer() != nil {
		C.QSpinBox_SetDisplayIntegerBase(ptr.Pointer(), C.int(int32(base)))
	}
}

func (ptr *QSpinBox) SetMaximum(max int) {
	if ptr.Pointer() != nil {
		C.QSpinBox_SetMaximum(ptr.Pointer(), C.int(int32(max)))
	}
}

func (ptr *QSpinBox) SetMinimum(min int) {
	if ptr.Pointer() != nil {
		C.QSpinBox_SetMinimum(ptr.Pointer(), C.int(int32(min)))
	}
}

func (ptr *QSpinBox) SetPrefix(prefix string) {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		C.QSpinBox_SetPrefix(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: prefixC, len: C.longlong(len(prefix))})
	}
}

func (ptr *QSpinBox) SetRange(minimum int, maximum int) {
	if ptr.Pointer() != nil {
		C.QSpinBox_SetRange(ptr.Pointer(), C.int(int32(minimum)), C.int(int32(maximum)))
	}
}

func (ptr *QSpinBox) SetSingleStep(val int) {
	if ptr.Pointer() != nil {
		C.QSpinBox_SetSingleStep(ptr.Pointer(), C.int(int32(val)))
	}
}

func (ptr *QSpinBox) SetStepType(stepType QAbstractSpinBox__StepType) {
	if ptr.Pointer() != nil {
		C.QSpinBox_SetStepType(ptr.Pointer(), C.longlong(stepType))
	}
}

func (ptr *QSpinBox) SetSuffix(suffix string) {
	if ptr.Pointer() != nil {
		var suffixC *C.char
		if suffix != "" {
			suffixC = C.CString(suffix)
			defer C.free(unsafe.Pointer(suffixC))
		}
		C.QSpinBox_SetSuffix(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: suffixC, len: C.longlong(len(suffix))})
	}
}

//export callbackQSpinBox_SetValue
func callbackQSpinBox_SetValue(ptr unsafe.Pointer, val C.int) {
	if signal := qt.GetSignal(ptr, "setValue"); signal != nil {
		(*(*func(int))(signal))(int(int32(val)))
	} else {
		NewQSpinBoxFromPointer(ptr).SetValueDefault(int(int32(val)))
	}
}

func (ptr *QSpinBox) ConnectSetValue(f func(val int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setValue"); signal != nil {
			f := func(val int) {
				(*(*func(int))(signal))(val)
				f(val)
			}
			qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpinBox) DisconnectSetValue() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setValue")
	}
}

func (ptr *QSpinBox) SetValue(val int) {
	if ptr.Pointer() != nil {
		C.QSpinBox_SetValue(ptr.Pointer(), C.int(int32(val)))
	}
}

func (ptr *QSpinBox) SetValueDefault(val int) {
	if ptr.Pointer() != nil {
		C.QSpinBox_SetValueDefault(ptr.Pointer(), C.int(int32(val)))
	}
}

//export callbackQSpinBox_ValueChanged2
func callbackQSpinBox_ValueChanged2(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "valueChanged2"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	}

}

func (ptr *QSpinBox) ConnectValueChanged2(f func(text string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "valueChanged2") {
			C.QSpinBox_ConnectValueChanged2(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "valueChanged2"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueChanged2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueChanged2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpinBox) DisconnectValueChanged2() {
	if ptr.Pointer() != nil {
		C.QSpinBox_DisconnectValueChanged2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "valueChanged2")
	}
}

func (ptr *QSpinBox) ValueChanged2(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QSpinBox_ValueChanged2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQSpinBox_ValueChanged
func callbackQSpinBox_ValueChanged(ptr unsafe.Pointer, i C.int) {
	if signal := qt.GetSignal(ptr, "valueChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(i)))
	}

}

func (ptr *QSpinBox) ConnectValueChanged(f func(i int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "valueChanged") {
			C.QSpinBox_ConnectValueChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "valueChanged"); signal != nil {
			f := func(i int) {
				(*(*func(int))(signal))(i)
				f(i)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpinBox) DisconnectValueChanged() {
	if ptr.Pointer() != nil {
		C.QSpinBox_DisconnectValueChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "valueChanged")
	}
}

func (ptr *QSpinBox) ValueChanged(i int) {
	if ptr.Pointer() != nil {
		C.QSpinBox_ValueChanged(ptr.Pointer(), C.int(int32(i)))
	}
}

//export callbackQSpinBox_DestroyQSpinBox
func callbackQSpinBox_DestroyQSpinBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSpinBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSpinBoxFromPointer(ptr).DestroyQSpinBoxDefault()
	}
}

func (ptr *QSpinBox) ConnectDestroyQSpinBox(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSpinBox"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSpinBox", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSpinBox", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpinBox) DisconnectDestroyQSpinBox() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSpinBox")
	}
}

func (ptr *QSpinBox) DestroyQSpinBox() {
	if ptr.Pointer() != nil {
		C.QSpinBox_DestroyQSpinBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSpinBox) DestroyQSpinBoxDefault() {
	if ptr.Pointer() != nil {
		C.QSpinBox_DestroyQSpinBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSpinBox) StepType() QAbstractSpinBox__StepType {
	if ptr.Pointer() != nil {
		return QAbstractSpinBox__StepType(C.QSpinBox_StepType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSpinBox) CleanText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSpinBox_CleanText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSpinBox) Prefix() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSpinBox_Prefix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSpinBox) Suffix() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSpinBox_Suffix(ptr.Pointer()))
	}
	return ""
}

//export callbackQSpinBox_TextFromValue
func callbackQSpinBox_TextFromValue(ptr unsafe.Pointer, value C.int) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "textFromValue"); signal != nil {
		tempVal := (*(*func(int) string)(signal))(int(int32(value)))
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQSpinBoxFromPointer(ptr).TextFromValueDefault(int(int32(value)))
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QSpinBox) ConnectTextFromValue(f func(value int) string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "textFromValue"); signal != nil {
			f := func(value int) string {
				(*(*func(int) string)(signal))(value)
				return f(value)
			}
			qt.ConnectSignal(ptr.Pointer(), "textFromValue", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "textFromValue", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpinBox) DisconnectTextFromValue() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "textFromValue")
	}
}

func (ptr *QSpinBox) TextFromValue(value int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSpinBox_TextFromValue(ptr.Pointer(), C.int(int32(value))))
	}
	return ""
}

func (ptr *QSpinBox) TextFromValueDefault(value int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSpinBox_TextFromValueDefault(ptr.Pointer(), C.int(int32(value))))
	}
	return ""
}

func (ptr *QSpinBox) DisplayIntegerBase() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSpinBox_DisplayIntegerBase(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSpinBox) Maximum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSpinBox_Maximum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSpinBox) Minimum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSpinBox_Minimum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSpinBox) SingleStep() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSpinBox_SingleStep(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSpinBox) Value() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSpinBox_Value(ptr.Pointer())))
	}
	return 0
}

//export callbackQSpinBox_ValueFromText
func callbackQSpinBox_ValueFromText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) C.int {
	if signal := qt.GetSignal(ptr, "valueFromText"); signal != nil {
		return C.int(int32((*(*func(string) int)(signal))(cGoUnpackString(text))))
	}

	return C.int(int32(NewQSpinBoxFromPointer(ptr).ValueFromTextDefault(cGoUnpackString(text))))
}

func (ptr *QSpinBox) ConnectValueFromText(f func(text string) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "valueFromText"); signal != nil {
			f := func(text string) int {
				(*(*func(string) int)(signal))(text)
				return f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "valueFromText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "valueFromText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSpinBox) DisconnectValueFromText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "valueFromText")
	}
}

func (ptr *QSpinBox) ValueFromText(text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QSpinBox_ValueFromText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

func (ptr *QSpinBox) ValueFromTextDefault(text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QSpinBox_ValueFromTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

type QSplashScreen struct {
	QWidget
}

type QSplashScreen_ITF interface {
	QWidget_ITF
	QSplashScreen_PTR() *QSplashScreen
}

func (ptr *QSplashScreen) QSplashScreen_PTR() *QSplashScreen {
	return ptr
}

func (ptr *QSplashScreen) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QSplashScreen) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQSplashScreen(ptr QSplashScreen_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSplashScreen_PTR().Pointer()
	}
	return nil
}

func NewQSplashScreenFromPointer(ptr unsafe.Pointer) (n *QSplashScreen) {
	n = new(QSplashScreen)
	n.SetPointer(ptr)
	return
}
func NewQSplashScreen2(parent QWidget_ITF, pixmap gui.QPixmap_ITF, ff core.Qt__WindowType) *QSplashScreen {
	tmpValue := NewQSplashScreenFromPointer(C.QSplashScreen_NewQSplashScreen2(PointerFromQWidget(parent), gui.PointerFromQPixmap(pixmap), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSplashScreen(pixmap gui.QPixmap_ITF, ff core.Qt__WindowType) *QSplashScreen {
	tmpValue := NewQSplashScreenFromPointer(C.QSplashScreen_NewQSplashScreen(gui.PointerFromQPixmap(pixmap), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQSplashScreen_ClearMessage
func callbackQSplashScreen_ClearMessage(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clearMessage"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSplashScreenFromPointer(ptr).ClearMessageDefault()
	}
}

func (ptr *QSplashScreen) ConnectClearMessage(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clearMessage"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clearMessage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clearMessage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSplashScreen) DisconnectClearMessage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clearMessage")
	}
}

func (ptr *QSplashScreen) ClearMessage() {
	if ptr.Pointer() != nil {
		C.QSplashScreen_ClearMessage(ptr.Pointer())
	}
}

func (ptr *QSplashScreen) ClearMessageDefault() {
	if ptr.Pointer() != nil {
		C.QSplashScreen_ClearMessageDefault(ptr.Pointer())
	}
}

//export callbackQSplashScreen_DrawContents
func callbackQSplashScreen_DrawContents(ptr unsafe.Pointer, painter unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawContents"); signal != nil {
		(*(*func(*gui.QPainter))(signal))(gui.NewQPainterFromPointer(painter))
	} else {
		NewQSplashScreenFromPointer(ptr).DrawContentsDefault(gui.NewQPainterFromPointer(painter))
	}
}

func (ptr *QSplashScreen) ConnectDrawContents(f func(painter *gui.QPainter)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawContents"); signal != nil {
			f := func(painter *gui.QPainter) {
				(*(*func(*gui.QPainter))(signal))(painter)
				f(painter)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSplashScreen) DisconnectDrawContents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawContents")
	}
}

func (ptr *QSplashScreen) DrawContents(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QSplashScreen_DrawContents(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

func (ptr *QSplashScreen) DrawContentsDefault(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QSplashScreen_DrawContentsDefault(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

func (ptr *QSplashScreen) Finish(mainWin QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QSplashScreen_Finish(ptr.Pointer(), PointerFromQWidget(mainWin))
	}
}

//export callbackQSplashScreen_MessageChanged
func callbackQSplashScreen_MessageChanged(ptr unsafe.Pointer, message C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "messageChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(message))
	}

}

func (ptr *QSplashScreen) ConnectMessageChanged(f func(message string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "messageChanged") {
			C.QSplashScreen_ConnectMessageChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "messageChanged"); signal != nil {
			f := func(message string) {
				(*(*func(string))(signal))(message)
				f(message)
			}
			qt.ConnectSignal(ptr.Pointer(), "messageChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "messageChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSplashScreen) DisconnectMessageChanged() {
	if ptr.Pointer() != nil {
		C.QSplashScreen_DisconnectMessageChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "messageChanged")
	}
}

func (ptr *QSplashScreen) MessageChanged(message string) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QSplashScreen_MessageChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))})
	}
}

func (ptr *QSplashScreen) Repaint() {
	if ptr.Pointer() != nil {
		C.QSplashScreen_Repaint(ptr.Pointer())
	}
}

func (ptr *QSplashScreen) SetPixmap(pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QSplashScreen_SetPixmap(ptr.Pointer(), gui.PointerFromQPixmap(pixmap))
	}
}

//export callbackQSplashScreen_ShowMessage
func callbackQSplashScreen_ShowMessage(ptr unsafe.Pointer, message C.struct_QtWidgets_PackedString, alignment C.int, color unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showMessage"); signal != nil {
		(*(*func(string, int, *gui.QColor))(signal))(cGoUnpackString(message), int(int32(alignment)), gui.NewQColorFromPointer(color))
	} else {
		NewQSplashScreenFromPointer(ptr).ShowMessageDefault(cGoUnpackString(message), int(int32(alignment)), gui.NewQColorFromPointer(color))
	}
}

func (ptr *QSplashScreen) ConnectShowMessage(f func(message string, alignment int, color *gui.QColor)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMessage"); signal != nil {
			f := func(message string, alignment int, color *gui.QColor) {
				(*(*func(string, int, *gui.QColor))(signal))(message, alignment, color)
				f(message, alignment, color)
			}
			qt.ConnectSignal(ptr.Pointer(), "showMessage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMessage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSplashScreen) DisconnectShowMessage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMessage")
	}
}

func (ptr *QSplashScreen) ShowMessage(message string, alignment int, color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QSplashScreen_ShowMessage(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, C.int(int32(alignment)), gui.PointerFromQColor(color))
	}
}

func (ptr *QSplashScreen) ShowMessageDefault(message string, alignment int, color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QSplashScreen_ShowMessageDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, C.int(int32(alignment)), gui.PointerFromQColor(color))
	}
}

//export callbackQSplashScreen_DestroyQSplashScreen
func callbackQSplashScreen_DestroyQSplashScreen(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSplashScreen"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSplashScreenFromPointer(ptr).DestroyQSplashScreenDefault()
	}
}

func (ptr *QSplashScreen) ConnectDestroyQSplashScreen(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSplashScreen"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSplashScreen", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSplashScreen", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSplashScreen) DisconnectDestroyQSplashScreen() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSplashScreen")
	}
}

func (ptr *QSplashScreen) DestroyQSplashScreen() {
	if ptr.Pointer() != nil {
		C.QSplashScreen_DestroyQSplashScreen(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSplashScreen) DestroyQSplashScreenDefault() {
	if ptr.Pointer() != nil {
		C.QSplashScreen_DestroyQSplashScreenDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSplashScreen) Message() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSplashScreen_Message(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSplashScreen) Pixmap() *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QSplashScreen_Pixmap(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

type QSplitter struct {
	QFrame
}

type QSplitter_ITF interface {
	QFrame_ITF
	QSplitter_PTR() *QSplitter
}

func (ptr *QSplitter) QSplitter_PTR() *QSplitter {
	return ptr
}

func (ptr *QSplitter) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QFrame_PTR().Pointer()
	}
	return nil
}

func (ptr *QSplitter) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QFrame_PTR().SetPointer(p)
	}
}

func PointerFromQSplitter(ptr QSplitter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSplitter_PTR().Pointer()
	}
	return nil
}

func NewQSplitterFromPointer(ptr unsafe.Pointer) (n *QSplitter) {
	n = new(QSplitter)
	n.SetPointer(ptr)
	return
}
func NewQSplitter(parent QWidget_ITF) *QSplitter {
	tmpValue := NewQSplitterFromPointer(C.QSplitter_NewQSplitter(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSplitter2(orientation core.Qt__Orientation, parent QWidget_ITF) *QSplitter {
	tmpValue := NewQSplitterFromPointer(C.QSplitter_NewQSplitter2(C.longlong(orientation), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQSplitter_CreateHandle
func callbackQSplitter_CreateHandle(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "createHandle"); signal != nil {
		return PointerFromQSplitterHandle((*(*func() *QSplitterHandle)(signal))())
	}

	return PointerFromQSplitterHandle(NewQSplitterFromPointer(ptr).CreateHandleDefault())
}

func (ptr *QSplitter) ConnectCreateHandle(f func() *QSplitterHandle) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "createHandle"); signal != nil {
			f := func() *QSplitterHandle {
				(*(*func() *QSplitterHandle)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "createHandle", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "createHandle", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSplitter) DisconnectCreateHandle() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "createHandle")
	}
}

func (ptr *QSplitter) CreateHandle() *QSplitterHandle {
	if ptr.Pointer() != nil {
		tmpValue := NewQSplitterHandleFromPointer(C.QSplitter_CreateHandle(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSplitter) CreateHandleDefault() *QSplitterHandle {
	if ptr.Pointer() != nil {
		tmpValue := NewQSplitterHandleFromPointer(C.QSplitter_CreateHandleDefault(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSplitter) ReplaceWidget(index int, widget QWidget_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QSplitter_ReplaceWidget(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(widget)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSplitter) RestoreState(state core.QByteArray_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSplitter_RestoreState(ptr.Pointer(), core.PointerFromQByteArray(state))) != 0
	}
	return false
}

func (ptr *QSplitter) ClosestLegalPosition(pos int, index int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSplitter_ClosestLegalPosition(ptr.Pointer(), C.int(int32(pos)), C.int(int32(index)))))
	}
	return 0
}

func (ptr *QSplitter) AddWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QSplitter_AddWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QSplitter) InsertWidget(index int, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QSplitter_InsertWidget(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(widget))
	}
}

func (ptr *QSplitter) MoveSplitter(pos int, index int) {
	if ptr.Pointer() != nil {
		C.QSplitter_MoveSplitter(ptr.Pointer(), C.int(int32(pos)), C.int(int32(index)))
	}
}

func (ptr *QSplitter) Refresh() {
	if ptr.Pointer() != nil {
		C.QSplitter_Refresh(ptr.Pointer())
	}
}

func (ptr *QSplitter) SetChildrenCollapsible(vbo bool) {
	if ptr.Pointer() != nil {
		C.QSplitter_SetChildrenCollapsible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QSplitter) SetCollapsible(index int, collapse bool) {
	if ptr.Pointer() != nil {
		C.QSplitter_SetCollapsible(ptr.Pointer(), C.int(int32(index)), C.char(int8(qt.GoBoolToInt(collapse))))
	}
}

func (ptr *QSplitter) SetHandleWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QSplitter_SetHandleWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QSplitter) SetOpaqueResize(opaque bool) {
	if ptr.Pointer() != nil {
		C.QSplitter_SetOpaqueResize(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(opaque))))
	}
}

func (ptr *QSplitter) SetOrientation(vqt core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QSplitter_SetOrientation(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QSplitter) SetRubberBand(pos int) {
	if ptr.Pointer() != nil {
		C.QSplitter_SetRubberBand(ptr.Pointer(), C.int(int32(pos)))
	}
}

func (ptr *QSplitter) SetSizes(list []int) {
	if ptr.Pointer() != nil {
		C.QSplitter_SetSizes(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQSplitterFromPointer(NewQSplitterFromPointer(nil).__setSizes_list_newList())
			for _, v := range list {
				tmpList.__setSizes_list_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QSplitter) SetStretchFactor(index int, stretch int) {
	if ptr.Pointer() != nil {
		C.QSplitter_SetStretchFactor(ptr.Pointer(), C.int(int32(index)), C.int(int32(stretch)))
	}
}

//export callbackQSplitter_SplitterMoved
func callbackQSplitter_SplitterMoved(ptr unsafe.Pointer, pos C.int, index C.int) {
	if signal := qt.GetSignal(ptr, "splitterMoved"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(pos)), int(int32(index)))
	}

}

func (ptr *QSplitter) ConnectSplitterMoved(f func(pos int, index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "splitterMoved") {
			C.QSplitter_ConnectSplitterMoved(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "splitterMoved"); signal != nil {
			f := func(pos int, index int) {
				(*(*func(int, int))(signal))(pos, index)
				f(pos, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "splitterMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "splitterMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSplitter) DisconnectSplitterMoved() {
	if ptr.Pointer() != nil {
		C.QSplitter_DisconnectSplitterMoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "splitterMoved")
	}
}

func (ptr *QSplitter) SplitterMoved(pos int, index int) {
	if ptr.Pointer() != nil {
		C.QSplitter_SplitterMoved(ptr.Pointer(), C.int(int32(pos)), C.int(int32(index)))
	}
}

//export callbackQSplitter_DestroyQSplitter
func callbackQSplitter_DestroyQSplitter(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSplitter"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSplitterFromPointer(ptr).DestroyQSplitterDefault()
	}
}

func (ptr *QSplitter) ConnectDestroyQSplitter(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSplitter"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSplitter", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSplitter", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSplitter) DisconnectDestroyQSplitter() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSplitter")
	}
}

func (ptr *QSplitter) DestroyQSplitter() {
	if ptr.Pointer() != nil {
		C.QSplitter_DestroyQSplitter(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSplitter) DestroyQSplitterDefault() {
	if ptr.Pointer() != nil {
		C.QSplitter_DestroyQSplitterDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSplitter) SaveState() *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QSplitter_SaveState(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QSplitter) Sizes() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQSplitterFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__sizes_atList(i)
			}
			return out
		}(C.QSplitter_Sizes(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QSplitter) Handle(index int) *QSplitterHandle {
	if ptr.Pointer() != nil {
		tmpValue := NewQSplitterHandleFromPointer(C.QSplitter_Handle(ptr.Pointer(), C.int(int32(index))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSplitter) Widget(index int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QSplitter_Widget(ptr.Pointer(), C.int(int32(index))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSplitter) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QSplitter_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSplitter) ChildrenCollapsible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSplitter_ChildrenCollapsible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSplitter) IsCollapsible(index int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSplitter_IsCollapsible(ptr.Pointer(), C.int(int32(index)))) != 0
	}
	return false
}

func (ptr *QSplitter) OpaqueResize() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSplitter_OpaqueResize(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QSplitter) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSplitter_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSplitter) HandleWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSplitter_HandleWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QSplitter) IndexOf(widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSplitter_IndexOf(ptr.Pointer(), PointerFromQWidget(widget))))
	}
	return 0
}

func (ptr *QSplitter) GetRange(index int, min int, max int) {
	if ptr.Pointer() != nil {
		C.QSplitter_GetRange(ptr.Pointer(), C.int(int32(index)), C.int(int32(min)), C.int(int32(max)))
	}
}

func (ptr *QSplitter) __setSizes_list_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSplitter___setSizes_list_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QSplitter) __setSizes_list_setList(i int) {
	if ptr.Pointer() != nil {
		C.QSplitter___setSizes_list_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QSplitter) __setSizes_list_newList() unsafe.Pointer {
	return C.QSplitter___setSizes_list_newList(ptr.Pointer())
}

func (ptr *QSplitter) __sizes_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSplitter___sizes_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QSplitter) __sizes_setList(i int) {
	if ptr.Pointer() != nil {
		C.QSplitter___sizes_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QSplitter) __sizes_newList() unsafe.Pointer {
	return C.QSplitter___sizes_newList(ptr.Pointer())
}

type QSplitterHandle struct {
	QWidget
}

type QSplitterHandle_ITF interface {
	QWidget_ITF
	QSplitterHandle_PTR() *QSplitterHandle
}

func (ptr *QSplitterHandle) QSplitterHandle_PTR() *QSplitterHandle {
	return ptr
}

func (ptr *QSplitterHandle) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QSplitterHandle) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQSplitterHandle(ptr QSplitterHandle_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSplitterHandle_PTR().Pointer()
	}
	return nil
}

func NewQSplitterHandleFromPointer(ptr unsafe.Pointer) (n *QSplitterHandle) {
	n = new(QSplitterHandle)
	n.SetPointer(ptr)
	return
}
func NewQSplitterHandle(orientation core.Qt__Orientation, parent QSplitter_ITF) *QSplitterHandle {
	tmpValue := NewQSplitterHandleFromPointer(C.QSplitterHandle_NewQSplitterHandle(C.longlong(orientation), PointerFromQSplitter(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QSplitterHandle) ClosestLegalPosition(pos int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QSplitterHandle_ClosestLegalPosition(ptr.Pointer(), C.int(int32(pos)))))
	}
	return 0
}

func (ptr *QSplitterHandle) MoveSplitter(pos int) {
	if ptr.Pointer() != nil {
		C.QSplitterHandle_MoveSplitter(ptr.Pointer(), C.int(int32(pos)))
	}
}

func (ptr *QSplitterHandle) SetOrientation(orientation core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QSplitterHandle_SetOrientation(ptr.Pointer(), C.longlong(orientation))
	}
}

//export callbackQSplitterHandle_DestroyQSplitterHandle
func callbackQSplitterHandle_DestroyQSplitterHandle(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSplitterHandle"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSplitterHandleFromPointer(ptr).DestroyQSplitterHandleDefault()
	}
}

func (ptr *QSplitterHandle) ConnectDestroyQSplitterHandle(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSplitterHandle"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSplitterHandle", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSplitterHandle", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSplitterHandle) DisconnectDestroyQSplitterHandle() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSplitterHandle")
	}
}

func (ptr *QSplitterHandle) DestroyQSplitterHandle() {
	if ptr.Pointer() != nil {
		C.QSplitterHandle_DestroyQSplitterHandle(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSplitterHandle) DestroyQSplitterHandleDefault() {
	if ptr.Pointer() != nil {
		C.QSplitterHandle_DestroyQSplitterHandleDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSplitterHandle) Splitter() *QSplitter {
	if ptr.Pointer() != nil {
		tmpValue := NewQSplitterFromPointer(C.QSplitterHandle_Splitter(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSplitterHandle) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QSplitterHandle_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSplitterHandle) OpaqueResize() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSplitterHandle_OpaqueResize(ptr.Pointer())) != 0
	}
	return false
}

type QStackedLayout struct {
	QLayout
}

type QStackedLayout_ITF interface {
	QLayout_ITF
	QStackedLayout_PTR() *QStackedLayout
}

func (ptr *QStackedLayout) QStackedLayout_PTR() *QStackedLayout {
	return ptr
}

func (ptr *QStackedLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QLayout_PTR().Pointer()
	}
	return nil
}

func (ptr *QStackedLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QLayout_PTR().SetPointer(p)
	}
}

func PointerFromQStackedLayout(ptr QStackedLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStackedLayout_PTR().Pointer()
	}
	return nil
}

func NewQStackedLayoutFromPointer(ptr unsafe.Pointer) (n *QStackedLayout) {
	n = new(QStackedLayout)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QStackedLayout__StackingMode
//QStackedLayout::StackingMode
type QStackedLayout__StackingMode int64

const (
	QStackedLayout__StackOne QStackedLayout__StackingMode = QStackedLayout__StackingMode(0)
	QStackedLayout__StackAll QStackedLayout__StackingMode = QStackedLayout__StackingMode(1)
)

//export callbackQStackedLayout_TakeAt
func callbackQStackedLayout_TakeAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "takeAt"); signal != nil {
		return PointerFromQLayoutItem((*(*func(int) *QLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQLayoutItem(NewQStackedLayoutFromPointer(ptr).TakeAtDefault(int(int32(index))))
}

func (ptr *QStackedLayout) ConnectTakeAt(f func(index int) *QLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "takeAt"); signal != nil {
			f := func(index int) *QLayoutItem {
				(*(*func(int) *QLayoutItem)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "takeAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "takeAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectTakeAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "takeAt")
	}
}

func (ptr *QStackedLayout) TakeAt(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QStackedLayout_TakeAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QStackedLayout) TakeAtDefault(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QStackedLayout_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func NewQStackedLayout() *QStackedLayout {
	tmpValue := NewQStackedLayoutFromPointer(C.QStackedLayout_NewQStackedLayout())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQStackedLayout3(parentLayout QLayout_ITF) *QStackedLayout {
	tmpValue := NewQStackedLayoutFromPointer(C.QStackedLayout_NewQStackedLayout3(PointerFromQLayout(parentLayout)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQStackedLayout2(parent QWidget_ITF) *QStackedLayout {
	tmpValue := NewQStackedLayoutFromPointer(C.QStackedLayout_NewQStackedLayout2(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QStackedLayout) AddWidget(widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedLayout_AddWidget(ptr.Pointer(), PointerFromQWidget(widget))))
	}
	return 0
}

func (ptr *QStackedLayout) InsertWidget(index int, widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedLayout_InsertWidget(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(widget))))
	}
	return 0
}

//export callbackQStackedLayout_AddItem
func callbackQStackedLayout_AddItem(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "addItem"); signal != nil {
		(*(*func(*QLayoutItem))(signal))(NewQLayoutItemFromPointer(item))
	} else {
		NewQStackedLayoutFromPointer(ptr).AddItemDefault(NewQLayoutItemFromPointer(item))
	}
}

func (ptr *QStackedLayout) ConnectAddItem(f func(item *QLayoutItem)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "addItem"); signal != nil {
			f := func(item *QLayoutItem) {
				(*(*func(*QLayoutItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "addItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "addItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectAddItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "addItem")
	}
}

func (ptr *QStackedLayout) AddItem(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QStackedLayout_AddItem(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

func (ptr *QStackedLayout) AddItemDefault(item QLayoutItem_ITF) {
	if ptr.Pointer() != nil {
		C.QStackedLayout_AddItemDefault(ptr.Pointer(), PointerFromQLayoutItem(item))
	}
}

//export callbackQStackedLayout_CurrentChanged
func callbackQStackedLayout_CurrentChanged(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QStackedLayout) ConnectCurrentChanged(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentChanged") {
			C.QStackedLayout_ConnectCurrentChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {
		C.QStackedLayout_DisconnectCurrentChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QStackedLayout) CurrentChanged(index int) {
	if ptr.Pointer() != nil {
		C.QStackedLayout_CurrentChanged(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQStackedLayout_SetCurrentIndex
func callbackQStackedLayout_SetCurrentIndex(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQStackedLayoutFromPointer(ptr).SetCurrentIndexDefault(int(int32(index)))
	}
}

func (ptr *QStackedLayout) ConnectSetCurrentIndex(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentIndex"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectSetCurrentIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentIndex")
	}
}

func (ptr *QStackedLayout) SetCurrentIndex(index int) {
	if ptr.Pointer() != nil {
		C.QStackedLayout_SetCurrentIndex(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QStackedLayout) SetCurrentIndexDefault(index int) {
	if ptr.Pointer() != nil {
		C.QStackedLayout_SetCurrentIndexDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQStackedLayout_SetCurrentWidget
func callbackQStackedLayout_SetCurrentWidget(ptr unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setCurrentWidget"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(widget))
	} else {
		NewQStackedLayoutFromPointer(ptr).SetCurrentWidgetDefault(NewQWidgetFromPointer(widget))
	}
}

func (ptr *QStackedLayout) ConnectSetCurrentWidget(f func(widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentWidget"); signal != nil {
			f := func(widget *QWidget) {
				(*(*func(*QWidget))(signal))(widget)
				f(widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectSetCurrentWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentWidget")
	}
}

func (ptr *QStackedLayout) SetCurrentWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStackedLayout_SetCurrentWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QStackedLayout) SetCurrentWidgetDefault(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStackedLayout_SetCurrentWidgetDefault(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QStackedLayout) SetStackingMode(stackingMode QStackedLayout__StackingMode) {
	if ptr.Pointer() != nil {
		C.QStackedLayout_SetStackingMode(ptr.Pointer(), C.longlong(stackingMode))
	}
}

//export callbackQStackedLayout_WidgetRemoved
func callbackQStackedLayout_WidgetRemoved(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "widgetRemoved"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QStackedLayout) ConnectWidgetRemoved(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "widgetRemoved") {
			C.QStackedLayout_ConnectWidgetRemoved(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "widgetRemoved"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "widgetRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "widgetRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectWidgetRemoved() {
	if ptr.Pointer() != nil {
		C.QStackedLayout_DisconnectWidgetRemoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "widgetRemoved")
	}
}

func (ptr *QStackedLayout) WidgetRemoved(index int) {
	if ptr.Pointer() != nil {
		C.QStackedLayout_WidgetRemoved(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQStackedLayout_DestroyQStackedLayout
func callbackQStackedLayout_DestroyQStackedLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QStackedLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStackedLayoutFromPointer(ptr).DestroyQStackedLayoutDefault()
	}
}

func (ptr *QStackedLayout) ConnectDestroyQStackedLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QStackedLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QStackedLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QStackedLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectDestroyQStackedLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QStackedLayout")
	}
}

func (ptr *QStackedLayout) DestroyQStackedLayout() {
	if ptr.Pointer() != nil {
		C.QStackedLayout_DestroyQStackedLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStackedLayout) DestroyQStackedLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QStackedLayout_DestroyQStackedLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQStackedLayout_ItemAt
func callbackQStackedLayout_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemAt"); signal != nil {
		return PointerFromQLayoutItem((*(*func(int) *QLayoutItem)(signal))(int(int32(index))))
	}

	return PointerFromQLayoutItem(NewQStackedLayoutFromPointer(ptr).ItemAtDefault(int(int32(index))))
}

func (ptr *QStackedLayout) ConnectItemAt(f func(index int) *QLayoutItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemAt"); signal != nil {
			f := func(index int) *QLayoutItem {
				(*(*func(int) *QLayoutItem)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectItemAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemAt")
	}
}

func (ptr *QStackedLayout) ItemAt(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QStackedLayout_ItemAt(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QStackedLayout) ItemAtDefault(index int) *QLayoutItem {
	if ptr.Pointer() != nil {
		return NewQLayoutItemFromPointer(C.QStackedLayout_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

//export callbackQStackedLayout_SizeHint
func callbackQStackedLayout_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQStackedLayoutFromPointer(ptr).SizeHintDefault())
}

func (ptr *QStackedLayout) ConnectSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QStackedLayout) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStackedLayout_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStackedLayout) SizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStackedLayout_SizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStackedLayout) StackingMode() QStackedLayout__StackingMode {
	if ptr.Pointer() != nil {
		return QStackedLayout__StackingMode(C.QStackedLayout_StackingMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStackedLayout) CurrentWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QStackedLayout_CurrentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStackedLayout) Widget(index int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QStackedLayout_Widget(ptr.Pointer(), C.int(int32(index))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQStackedLayout_Count
func callbackQStackedLayout_Count(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "count"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQStackedLayoutFromPointer(ptr).CountDefault()))
}

func (ptr *QStackedLayout) ConnectCount(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "count"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "count", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedLayout) DisconnectCount() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "count")
	}
}

func (ptr *QStackedLayout) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedLayout_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStackedLayout) CountDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedLayout_CountDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStackedLayout) CurrentIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedLayout_CurrentIndex(ptr.Pointer())))
	}
	return 0
}

type QStackedWidget struct {
	QFrame
}

type QStackedWidget_ITF interface {
	QFrame_ITF
	QStackedWidget_PTR() *QStackedWidget
}

func (ptr *QStackedWidget) QStackedWidget_PTR() *QStackedWidget {
	return ptr
}

func (ptr *QStackedWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QFrame_PTR().Pointer()
	}
	return nil
}

func (ptr *QStackedWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QFrame_PTR().SetPointer(p)
	}
}

func PointerFromQStackedWidget(ptr QStackedWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStackedWidget_PTR().Pointer()
	}
	return nil
}

func NewQStackedWidgetFromPointer(ptr unsafe.Pointer) (n *QStackedWidget) {
	n = new(QStackedWidget)
	n.SetPointer(ptr)
	return
}
func NewQStackedWidget(parent QWidget_ITF) *QStackedWidget {
	tmpValue := NewQStackedWidgetFromPointer(C.QStackedWidget_NewQStackedWidget(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QStackedWidget) AddWidget(widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedWidget_AddWidget(ptr.Pointer(), PointerFromQWidget(widget))))
	}
	return 0
}

func (ptr *QStackedWidget) InsertWidget(index int, widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedWidget_InsertWidget(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(widget))))
	}
	return 0
}

//export callbackQStackedWidget_CurrentChanged
func callbackQStackedWidget_CurrentChanged(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QStackedWidget) ConnectCurrentChanged(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentChanged") {
			C.QStackedWidget_ConnectCurrentChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedWidget) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {
		C.QStackedWidget_DisconnectCurrentChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QStackedWidget) CurrentChanged(index int) {
	if ptr.Pointer() != nil {
		C.QStackedWidget_CurrentChanged(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QStackedWidget) RemoveWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStackedWidget_RemoveWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQStackedWidget_SetCurrentIndex
func callbackQStackedWidget_SetCurrentIndex(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQStackedWidgetFromPointer(ptr).SetCurrentIndexDefault(int(int32(index)))
	}
}

func (ptr *QStackedWidget) ConnectSetCurrentIndex(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentIndex"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedWidget) DisconnectSetCurrentIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentIndex")
	}
}

func (ptr *QStackedWidget) SetCurrentIndex(index int) {
	if ptr.Pointer() != nil {
		C.QStackedWidget_SetCurrentIndex(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QStackedWidget) SetCurrentIndexDefault(index int) {
	if ptr.Pointer() != nil {
		C.QStackedWidget_SetCurrentIndexDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQStackedWidget_SetCurrentWidget
func callbackQStackedWidget_SetCurrentWidget(ptr unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setCurrentWidget"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(widget))
	} else {
		NewQStackedWidgetFromPointer(ptr).SetCurrentWidgetDefault(NewQWidgetFromPointer(widget))
	}
}

func (ptr *QStackedWidget) ConnectSetCurrentWidget(f func(widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentWidget"); signal != nil {
			f := func(widget *QWidget) {
				(*(*func(*QWidget))(signal))(widget)
				f(widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedWidget) DisconnectSetCurrentWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentWidget")
	}
}

func (ptr *QStackedWidget) SetCurrentWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStackedWidget_SetCurrentWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QStackedWidget) SetCurrentWidgetDefault(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStackedWidget_SetCurrentWidgetDefault(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQStackedWidget_WidgetRemoved
func callbackQStackedWidget_WidgetRemoved(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "widgetRemoved"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QStackedWidget) ConnectWidgetRemoved(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "widgetRemoved") {
			C.QStackedWidget_ConnectWidgetRemoved(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "widgetRemoved"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "widgetRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "widgetRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedWidget) DisconnectWidgetRemoved() {
	if ptr.Pointer() != nil {
		C.QStackedWidget_DisconnectWidgetRemoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "widgetRemoved")
	}
}

func (ptr *QStackedWidget) WidgetRemoved(index int) {
	if ptr.Pointer() != nil {
		C.QStackedWidget_WidgetRemoved(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQStackedWidget_DestroyQStackedWidget
func callbackQStackedWidget_DestroyQStackedWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QStackedWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStackedWidgetFromPointer(ptr).DestroyQStackedWidgetDefault()
	}
}

func (ptr *QStackedWidget) ConnectDestroyQStackedWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QStackedWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QStackedWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QStackedWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStackedWidget) DisconnectDestroyQStackedWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QStackedWidget")
	}
}

func (ptr *QStackedWidget) DestroyQStackedWidget() {
	if ptr.Pointer() != nil {
		C.QStackedWidget_DestroyQStackedWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStackedWidget) DestroyQStackedWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QStackedWidget_DestroyQStackedWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStackedWidget) CurrentWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QStackedWidget_CurrentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStackedWidget) Widget(index int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QStackedWidget_Widget(ptr.Pointer(), C.int(int32(index))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStackedWidget) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedWidget_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStackedWidget) CurrentIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedWidget_CurrentIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStackedWidget) IndexOf(widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStackedWidget_IndexOf(ptr.Pointer(), PointerFromQWidget(widget))))
	}
	return 0
}

type QStandardItemEditorCreator struct {
	QItemEditorCreatorBase
}

type QStandardItemEditorCreator_ITF interface {
	QItemEditorCreatorBase_ITF
	QStandardItemEditorCreator_PTR() *QStandardItemEditorCreator
}

func (ptr *QStandardItemEditorCreator) QStandardItemEditorCreator_PTR() *QStandardItemEditorCreator {
	return ptr
}

func (ptr *QStandardItemEditorCreator) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QItemEditorCreatorBase_PTR().Pointer()
	}
	return nil
}

func (ptr *QStandardItemEditorCreator) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QItemEditorCreatorBase_PTR().SetPointer(p)
	}
}

func PointerFromQStandardItemEditorCreator(ptr QStandardItemEditorCreator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStandardItemEditorCreator_PTR().Pointer()
	}
	return nil
}

func NewQStandardItemEditorCreatorFromPointer(ptr unsafe.Pointer) (n *QStandardItemEditorCreator) {
	n = new(QStandardItemEditorCreator)
	n.SetPointer(ptr)
	return
}

func (ptr *QStandardItemEditorCreator) DestroyQStandardItemEditorCreator() {
	if ptr != nil {
		C.free(ptr.Pointer())
		qt.DisconnectAllSignals(ptr.Pointer(), "")
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QStatusBar struct {
	QWidget
}

type QStatusBar_ITF interface {
	QWidget_ITF
	QStatusBar_PTR() *QStatusBar
}

func (ptr *QStatusBar) QStatusBar_PTR() *QStatusBar {
	return ptr
}

func (ptr *QStatusBar) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QStatusBar) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQStatusBar(ptr QStatusBar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStatusBar_PTR().Pointer()
	}
	return nil
}

func NewQStatusBarFromPointer(ptr unsafe.Pointer) (n *QStatusBar) {
	n = new(QStatusBar)
	n.SetPointer(ptr)
	return
}
func NewQStatusBar(parent QWidget_ITF) *QStatusBar {
	tmpValue := NewQStatusBarFromPointer(C.QStatusBar_NewQStatusBar(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QStatusBar) InsertPermanentWidget(index int, widget QWidget_ITF, stretch int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStatusBar_InsertPermanentWidget(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(widget), C.int(int32(stretch)))))
	}
	return 0
}

func (ptr *QStatusBar) InsertWidget(index int, widget QWidget_ITF, stretch int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStatusBar_InsertWidget(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(widget), C.int(int32(stretch)))))
	}
	return 0
}

func (ptr *QStatusBar) AddPermanentWidget(widget QWidget_ITF, stretch int) {
	if ptr.Pointer() != nil {
		C.QStatusBar_AddPermanentWidget(ptr.Pointer(), PointerFromQWidget(widget), C.int(int32(stretch)))
	}
}

func (ptr *QStatusBar) AddWidget(widget QWidget_ITF, stretch int) {
	if ptr.Pointer() != nil {
		C.QStatusBar_AddWidget(ptr.Pointer(), PointerFromQWidget(widget), C.int(int32(stretch)))
	}
}

//export callbackQStatusBar_ClearMessage
func callbackQStatusBar_ClearMessage(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clearMessage"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStatusBarFromPointer(ptr).ClearMessageDefault()
	}
}

func (ptr *QStatusBar) ConnectClearMessage(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clearMessage"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clearMessage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clearMessage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStatusBar) DisconnectClearMessage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clearMessage")
	}
}

func (ptr *QStatusBar) ClearMessage() {
	if ptr.Pointer() != nil {
		C.QStatusBar_ClearMessage(ptr.Pointer())
	}
}

func (ptr *QStatusBar) ClearMessageDefault() {
	if ptr.Pointer() != nil {
		C.QStatusBar_ClearMessageDefault(ptr.Pointer())
	}
}

func (ptr *QStatusBar) HideOrShow() {
	if ptr.Pointer() != nil {
		C.QStatusBar_HideOrShow(ptr.Pointer())
	}
}

//export callbackQStatusBar_MessageChanged
func callbackQStatusBar_MessageChanged(ptr unsafe.Pointer, message C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "messageChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(message))
	}

}

func (ptr *QStatusBar) ConnectMessageChanged(f func(message string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "messageChanged") {
			C.QStatusBar_ConnectMessageChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "messageChanged"); signal != nil {
			f := func(message string) {
				(*(*func(string))(signal))(message)
				f(message)
			}
			qt.ConnectSignal(ptr.Pointer(), "messageChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "messageChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStatusBar) DisconnectMessageChanged() {
	if ptr.Pointer() != nil {
		C.QStatusBar_DisconnectMessageChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "messageChanged")
	}
}

func (ptr *QStatusBar) MessageChanged(message string) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QStatusBar_MessageChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))})
	}
}

func (ptr *QStatusBar) Reformat() {
	if ptr.Pointer() != nil {
		C.QStatusBar_Reformat(ptr.Pointer())
	}
}

func (ptr *QStatusBar) RemoveWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStatusBar_RemoveWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QStatusBar) SetSizeGripEnabled(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStatusBar_SetSizeGripEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

//export callbackQStatusBar_ShowMessage
func callbackQStatusBar_ShowMessage(ptr unsafe.Pointer, message C.struct_QtWidgets_PackedString, timeout C.int) {
	if signal := qt.GetSignal(ptr, "showMessage"); signal != nil {
		(*(*func(string, int))(signal))(cGoUnpackString(message), int(int32(timeout)))
	} else {
		NewQStatusBarFromPointer(ptr).ShowMessageDefault(cGoUnpackString(message), int(int32(timeout)))
	}
}

func (ptr *QStatusBar) ConnectShowMessage(f func(message string, timeout int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMessage"); signal != nil {
			f := func(message string, timeout int) {
				(*(*func(string, int))(signal))(message, timeout)
				f(message, timeout)
			}
			qt.ConnectSignal(ptr.Pointer(), "showMessage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMessage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStatusBar) DisconnectShowMessage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMessage")
	}
}

func (ptr *QStatusBar) ShowMessage(message string, timeout int) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QStatusBar_ShowMessage(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, C.int(int32(timeout)))
	}
}

func (ptr *QStatusBar) ShowMessageDefault(message string, timeout int) {
	if ptr.Pointer() != nil {
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QStatusBar_ShowMessageDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, C.int(int32(timeout)))
	}
}

//export callbackQStatusBar_DestroyQStatusBar
func callbackQStatusBar_DestroyQStatusBar(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QStatusBar"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStatusBarFromPointer(ptr).DestroyQStatusBarDefault()
	}
}

func (ptr *QStatusBar) ConnectDestroyQStatusBar(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QStatusBar"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QStatusBar", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QStatusBar", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStatusBar) DisconnectDestroyQStatusBar() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QStatusBar")
	}
}

func (ptr *QStatusBar) DestroyQStatusBar() {
	if ptr.Pointer() != nil {
		C.QStatusBar_DestroyQStatusBar(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStatusBar) DestroyQStatusBarDefault() {
	if ptr.Pointer() != nil {
		C.QStatusBar_DestroyQStatusBarDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStatusBar) CurrentMessage() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStatusBar_CurrentMessage(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStatusBar) IsSizeGripEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStatusBar_IsSizeGripEnabled(ptr.Pointer())) != 0
	}
	return false
}

type QStyle struct {
	core.QObject
}

type QStyle_ITF interface {
	core.QObject_ITF
	QStyle_PTR() *QStyle
}

func (ptr *QStyle) QStyle_PTR() *QStyle {
	return ptr
}

func (ptr *QStyle) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyle) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQStyle(ptr QStyle_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyle_PTR().Pointer()
	}
	return nil
}

func NewQStyleFromPointer(ptr unsafe.Pointer) (n *QStyle) {
	n = new(QStyle)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QStyle__ComplexControl
//QStyle::ComplexControl
type QStyle__ComplexControl int64

const (
	QStyle__CC_SpinBox     QStyle__ComplexControl = QStyle__ComplexControl(0)
	QStyle__CC_ComboBox    QStyle__ComplexControl = QStyle__ComplexControl(1)
	QStyle__CC_ScrollBar   QStyle__ComplexControl = QStyle__ComplexControl(2)
	QStyle__CC_Slider      QStyle__ComplexControl = QStyle__ComplexControl(3)
	QStyle__CC_ToolButton  QStyle__ComplexControl = QStyle__ComplexControl(4)
	QStyle__CC_TitleBar    QStyle__ComplexControl = QStyle__ComplexControl(5)
	QStyle__CC_Dial        QStyle__ComplexControl = QStyle__ComplexControl(6)
	QStyle__CC_GroupBox    QStyle__ComplexControl = QStyle__ComplexControl(7)
	QStyle__CC_MdiControls QStyle__ComplexControl = QStyle__ComplexControl(8)
	QStyle__CC_CustomBase  QStyle__ComplexControl = QStyle__ComplexControl(0xf0000000)
)

//go:generate stringer -type=QStyle__ContentsType
//QStyle::ContentsType
type QStyle__ContentsType int64

const (
	QStyle__CT_PushButton    QStyle__ContentsType = QStyle__ContentsType(0)
	QStyle__CT_CheckBox      QStyle__ContentsType = QStyle__ContentsType(1)
	QStyle__CT_RadioButton   QStyle__ContentsType = QStyle__ContentsType(2)
	QStyle__CT_ToolButton    QStyle__ContentsType = QStyle__ContentsType(3)
	QStyle__CT_ComboBox      QStyle__ContentsType = QStyle__ContentsType(4)
	QStyle__CT_Splitter      QStyle__ContentsType = QStyle__ContentsType(5)
	QStyle__CT_ProgressBar   QStyle__ContentsType = QStyle__ContentsType(6)
	QStyle__CT_MenuItem      QStyle__ContentsType = QStyle__ContentsType(7)
	QStyle__CT_MenuBarItem   QStyle__ContentsType = QStyle__ContentsType(8)
	QStyle__CT_MenuBar       QStyle__ContentsType = QStyle__ContentsType(9)
	QStyle__CT_Menu          QStyle__ContentsType = QStyle__ContentsType(10)
	QStyle__CT_TabBarTab     QStyle__ContentsType = QStyle__ContentsType(11)
	QStyle__CT_Slider        QStyle__ContentsType = QStyle__ContentsType(12)
	QStyle__CT_ScrollBar     QStyle__ContentsType = QStyle__ContentsType(13)
	QStyle__CT_LineEdit      QStyle__ContentsType = QStyle__ContentsType(14)
	QStyle__CT_SpinBox       QStyle__ContentsType = QStyle__ContentsType(15)
	QStyle__CT_SizeGrip      QStyle__ContentsType = QStyle__ContentsType(16)
	QStyle__CT_TabWidget     QStyle__ContentsType = QStyle__ContentsType(17)
	QStyle__CT_DialogButtons QStyle__ContentsType = QStyle__ContentsType(18)
	QStyle__CT_HeaderSection QStyle__ContentsType = QStyle__ContentsType(19)
	QStyle__CT_GroupBox      QStyle__ContentsType = QStyle__ContentsType(20)
	QStyle__CT_MdiControls   QStyle__ContentsType = QStyle__ContentsType(21)
	QStyle__CT_ItemViewItem  QStyle__ContentsType = QStyle__ContentsType(22)
	QStyle__CT_CustomBase    QStyle__ContentsType = QStyle__ContentsType(0xf0000000)
)

//go:generate stringer -type=QStyle__ControlElement
//QStyle::ControlElement
type QStyle__ControlElement int64

const (
	QStyle__CE_PushButton          QStyle__ControlElement = QStyle__ControlElement(0)
	QStyle__CE_PushButtonBevel     QStyle__ControlElement = QStyle__ControlElement(1)
	QStyle__CE_PushButtonLabel     QStyle__ControlElement = QStyle__ControlElement(2)
	QStyle__CE_CheckBox            QStyle__ControlElement = QStyle__ControlElement(3)
	QStyle__CE_CheckBoxLabel       QStyle__ControlElement = QStyle__ControlElement(4)
	QStyle__CE_RadioButton         QStyle__ControlElement = QStyle__ControlElement(5)
	QStyle__CE_RadioButtonLabel    QStyle__ControlElement = QStyle__ControlElement(6)
	QStyle__CE_TabBarTab           QStyle__ControlElement = QStyle__ControlElement(7)
	QStyle__CE_TabBarTabShape      QStyle__ControlElement = QStyle__ControlElement(8)
	QStyle__CE_TabBarTabLabel      QStyle__ControlElement = QStyle__ControlElement(9)
	QStyle__CE_ProgressBar         QStyle__ControlElement = QStyle__ControlElement(10)
	QStyle__CE_ProgressBarGroove   QStyle__ControlElement = QStyle__ControlElement(11)
	QStyle__CE_ProgressBarContents QStyle__ControlElement = QStyle__ControlElement(12)
	QStyle__CE_ProgressBarLabel    QStyle__ControlElement = QStyle__ControlElement(13)
	QStyle__CE_MenuItem            QStyle__ControlElement = QStyle__ControlElement(14)
	QStyle__CE_MenuScroller        QStyle__ControlElement = QStyle__ControlElement(15)
	QStyle__CE_MenuVMargin         QStyle__ControlElement = QStyle__ControlElement(16)
	QStyle__CE_MenuHMargin         QStyle__ControlElement = QStyle__ControlElement(17)
	QStyle__CE_MenuTearoff         QStyle__ControlElement = QStyle__ControlElement(18)
	QStyle__CE_MenuEmptyArea       QStyle__ControlElement = QStyle__ControlElement(19)
	QStyle__CE_MenuBarItem         QStyle__ControlElement = QStyle__ControlElement(20)
	QStyle__CE_MenuBarEmptyArea    QStyle__ControlElement = QStyle__ControlElement(21)
	QStyle__CE_ToolButtonLabel     QStyle__ControlElement = QStyle__ControlElement(22)
	QStyle__CE_Header              QStyle__ControlElement = QStyle__ControlElement(23)
	QStyle__CE_HeaderSection       QStyle__ControlElement = QStyle__ControlElement(24)
	QStyle__CE_HeaderLabel         QStyle__ControlElement = QStyle__ControlElement(25)
	QStyle__CE_ToolBoxTab          QStyle__ControlElement = QStyle__ControlElement(26)
	QStyle__CE_SizeGrip            QStyle__ControlElement = QStyle__ControlElement(27)
	QStyle__CE_Splitter            QStyle__ControlElement = QStyle__ControlElement(28)
	QStyle__CE_RubberBand          QStyle__ControlElement = QStyle__ControlElement(29)
	QStyle__CE_DockWidgetTitle     QStyle__ControlElement = QStyle__ControlElement(30)
	QStyle__CE_ScrollBarAddLine    QStyle__ControlElement = QStyle__ControlElement(31)
	QStyle__CE_ScrollBarSubLine    QStyle__ControlElement = QStyle__ControlElement(32)
	QStyle__CE_ScrollBarAddPage    QStyle__ControlElement = QStyle__ControlElement(33)
	QStyle__CE_ScrollBarSubPage    QStyle__ControlElement = QStyle__ControlElement(34)
	QStyle__CE_ScrollBarSlider     QStyle__ControlElement = QStyle__ControlElement(35)
	QStyle__CE_ScrollBarFirst      QStyle__ControlElement = QStyle__ControlElement(36)
	QStyle__CE_ScrollBarLast       QStyle__ControlElement = QStyle__ControlElement(37)
	QStyle__CE_FocusFrame          QStyle__ControlElement = QStyle__ControlElement(38)
	QStyle__CE_ComboBoxLabel       QStyle__ControlElement = QStyle__ControlElement(39)
	QStyle__CE_ToolBar             QStyle__ControlElement = QStyle__ControlElement(40)
	QStyle__CE_ToolBoxTabShape     QStyle__ControlElement = QStyle__ControlElement(41)
	QStyle__CE_ToolBoxTabLabel     QStyle__ControlElement = QStyle__ControlElement(42)
	QStyle__CE_HeaderEmptyArea     QStyle__ControlElement = QStyle__ControlElement(43)
	QStyle__CE_ColumnViewGrip      QStyle__ControlElement = QStyle__ControlElement(44)
	QStyle__CE_ItemViewItem        QStyle__ControlElement = QStyle__ControlElement(45)
	QStyle__CE_ShapedFrame         QStyle__ControlElement = QStyle__ControlElement(46)
	QStyle__CE_CustomBase          QStyle__ControlElement = QStyle__ControlElement(0xf0000000)
)

//go:generate stringer -type=QStyle__PixelMetric
//QStyle::PixelMetric
type QStyle__PixelMetric int64

const (
	QStyle__PM_ButtonMargin                       QStyle__PixelMetric = QStyle__PixelMetric(0)
	QStyle__PM_ButtonDefaultIndicator             QStyle__PixelMetric = QStyle__PixelMetric(1)
	QStyle__PM_MenuButtonIndicator                QStyle__PixelMetric = QStyle__PixelMetric(2)
	QStyle__PM_ButtonShiftHorizontal              QStyle__PixelMetric = QStyle__PixelMetric(3)
	QStyle__PM_ButtonShiftVertical                QStyle__PixelMetric = QStyle__PixelMetric(4)
	QStyle__PM_DefaultFrameWidth                  QStyle__PixelMetric = QStyle__PixelMetric(5)
	QStyle__PM_SpinBoxFrameWidth                  QStyle__PixelMetric = QStyle__PixelMetric(6)
	QStyle__PM_ComboBoxFrameWidth                 QStyle__PixelMetric = QStyle__PixelMetric(7)
	QStyle__PM_MaximumDragDistance                QStyle__PixelMetric = QStyle__PixelMetric(8)
	QStyle__PM_ScrollBarExtent                    QStyle__PixelMetric = QStyle__PixelMetric(9)
	QStyle__PM_ScrollBarSliderMin                 QStyle__PixelMetric = QStyle__PixelMetric(10)
	QStyle__PM_SliderThickness                    QStyle__PixelMetric = QStyle__PixelMetric(11)
	QStyle__PM_SliderControlThickness             QStyle__PixelMetric = QStyle__PixelMetric(12)
	QStyle__PM_SliderLength                       QStyle__PixelMetric = QStyle__PixelMetric(13)
	QStyle__PM_SliderTickmarkOffset               QStyle__PixelMetric = QStyle__PixelMetric(14)
	QStyle__PM_SliderSpaceAvailable               QStyle__PixelMetric = QStyle__PixelMetric(15)
	QStyle__PM_DockWidgetSeparatorExtent          QStyle__PixelMetric = QStyle__PixelMetric(16)
	QStyle__PM_DockWidgetHandleExtent             QStyle__PixelMetric = QStyle__PixelMetric(17)
	QStyle__PM_DockWidgetFrameWidth               QStyle__PixelMetric = QStyle__PixelMetric(18)
	QStyle__PM_TabBarTabOverlap                   QStyle__PixelMetric = QStyle__PixelMetric(19)
	QStyle__PM_TabBarTabHSpace                    QStyle__PixelMetric = QStyle__PixelMetric(20)
	QStyle__PM_TabBarTabVSpace                    QStyle__PixelMetric = QStyle__PixelMetric(21)
	QStyle__PM_TabBarBaseHeight                   QStyle__PixelMetric = QStyle__PixelMetric(22)
	QStyle__PM_TabBarBaseOverlap                  QStyle__PixelMetric = QStyle__PixelMetric(23)
	QStyle__PM_ProgressBarChunkWidth              QStyle__PixelMetric = QStyle__PixelMetric(24)
	QStyle__PM_SplitterWidth                      QStyle__PixelMetric = QStyle__PixelMetric(25)
	QStyle__PM_TitleBarHeight                     QStyle__PixelMetric = QStyle__PixelMetric(26)
	QStyle__PM_MenuScrollerHeight                 QStyle__PixelMetric = QStyle__PixelMetric(27)
	QStyle__PM_MenuHMargin                        QStyle__PixelMetric = QStyle__PixelMetric(28)
	QStyle__PM_MenuVMargin                        QStyle__PixelMetric = QStyle__PixelMetric(29)
	QStyle__PM_MenuPanelWidth                     QStyle__PixelMetric = QStyle__PixelMetric(30)
	QStyle__PM_MenuTearoffHeight                  QStyle__PixelMetric = QStyle__PixelMetric(31)
	QStyle__PM_MenuDesktopFrameWidth              QStyle__PixelMetric = QStyle__PixelMetric(32)
	QStyle__PM_MenuBarPanelWidth                  QStyle__PixelMetric = QStyle__PixelMetric(33)
	QStyle__PM_MenuBarItemSpacing                 QStyle__PixelMetric = QStyle__PixelMetric(34)
	QStyle__PM_MenuBarVMargin                     QStyle__PixelMetric = QStyle__PixelMetric(35)
	QStyle__PM_MenuBarHMargin                     QStyle__PixelMetric = QStyle__PixelMetric(36)
	QStyle__PM_IndicatorWidth                     QStyle__PixelMetric = QStyle__PixelMetric(37)
	QStyle__PM_IndicatorHeight                    QStyle__PixelMetric = QStyle__PixelMetric(38)
	QStyle__PM_ExclusiveIndicatorWidth            QStyle__PixelMetric = QStyle__PixelMetric(39)
	QStyle__PM_ExclusiveIndicatorHeight           QStyle__PixelMetric = QStyle__PixelMetric(40)
	QStyle__PM_DialogButtonsSeparator             QStyle__PixelMetric = QStyle__PixelMetric(41)
	QStyle__PM_DialogButtonsButtonWidth           QStyle__PixelMetric = QStyle__PixelMetric(42)
	QStyle__PM_DialogButtonsButtonHeight          QStyle__PixelMetric = QStyle__PixelMetric(43)
	QStyle__PM_MdiSubWindowFrameWidth             QStyle__PixelMetric = QStyle__PixelMetric(44)
	QStyle__PM_MDIFrameWidth                      QStyle__PixelMetric = QStyle__PixelMetric(QStyle__PM_MdiSubWindowFrameWidth)
	QStyle__PM_MdiSubWindowMinimizedWidth         QStyle__PixelMetric = QStyle__PixelMetric(45)
	QStyle__PM_MDIMinimizedWidth                  QStyle__PixelMetric = QStyle__PixelMetric(QStyle__PM_MdiSubWindowMinimizedWidth)
	QStyle__PM_HeaderMargin                       QStyle__PixelMetric = QStyle__PixelMetric(46)
	QStyle__PM_HeaderMarkSize                     QStyle__PixelMetric = QStyle__PixelMetric(47)
	QStyle__PM_HeaderGripMargin                   QStyle__PixelMetric = QStyle__PixelMetric(48)
	QStyle__PM_TabBarTabShiftHorizontal           QStyle__PixelMetric = QStyle__PixelMetric(49)
	QStyle__PM_TabBarTabShiftVertical             QStyle__PixelMetric = QStyle__PixelMetric(50)
	QStyle__PM_TabBarScrollButtonWidth            QStyle__PixelMetric = QStyle__PixelMetric(51)
	QStyle__PM_ToolBarFrameWidth                  QStyle__PixelMetric = QStyle__PixelMetric(52)
	QStyle__PM_ToolBarHandleExtent                QStyle__PixelMetric = QStyle__PixelMetric(53)
	QStyle__PM_ToolBarItemSpacing                 QStyle__PixelMetric = QStyle__PixelMetric(54)
	QStyle__PM_ToolBarItemMargin                  QStyle__PixelMetric = QStyle__PixelMetric(55)
	QStyle__PM_ToolBarSeparatorExtent             QStyle__PixelMetric = QStyle__PixelMetric(56)
	QStyle__PM_ToolBarExtensionExtent             QStyle__PixelMetric = QStyle__PixelMetric(57)
	QStyle__PM_SpinBoxSliderHeight                QStyle__PixelMetric = QStyle__PixelMetric(58)
	QStyle__PM_DefaultTopLevelMargin              QStyle__PixelMetric = QStyle__PixelMetric(59)
	QStyle__PM_DefaultChildMargin                 QStyle__PixelMetric = QStyle__PixelMetric(60)
	QStyle__PM_DefaultLayoutSpacing               QStyle__PixelMetric = QStyle__PixelMetric(61)
	QStyle__PM_ToolBarIconSize                    QStyle__PixelMetric = QStyle__PixelMetric(62)
	QStyle__PM_ListViewIconSize                   QStyle__PixelMetric = QStyle__PixelMetric(63)
	QStyle__PM_IconViewIconSize                   QStyle__PixelMetric = QStyle__PixelMetric(64)
	QStyle__PM_SmallIconSize                      QStyle__PixelMetric = QStyle__PixelMetric(65)
	QStyle__PM_LargeIconSize                      QStyle__PixelMetric = QStyle__PixelMetric(66)
	QStyle__PM_FocusFrameVMargin                  QStyle__PixelMetric = QStyle__PixelMetric(67)
	QStyle__PM_FocusFrameHMargin                  QStyle__PixelMetric = QStyle__PixelMetric(68)
	QStyle__PM_ToolTipLabelFrameWidth             QStyle__PixelMetric = QStyle__PixelMetric(69)
	QStyle__PM_CheckBoxLabelSpacing               QStyle__PixelMetric = QStyle__PixelMetric(70)
	QStyle__PM_TabBarIconSize                     QStyle__PixelMetric = QStyle__PixelMetric(71)
	QStyle__PM_SizeGripSize                       QStyle__PixelMetric = QStyle__PixelMetric(72)
	QStyle__PM_DockWidgetTitleMargin              QStyle__PixelMetric = QStyle__PixelMetric(73)
	QStyle__PM_MessageBoxIconSize                 QStyle__PixelMetric = QStyle__PixelMetric(74)
	QStyle__PM_ButtonIconSize                     QStyle__PixelMetric = QStyle__PixelMetric(75)
	QStyle__PM_DockWidgetTitleBarButtonMargin     QStyle__PixelMetric = QStyle__PixelMetric(76)
	QStyle__PM_RadioButtonLabelSpacing            QStyle__PixelMetric = QStyle__PixelMetric(77)
	QStyle__PM_LayoutLeftMargin                   QStyle__PixelMetric = QStyle__PixelMetric(78)
	QStyle__PM_LayoutTopMargin                    QStyle__PixelMetric = QStyle__PixelMetric(79)
	QStyle__PM_LayoutRightMargin                  QStyle__PixelMetric = QStyle__PixelMetric(80)
	QStyle__PM_LayoutBottomMargin                 QStyle__PixelMetric = QStyle__PixelMetric(81)
	QStyle__PM_LayoutHorizontalSpacing            QStyle__PixelMetric = QStyle__PixelMetric(82)
	QStyle__PM_LayoutVerticalSpacing              QStyle__PixelMetric = QStyle__PixelMetric(83)
	QStyle__PM_TabBar_ScrollButtonOverlap         QStyle__PixelMetric = QStyle__PixelMetric(84)
	QStyle__PM_TextCursorWidth                    QStyle__PixelMetric = QStyle__PixelMetric(85)
	QStyle__PM_TabCloseIndicatorWidth             QStyle__PixelMetric = QStyle__PixelMetric(86)
	QStyle__PM_TabCloseIndicatorHeight            QStyle__PixelMetric = QStyle__PixelMetric(87)
	QStyle__PM_ScrollView_ScrollBarSpacing        QStyle__PixelMetric = QStyle__PixelMetric(88)
	QStyle__PM_ScrollView_ScrollBarOverlap        QStyle__PixelMetric = QStyle__PixelMetric(89)
	QStyle__PM_SubMenuOverlap                     QStyle__PixelMetric = QStyle__PixelMetric(90)
	QStyle__PM_TreeViewIndentation                QStyle__PixelMetric = QStyle__PixelMetric(91)
	QStyle__PM_HeaderDefaultSectionSizeHorizontal QStyle__PixelMetric = QStyle__PixelMetric(92)
	QStyle__PM_HeaderDefaultSectionSizeVertical   QStyle__PixelMetric = QStyle__PixelMetric(93)
	QStyle__PM_TitleBarButtonIconSize             QStyle__PixelMetric = QStyle__PixelMetric(94)
	QStyle__PM_TitleBarButtonSize                 QStyle__PixelMetric = QStyle__PixelMetric(95)
	QStyle__PM_CustomBase                         QStyle__PixelMetric = QStyle__PixelMetric(0xf0000000)
)

//go:generate stringer -type=QStyle__PrimitiveElement
//QStyle::PrimitiveElement
type QStyle__PrimitiveElement int64

const (
	QStyle__PE_Frame                           QStyle__PrimitiveElement = QStyle__PrimitiveElement(0)
	QStyle__PE_FrameDefaultButton              QStyle__PrimitiveElement = QStyle__PrimitiveElement(1)
	QStyle__PE_FrameDockWidget                 QStyle__PrimitiveElement = QStyle__PrimitiveElement(2)
	QStyle__PE_FrameFocusRect                  QStyle__PrimitiveElement = QStyle__PrimitiveElement(3)
	QStyle__PE_FrameGroupBox                   QStyle__PrimitiveElement = QStyle__PrimitiveElement(4)
	QStyle__PE_FrameLineEdit                   QStyle__PrimitiveElement = QStyle__PrimitiveElement(5)
	QStyle__PE_FrameMenu                       QStyle__PrimitiveElement = QStyle__PrimitiveElement(6)
	QStyle__PE_FrameStatusBar                  QStyle__PrimitiveElement = QStyle__PrimitiveElement(7)
	QStyle__PE_FrameStatusBarItem              QStyle__PrimitiveElement = QStyle__PrimitiveElement(QStyle__PE_FrameStatusBar)
	QStyle__PE_FrameTabWidget                  QStyle__PrimitiveElement = QStyle__PrimitiveElement(8)
	QStyle__PE_FrameWindow                     QStyle__PrimitiveElement = QStyle__PrimitiveElement(9)
	QStyle__PE_FrameButtonBevel                QStyle__PrimitiveElement = QStyle__PrimitiveElement(10)
	QStyle__PE_FrameButtonTool                 QStyle__PrimitiveElement = QStyle__PrimitiveElement(11)
	QStyle__PE_FrameTabBarBase                 QStyle__PrimitiveElement = QStyle__PrimitiveElement(12)
	QStyle__PE_PanelButtonCommand              QStyle__PrimitiveElement = QStyle__PrimitiveElement(13)
	QStyle__PE_PanelButtonBevel                QStyle__PrimitiveElement = QStyle__PrimitiveElement(14)
	QStyle__PE_PanelButtonTool                 QStyle__PrimitiveElement = QStyle__PrimitiveElement(15)
	QStyle__PE_PanelMenuBar                    QStyle__PrimitiveElement = QStyle__PrimitiveElement(16)
	QStyle__PE_PanelToolBar                    QStyle__PrimitiveElement = QStyle__PrimitiveElement(17)
	QStyle__PE_PanelLineEdit                   QStyle__PrimitiveElement = QStyle__PrimitiveElement(18)
	QStyle__PE_IndicatorArrowDown              QStyle__PrimitiveElement = QStyle__PrimitiveElement(19)
	QStyle__PE_IndicatorArrowLeft              QStyle__PrimitiveElement = QStyle__PrimitiveElement(20)
	QStyle__PE_IndicatorArrowRight             QStyle__PrimitiveElement = QStyle__PrimitiveElement(21)
	QStyle__PE_IndicatorArrowUp                QStyle__PrimitiveElement = QStyle__PrimitiveElement(22)
	QStyle__PE_IndicatorBranch                 QStyle__PrimitiveElement = QStyle__PrimitiveElement(23)
	QStyle__PE_IndicatorButtonDropDown         QStyle__PrimitiveElement = QStyle__PrimitiveElement(24)
	QStyle__PE_IndicatorViewItemCheck          QStyle__PrimitiveElement = QStyle__PrimitiveElement(25)
	QStyle__PE_IndicatorItemViewItemCheck      QStyle__PrimitiveElement = QStyle__PrimitiveElement(QStyle__PE_IndicatorViewItemCheck)
	QStyle__PE_IndicatorCheckBox               QStyle__PrimitiveElement = QStyle__PrimitiveElement(26)
	QStyle__PE_IndicatorDockWidgetResizeHandle QStyle__PrimitiveElement = QStyle__PrimitiveElement(27)
	QStyle__PE_IndicatorHeaderArrow            QStyle__PrimitiveElement = QStyle__PrimitiveElement(28)
	QStyle__PE_IndicatorMenuCheckMark          QStyle__PrimitiveElement = QStyle__PrimitiveElement(29)
	QStyle__PE_IndicatorProgressChunk          QStyle__PrimitiveElement = QStyle__PrimitiveElement(30)
	QStyle__PE_IndicatorRadioButton            QStyle__PrimitiveElement = QStyle__PrimitiveElement(31)
	QStyle__PE_IndicatorSpinDown               QStyle__PrimitiveElement = QStyle__PrimitiveElement(32)
	QStyle__PE_IndicatorSpinMinus              QStyle__PrimitiveElement = QStyle__PrimitiveElement(33)
	QStyle__PE_IndicatorSpinPlus               QStyle__PrimitiveElement = QStyle__PrimitiveElement(34)
	QStyle__PE_IndicatorSpinUp                 QStyle__PrimitiveElement = QStyle__PrimitiveElement(35)
	QStyle__PE_IndicatorToolBarHandle          QStyle__PrimitiveElement = QStyle__PrimitiveElement(36)
	QStyle__PE_IndicatorToolBarSeparator       QStyle__PrimitiveElement = QStyle__PrimitiveElement(37)
	QStyle__PE_PanelTipLabel                   QStyle__PrimitiveElement = QStyle__PrimitiveElement(38)
	QStyle__PE_IndicatorTabTear                QStyle__PrimitiveElement = QStyle__PrimitiveElement(39)
	QStyle__PE_IndicatorTabTearLeft            QStyle__PrimitiveElement = QStyle__PrimitiveElement(QStyle__PE_IndicatorTabTear)
	QStyle__PE_PanelScrollAreaCorner           QStyle__PrimitiveElement = QStyle__PrimitiveElement(40)
	QStyle__PE_Widget                          QStyle__PrimitiveElement = QStyle__PrimitiveElement(41)
	QStyle__PE_IndicatorColumnViewArrow        QStyle__PrimitiveElement = QStyle__PrimitiveElement(42)
	QStyle__PE_IndicatorItemViewItemDrop       QStyle__PrimitiveElement = QStyle__PrimitiveElement(43)
	QStyle__PE_PanelItemViewItem               QStyle__PrimitiveElement = QStyle__PrimitiveElement(44)
	QStyle__PE_PanelItemViewRow                QStyle__PrimitiveElement = QStyle__PrimitiveElement(45)
	QStyle__PE_PanelStatusBar                  QStyle__PrimitiveElement = QStyle__PrimitiveElement(46)
	QStyle__PE_IndicatorTabClose               QStyle__PrimitiveElement = QStyle__PrimitiveElement(47)
	QStyle__PE_PanelMenu                       QStyle__PrimitiveElement = QStyle__PrimitiveElement(48)
	QStyle__PE_IndicatorTabTearRight           QStyle__PrimitiveElement = QStyle__PrimitiveElement(49)
	QStyle__PE_CustomBase                      QStyle__PrimitiveElement = QStyle__PrimitiveElement(0xf000000)
)

//go:generate stringer -type=QStyle__RequestSoftwareInputPanel
//QStyle::RequestSoftwareInputPanel
type QStyle__RequestSoftwareInputPanel int64

const (
	QStyle__RSIP_OnMouseClickAndAlreadyFocused QStyle__RequestSoftwareInputPanel = QStyle__RequestSoftwareInputPanel(0)
	QStyle__RSIP_OnMouseClick                  QStyle__RequestSoftwareInputPanel = QStyle__RequestSoftwareInputPanel(1)
)

//go:generate stringer -type=QStyle__StandardPixmap
//QStyle::StandardPixmap
type QStyle__StandardPixmap int64

const (
	QStyle__SP_TitleBarMenuButton               QStyle__StandardPixmap = QStyle__StandardPixmap(0)
	QStyle__SP_TitleBarMinButton                QStyle__StandardPixmap = QStyle__StandardPixmap(1)
	QStyle__SP_TitleBarMaxButton                QStyle__StandardPixmap = QStyle__StandardPixmap(2)
	QStyle__SP_TitleBarCloseButton              QStyle__StandardPixmap = QStyle__StandardPixmap(3)
	QStyle__SP_TitleBarNormalButton             QStyle__StandardPixmap = QStyle__StandardPixmap(4)
	QStyle__SP_TitleBarShadeButton              QStyle__StandardPixmap = QStyle__StandardPixmap(5)
	QStyle__SP_TitleBarUnshadeButton            QStyle__StandardPixmap = QStyle__StandardPixmap(6)
	QStyle__SP_TitleBarContextHelpButton        QStyle__StandardPixmap = QStyle__StandardPixmap(7)
	QStyle__SP_DockWidgetCloseButton            QStyle__StandardPixmap = QStyle__StandardPixmap(8)
	QStyle__SP_MessageBoxInformation            QStyle__StandardPixmap = QStyle__StandardPixmap(9)
	QStyle__SP_MessageBoxWarning                QStyle__StandardPixmap = QStyle__StandardPixmap(10)
	QStyle__SP_MessageBoxCritical               QStyle__StandardPixmap = QStyle__StandardPixmap(11)
	QStyle__SP_MessageBoxQuestion               QStyle__StandardPixmap = QStyle__StandardPixmap(12)
	QStyle__SP_DesktopIcon                      QStyle__StandardPixmap = QStyle__StandardPixmap(13)
	QStyle__SP_TrashIcon                        QStyle__StandardPixmap = QStyle__StandardPixmap(14)
	QStyle__SP_ComputerIcon                     QStyle__StandardPixmap = QStyle__StandardPixmap(15)
	QStyle__SP_DriveFDIcon                      QStyle__StandardPixmap = QStyle__StandardPixmap(16)
	QStyle__SP_DriveHDIcon                      QStyle__StandardPixmap = QStyle__StandardPixmap(17)
	QStyle__SP_DriveCDIcon                      QStyle__StandardPixmap = QStyle__StandardPixmap(18)
	QStyle__SP_DriveDVDIcon                     QStyle__StandardPixmap = QStyle__StandardPixmap(19)
	QStyle__SP_DriveNetIcon                     QStyle__StandardPixmap = QStyle__StandardPixmap(20)
	QStyle__SP_DirOpenIcon                      QStyle__StandardPixmap = QStyle__StandardPixmap(21)
	QStyle__SP_DirClosedIcon                    QStyle__StandardPixmap = QStyle__StandardPixmap(22)
	QStyle__SP_DirLinkIcon                      QStyle__StandardPixmap = QStyle__StandardPixmap(23)
	QStyle__SP_DirLinkOpenIcon                  QStyle__StandardPixmap = QStyle__StandardPixmap(24)
	QStyle__SP_FileIcon                         QStyle__StandardPixmap = QStyle__StandardPixmap(25)
	QStyle__SP_FileLinkIcon                     QStyle__StandardPixmap = QStyle__StandardPixmap(26)
	QStyle__SP_ToolBarHorizontalExtensionButton QStyle__StandardPixmap = QStyle__StandardPixmap(27)
	QStyle__SP_ToolBarVerticalExtensionButton   QStyle__StandardPixmap = QStyle__StandardPixmap(28)
	QStyle__SP_FileDialogStart                  QStyle__StandardPixmap = QStyle__StandardPixmap(29)
	QStyle__SP_FileDialogEnd                    QStyle__StandardPixmap = QStyle__StandardPixmap(30)
	QStyle__SP_FileDialogToParent               QStyle__StandardPixmap = QStyle__StandardPixmap(31)
	QStyle__SP_FileDialogNewFolder              QStyle__StandardPixmap = QStyle__StandardPixmap(32)
	QStyle__SP_FileDialogDetailedView           QStyle__StandardPixmap = QStyle__StandardPixmap(33)
	QStyle__SP_FileDialogInfoView               QStyle__StandardPixmap = QStyle__StandardPixmap(34)
	QStyle__SP_FileDialogContentsView           QStyle__StandardPixmap = QStyle__StandardPixmap(35)
	QStyle__SP_FileDialogListView               QStyle__StandardPixmap = QStyle__StandardPixmap(36)
	QStyle__SP_FileDialogBack                   QStyle__StandardPixmap = QStyle__StandardPixmap(37)
	QStyle__SP_DirIcon                          QStyle__StandardPixmap = QStyle__StandardPixmap(38)
	QStyle__SP_DialogOkButton                   QStyle__StandardPixmap = QStyle__StandardPixmap(39)
	QStyle__SP_DialogCancelButton               QStyle__StandardPixmap = QStyle__StandardPixmap(40)
	QStyle__SP_DialogHelpButton                 QStyle__StandardPixmap = QStyle__StandardPixmap(41)
	QStyle__SP_DialogOpenButton                 QStyle__StandardPixmap = QStyle__StandardPixmap(42)
	QStyle__SP_DialogSaveButton                 QStyle__StandardPixmap = QStyle__StandardPixmap(43)
	QStyle__SP_DialogCloseButton                QStyle__StandardPixmap = QStyle__StandardPixmap(44)
	QStyle__SP_DialogApplyButton                QStyle__StandardPixmap = QStyle__StandardPixmap(45)
	QStyle__SP_DialogResetButton                QStyle__StandardPixmap = QStyle__StandardPixmap(46)
	QStyle__SP_DialogDiscardButton              QStyle__StandardPixmap = QStyle__StandardPixmap(47)
	QStyle__SP_DialogYesButton                  QStyle__StandardPixmap = QStyle__StandardPixmap(48)
	QStyle__SP_DialogNoButton                   QStyle__StandardPixmap = QStyle__StandardPixmap(49)
	QStyle__SP_ArrowUp                          QStyle__StandardPixmap = QStyle__StandardPixmap(50)
	QStyle__SP_ArrowDown                        QStyle__StandardPixmap = QStyle__StandardPixmap(51)
	QStyle__SP_ArrowLeft                        QStyle__StandardPixmap = QStyle__StandardPixmap(52)
	QStyle__SP_ArrowRight                       QStyle__StandardPixmap = QStyle__StandardPixmap(53)
	QStyle__SP_ArrowBack                        QStyle__StandardPixmap = QStyle__StandardPixmap(54)
	QStyle__SP_ArrowForward                     QStyle__StandardPixmap = QStyle__StandardPixmap(55)
	QStyle__SP_DirHomeIcon                      QStyle__StandardPixmap = QStyle__StandardPixmap(56)
	QStyle__SP_CommandLink                      QStyle__StandardPixmap = QStyle__StandardPixmap(57)
	QStyle__SP_VistaShield                      QStyle__StandardPixmap = QStyle__StandardPixmap(58)
	QStyle__SP_BrowserReload                    QStyle__StandardPixmap = QStyle__StandardPixmap(59)
	QStyle__SP_BrowserStop                      QStyle__StandardPixmap = QStyle__StandardPixmap(60)
	QStyle__SP_MediaPlay                        QStyle__StandardPixmap = QStyle__StandardPixmap(61)
	QStyle__SP_MediaStop                        QStyle__StandardPixmap = QStyle__StandardPixmap(62)
	QStyle__SP_MediaPause                       QStyle__StandardPixmap = QStyle__StandardPixmap(63)
	QStyle__SP_MediaSkipForward                 QStyle__StandardPixmap = QStyle__StandardPixmap(64)
	QStyle__SP_MediaSkipBackward                QStyle__StandardPixmap = QStyle__StandardPixmap(65)
	QStyle__SP_MediaSeekForward                 QStyle__StandardPixmap = QStyle__StandardPixmap(66)
	QStyle__SP_MediaSeekBackward                QStyle__StandardPixmap = QStyle__StandardPixmap(67)
	QStyle__SP_MediaVolume                      QStyle__StandardPixmap = QStyle__StandardPixmap(68)
	QStyle__SP_MediaVolumeMuted                 QStyle__StandardPixmap = QStyle__StandardPixmap(69)
	QStyle__SP_LineEditClearButton              QStyle__StandardPixmap = QStyle__StandardPixmap(70)
	QStyle__SP_CustomBase                       QStyle__StandardPixmap = QStyle__StandardPixmap(0xf0000000)
)

//go:generate stringer -type=QStyle__StateFlag
//QStyle::StateFlag
type QStyle__StateFlag int64

const (
	QStyle__State_None                QStyle__StateFlag = QStyle__StateFlag(0x00000000)
	QStyle__State_Enabled             QStyle__StateFlag = QStyle__StateFlag(0x00000001)
	QStyle__State_Raised              QStyle__StateFlag = QStyle__StateFlag(0x00000002)
	QStyle__State_Sunken              QStyle__StateFlag = QStyle__StateFlag(0x00000004)
	QStyle__State_Off                 QStyle__StateFlag = QStyle__StateFlag(0x00000008)
	QStyle__State_NoChange            QStyle__StateFlag = QStyle__StateFlag(0x00000010)
	QStyle__State_On                  QStyle__StateFlag = QStyle__StateFlag(0x00000020)
	QStyle__State_DownArrow           QStyle__StateFlag = QStyle__StateFlag(0x00000040)
	QStyle__State_Horizontal          QStyle__StateFlag = QStyle__StateFlag(0x00000080)
	QStyle__State_HasFocus            QStyle__StateFlag = QStyle__StateFlag(0x00000100)
	QStyle__State_Top                 QStyle__StateFlag = QStyle__StateFlag(0x00000200)
	QStyle__State_Bottom              QStyle__StateFlag = QStyle__StateFlag(0x00000400)
	QStyle__State_FocusAtBorder       QStyle__StateFlag = QStyle__StateFlag(0x00000800)
	QStyle__State_AutoRaise           QStyle__StateFlag = QStyle__StateFlag(0x00001000)
	QStyle__State_MouseOver           QStyle__StateFlag = QStyle__StateFlag(0x00002000)
	QStyle__State_UpArrow             QStyle__StateFlag = QStyle__StateFlag(0x00004000)
	QStyle__State_Selected            QStyle__StateFlag = QStyle__StateFlag(0x00008000)
	QStyle__State_Active              QStyle__StateFlag = QStyle__StateFlag(0x00010000)
	QStyle__State_Window              QStyle__StateFlag = QStyle__StateFlag(0x00020000)
	QStyle__State_Open                QStyle__StateFlag = QStyle__StateFlag(0x00040000)
	QStyle__State_Children            QStyle__StateFlag = QStyle__StateFlag(0x00080000)
	QStyle__State_Item                QStyle__StateFlag = QStyle__StateFlag(0x00100000)
	QStyle__State_Sibling             QStyle__StateFlag = QStyle__StateFlag(0x00200000)
	QStyle__State_Editing             QStyle__StateFlag = QStyle__StateFlag(0x00400000)
	QStyle__State_KeyboardFocusChange QStyle__StateFlag = QStyle__StateFlag(0x00800000)
	QStyle__State_HasEditFocus        QStyle__StateFlag = QStyle__StateFlag(0x01000000)
	QStyle__State_ReadOnly            QStyle__StateFlag = QStyle__StateFlag(0x02000000)
	QStyle__State_Small               QStyle__StateFlag = QStyle__StateFlag(0x04000000)
	QStyle__State_Mini                QStyle__StateFlag = QStyle__StateFlag(0x08000000)
)

//go:generate stringer -type=QStyle__StyleHint
//QStyle::StyleHint
type QStyle__StyleHint int64

var (
	QStyle__SH_EtchDisabledText                               QStyle__StyleHint = QStyle__StyleHint(0)
	QStyle__SH_DitherDisabledText                             QStyle__StyleHint = QStyle__StyleHint(1)
	QStyle__SH_ScrollBar_MiddleClickAbsolutePosition          QStyle__StyleHint = QStyle__StyleHint(2)
	QStyle__SH_ScrollBar_ScrollWhenPointerLeavesControl       QStyle__StyleHint = QStyle__StyleHint(3)
	QStyle__SH_TabBar_SelectMouseType                         QStyle__StyleHint = QStyle__StyleHint(4)
	QStyle__SH_TabBar_Alignment                               QStyle__StyleHint = QStyle__StyleHint(5)
	QStyle__SH_Header_ArrowAlignment                          QStyle__StyleHint = QStyle__StyleHint(6)
	QStyle__SH_Slider_SnapToValue                             QStyle__StyleHint = QStyle__StyleHint(7)
	QStyle__SH_Slider_SloppyKeyEvents                         QStyle__StyleHint = QStyle__StyleHint(8)
	QStyle__SH_ProgressDialog_CenterCancelButton              QStyle__StyleHint = QStyle__StyleHint(9)
	QStyle__SH_ProgressDialog_TextLabelAlignment              QStyle__StyleHint = QStyle__StyleHint(10)
	QStyle__SH_PrintDialog_RightAlignButtons                  QStyle__StyleHint = QStyle__StyleHint(11)
	QStyle__SH_MainWindow_SpaceBelowMenuBar                   QStyle__StyleHint = QStyle__StyleHint(12)
	QStyle__SH_FontDialog_SelectAssociatedText                QStyle__StyleHint = QStyle__StyleHint(13)
	QStyle__SH_Menu_AllowActiveAndDisabled                    QStyle__StyleHint = QStyle__StyleHint(14)
	QStyle__SH_Menu_SpaceActivatesItem                        QStyle__StyleHint = QStyle__StyleHint(15)
	QStyle__SH_Menu_SubMenuPopupDelay                         QStyle__StyleHint = QStyle__StyleHint(16)
	QStyle__SH_ScrollView_FrameOnlyAroundContents             QStyle__StyleHint = QStyle__StyleHint(17)
	QStyle__SH_MenuBar_AltKeyNavigation                       QStyle__StyleHint = QStyle__StyleHint(18)
	QStyle__SH_ComboBox_ListMouseTracking                     QStyle__StyleHint = QStyle__StyleHint(19)
	QStyle__SH_Menu_MouseTracking                             QStyle__StyleHint = QStyle__StyleHint(20)
	QStyle__SH_MenuBar_MouseTracking                          QStyle__StyleHint = QStyle__StyleHint(21)
	QStyle__SH_ItemView_ChangeHighlightOnFocus                QStyle__StyleHint = QStyle__StyleHint(22)
	QStyle__SH_Widget_ShareActivation                         QStyle__StyleHint = QStyle__StyleHint(23)
	QStyle__SH_Workspace_FillSpaceOnMaximize                  QStyle__StyleHint = QStyle__StyleHint(24)
	QStyle__SH_ComboBox_Popup                                 QStyle__StyleHint = QStyle__StyleHint(25)
	QStyle__SH_TitleBar_NoBorder                              QStyle__StyleHint = QStyle__StyleHint(26)
	QStyle__SH_Slider_StopMouseOverSlider                     QStyle__StyleHint = QStyle__StyleHint(27)
	QStyle__SH_ScrollBar_StopMouseOverSlider                  QStyle__StyleHint = QStyle__StyleHint(QStyle__SH_Slider_StopMouseOverSlider)
	QStyle__SH_BlinkCursorWhenTextSelected                    QStyle__StyleHint = QStyle__StyleHint(28)
	QStyle__SH_RichText_FullWidthSelection                    QStyle__StyleHint = QStyle__StyleHint(29)
	QStyle__SH_Menu_Scrollable                                QStyle__StyleHint = QStyle__StyleHint(30)
	QStyle__SH_GroupBox_TextLabelVerticalAlignment            QStyle__StyleHint = QStyle__StyleHint(31)
	QStyle__SH_GroupBox_TextLabelColor                        QStyle__StyleHint = QStyle__StyleHint(32)
	QStyle__SH_Menu_SloppySubMenus                            QStyle__StyleHint = QStyle__StyleHint(33)
	QStyle__SH_Table_GridLineColor                            QStyle__StyleHint = QStyle__StyleHint(34)
	QStyle__SH_LineEdit_PasswordCharacter                     QStyle__StyleHint = QStyle__StyleHint(35)
	QStyle__SH_DialogButtons_DefaultButton                    QStyle__StyleHint = QStyle__StyleHint(36)
	QStyle__SH_ToolBox_SelectedPageTitleBold                  QStyle__StyleHint = QStyle__StyleHint(37)
	QStyle__SH_TabBar_PreferNoArrows                          QStyle__StyleHint = QStyle__StyleHint(38)
	QStyle__SH_ScrollBar_LeftClickAbsolutePosition            QStyle__StyleHint = QStyle__StyleHint(39)
	QStyle__SH_ListViewExpand_SelectMouseType                 QStyle__StyleHint = QStyle__StyleHint(40)
	QStyle__SH_UnderlineShortcut                              QStyle__StyleHint = QStyle__StyleHint(41)
	QStyle__SH_SpinBox_AnimateButton                          QStyle__StyleHint = QStyle__StyleHint(42)
	QStyle__SH_SpinBox_KeyPressAutoRepeatRate                 QStyle__StyleHint = QStyle__StyleHint(43)
	QStyle__SH_SpinBox_ClickAutoRepeatRate                    QStyle__StyleHint = QStyle__StyleHint(44)
	QStyle__SH_Menu_FillScreenWithScroll                      QStyle__StyleHint = QStyle__StyleHint(45)
	QStyle__SH_ToolTipLabel_Opacity                           QStyle__StyleHint = QStyle__StyleHint(46)
	QStyle__SH_DrawMenuBarSeparator                           QStyle__StyleHint = QStyle__StyleHint(47)
	QStyle__SH_TitleBar_ModifyNotification                    QStyle__StyleHint = QStyle__StyleHint(48)
	QStyle__SH_Button_FocusPolicy                             QStyle__StyleHint = QStyle__StyleHint(49)
	QStyle__SH_MessageBox_UseBorderForButtonSpacing           QStyle__StyleHint = QStyle__StyleHint(50)
	QStyle__SH_TitleBar_AutoRaise                             QStyle__StyleHint = QStyle__StyleHint(51)
	QStyle__SH_ToolButton_PopupDelay                          QStyle__StyleHint = QStyle__StyleHint(52)
	QStyle__SH_FocusFrame_Mask                                QStyle__StyleHint = QStyle__StyleHint(53)
	QStyle__SH_RubberBand_Mask                                QStyle__StyleHint = QStyle__StyleHint(54)
	QStyle__SH_WindowFrame_Mask                               QStyle__StyleHint = QStyle__StyleHint(55)
	QStyle__SH_SpinControls_DisableOnBounds                   QStyle__StyleHint = QStyle__StyleHint(56)
	QStyle__SH_Dial_BackgroundRole                            QStyle__StyleHint = QStyle__StyleHint(57)
	QStyle__SH_ComboBox_LayoutDirection                       QStyle__StyleHint = QStyle__StyleHint(58)
	QStyle__SH_ItemView_EllipsisLocation                      QStyle__StyleHint = QStyle__StyleHint(59)
	QStyle__SH_ItemView_ShowDecorationSelected                QStyle__StyleHint = QStyle__StyleHint(60)
	QStyle__SH_ItemView_ActivateItemOnSingleClick             QStyle__StyleHint = QStyle__StyleHint(61)
	QStyle__SH_ScrollBar_ContextMenu                          QStyle__StyleHint = QStyle__StyleHint(62)
	QStyle__SH_ScrollBar_RollBetweenButtons                   QStyle__StyleHint = QStyle__StyleHint(63)
	QStyle__SH_Slider_AbsoluteSetButtons                      QStyle__StyleHint = QStyle__StyleHint(64)
	QStyle__SH_Slider_PageSetButtons                          QStyle__StyleHint = QStyle__StyleHint(65)
	QStyle__SH_Menu_KeyboardSearch                            QStyle__StyleHint = QStyle__StyleHint(66)
	QStyle__SH_TabBar_ElideMode                               QStyle__StyleHint = QStyle__StyleHint(67)
	QStyle__SH_DialogButtonLayout                             QStyle__StyleHint = QStyle__StyleHint(68)
	QStyle__SH_ComboBox_PopupFrameStyle                       QStyle__StyleHint = QStyle__StyleHint(69)
	QStyle__SH_MessageBox_TextInteractionFlags                QStyle__StyleHint = QStyle__StyleHint(70)
	QStyle__SH_DialogButtonBox_ButtonsHaveIcons               QStyle__StyleHint = QStyle__StyleHint(71)
	QStyle__SH_SpellCheckUnderlineStyle                       QStyle__StyleHint = QStyle__StyleHint(72)
	QStyle__SH_MessageBox_CenterButtons                       QStyle__StyleHint = QStyle__StyleHint(73)
	QStyle__SH_Menu_SelectionWrap                             QStyle__StyleHint = QStyle__StyleHint(74)
	QStyle__SH_ItemView_MovementWithoutUpdatingSelection      QStyle__StyleHint = QStyle__StyleHint(75)
	QStyle__SH_ToolTip_Mask                                   QStyle__StyleHint = QStyle__StyleHint(76)
	QStyle__SH_FocusFrame_AboveWidget                         QStyle__StyleHint = QStyle__StyleHint(77)
	QStyle__SH_TextControl_FocusIndicatorTextCharFormat       QStyle__StyleHint = QStyle__StyleHint(78)
	QStyle__SH_WizardStyle                                    QStyle__StyleHint = QStyle__StyleHint(79)
	QStyle__SH_ItemView_ArrowKeysNavigateIntoChildren         QStyle__StyleHint = QStyle__StyleHint(80)
	QStyle__SH_Menu_Mask                                      QStyle__StyleHint = QStyle__StyleHint(81)
	QStyle__SH_Menu_FlashTriggeredItem                        QStyle__StyleHint = QStyle__StyleHint(82)
	QStyle__SH_Menu_FadeOutOnHide                             QStyle__StyleHint = QStyle__StyleHint(83)
	QStyle__SH_SpinBox_ClickAutoRepeatThreshold               QStyle__StyleHint = QStyle__StyleHint(84)
	QStyle__SH_ItemView_PaintAlternatingRowColorsForEmptyArea QStyle__StyleHint = QStyle__StyleHint(85)
	QStyle__SH_FormLayoutWrapPolicy                           QStyle__StyleHint = QStyle__StyleHint(86)
	QStyle__SH_TabWidget_DefaultTabPosition                   QStyle__StyleHint = QStyle__StyleHint(87)
	QStyle__SH_ToolBar_Movable                                QStyle__StyleHint = QStyle__StyleHint(88)
	QStyle__SH_FormLayoutFieldGrowthPolicy                    QStyle__StyleHint = QStyle__StyleHint(89)
	QStyle__SH_FormLayoutFormAlignment                        QStyle__StyleHint = QStyle__StyleHint(90)
	QStyle__SH_FormLayoutLabelAlignment                       QStyle__StyleHint = QStyle__StyleHint(91)
	QStyle__SH_ItemView_DrawDelegateFrame                     QStyle__StyleHint = QStyle__StyleHint(92)
	QStyle__SH_TabBar_CloseButtonPosition                     QStyle__StyleHint = QStyle__StyleHint(93)
	QStyle__SH_DockWidget_ButtonsHaveFrame                    QStyle__StyleHint = QStyle__StyleHint(94)
	QStyle__SH_ToolButtonStyle                                QStyle__StyleHint = QStyle__StyleHint(95)
	QStyle__SH_RequestSoftwareInputPanel                      QStyle__StyleHint = QStyle__StyleHint(96)
	QStyle__SH_ScrollBar_Transient                            QStyle__StyleHint = QStyle__StyleHint(97)
	QStyle__SH_Menu_SupportsSections                          QStyle__StyleHint = QStyle__StyleHint(98)
	QStyle__SH_ToolTip_WakeUpDelay                            QStyle__StyleHint = QStyle__StyleHint(99)
	QStyle__SH_ToolTip_FallAsleepDelay                        QStyle__StyleHint = QStyle__StyleHint(100)
	QStyle__SH_Widget_Animate                                 QStyle__StyleHint = QStyle__StyleHint(101)
	QStyle__SH_Splitter_OpaqueResize                          QStyle__StyleHint = QStyle__StyleHint(102)
	QStyle__SH_ComboBox_UseNativePopup                        QStyle__StyleHint = QStyle__StyleHint(103)
	QStyle__SH_LineEdit_PasswordMaskDelay                     QStyle__StyleHint = QStyle__StyleHint(104)
	QStyle__SH_TabBar_ChangeCurrentDelay                      QStyle__StyleHint = QStyle__StyleHint(105)
	QStyle__SH_Menu_SubMenuUniDirection                       QStyle__StyleHint = QStyle__StyleHint(106)
	QStyle__SH_Menu_SubMenuUniDirectionFailCount              QStyle__StyleHint = QStyle__StyleHint(107)
	QStyle__SH_Menu_SubMenuSloppySelectOtherActions           QStyle__StyleHint = QStyle__StyleHint(108)
	QStyle__SH_Menu_SubMenuSloppyCloseTimeout                 QStyle__StyleHint = QStyle__StyleHint(109)
	QStyle__SH_Menu_SubMenuResetWhenReenteringParent          QStyle__StyleHint = QStyle__StyleHint(110)
	QStyle__SH_Menu_SubMenuDontStartSloppyOnLeave             QStyle__StyleHint = QStyle__StyleHint(111)
	QStyle__SH_ItemView_ScrollMode                            QStyle__StyleHint = QStyle__StyleHint(112)
	QStyle__SH_TitleBar_ShowToolTipsOnButtons                 QStyle__StyleHint = QStyle__StyleHint(113)
	QStyle__SH_Widget_Animation_Duration                      QStyle__StyleHint = QStyle__StyleHint(114)
	QStyle__SH_ComboBox_AllowWheelScrolling                   QStyle__StyleHint = QStyle__StyleHint(115)
	QStyle__SH_SpinBox_ButtonsInsideFrame                     QStyle__StyleHint = QStyle__StyleHint(116)
	QStyle__SH_SpinBox_StepModifier                           QStyle__StyleHint = QStyle__StyleHint(117)
	QStyle__SH_CustomBase                                     QStyle__StyleHint = QStyle__StyleHint(0xf0000000)
)

//go:generate stringer -type=QStyle__SubControl
//QStyle::SubControl
type QStyle__SubControl int64

const (
	QStyle__SC_None                      QStyle__SubControl = QStyle__SubControl(0x00000000)
	QStyle__SC_ScrollBarAddLine          QStyle__SubControl = QStyle__SubControl(0x00000001)
	QStyle__SC_ScrollBarSubLine          QStyle__SubControl = QStyle__SubControl(0x00000002)
	QStyle__SC_ScrollBarAddPage          QStyle__SubControl = QStyle__SubControl(0x00000004)
	QStyle__SC_ScrollBarSubPage          QStyle__SubControl = QStyle__SubControl(0x00000008)
	QStyle__SC_ScrollBarFirst            QStyle__SubControl = QStyle__SubControl(0x00000010)
	QStyle__SC_ScrollBarLast             QStyle__SubControl = QStyle__SubControl(0x00000020)
	QStyle__SC_ScrollBarSlider           QStyle__SubControl = QStyle__SubControl(0x00000040)
	QStyle__SC_ScrollBarGroove           QStyle__SubControl = QStyle__SubControl(0x00000080)
	QStyle__SC_SpinBoxUp                 QStyle__SubControl = QStyle__SubControl(0x00000001)
	QStyle__SC_SpinBoxDown               QStyle__SubControl = QStyle__SubControl(0x00000002)
	QStyle__SC_SpinBoxFrame              QStyle__SubControl = QStyle__SubControl(0x00000004)
	QStyle__SC_SpinBoxEditField          QStyle__SubControl = QStyle__SubControl(0x00000008)
	QStyle__SC_ComboBoxFrame             QStyle__SubControl = QStyle__SubControl(0x00000001)
	QStyle__SC_ComboBoxEditField         QStyle__SubControl = QStyle__SubControl(0x00000002)
	QStyle__SC_ComboBoxArrow             QStyle__SubControl = QStyle__SubControl(0x00000004)
	QStyle__SC_ComboBoxListBoxPopup      QStyle__SubControl = QStyle__SubControl(0x00000008)
	QStyle__SC_SliderGroove              QStyle__SubControl = QStyle__SubControl(0x00000001)
	QStyle__SC_SliderHandle              QStyle__SubControl = QStyle__SubControl(0x00000002)
	QStyle__SC_SliderTickmarks           QStyle__SubControl = QStyle__SubControl(0x00000004)
	QStyle__SC_ToolButton                QStyle__SubControl = QStyle__SubControl(0x00000001)
	QStyle__SC_ToolButtonMenu            QStyle__SubControl = QStyle__SubControl(0x00000002)
	QStyle__SC_TitleBarSysMenu           QStyle__SubControl = QStyle__SubControl(0x00000001)
	QStyle__SC_TitleBarMinButton         QStyle__SubControl = QStyle__SubControl(0x00000002)
	QStyle__SC_TitleBarMaxButton         QStyle__SubControl = QStyle__SubControl(0x00000004)
	QStyle__SC_TitleBarCloseButton       QStyle__SubControl = QStyle__SubControl(0x00000008)
	QStyle__SC_TitleBarNormalButton      QStyle__SubControl = QStyle__SubControl(0x00000010)
	QStyle__SC_TitleBarShadeButton       QStyle__SubControl = QStyle__SubControl(0x00000020)
	QStyle__SC_TitleBarUnshadeButton     QStyle__SubControl = QStyle__SubControl(0x00000040)
	QStyle__SC_TitleBarContextHelpButton QStyle__SubControl = QStyle__SubControl(0x00000080)
	QStyle__SC_TitleBarLabel             QStyle__SubControl = QStyle__SubControl(0x00000100)
	QStyle__SC_DialGroove                QStyle__SubControl = QStyle__SubControl(0x00000001)
	QStyle__SC_DialHandle                QStyle__SubControl = QStyle__SubControl(0x00000002)
	QStyle__SC_DialTickmarks             QStyle__SubControl = QStyle__SubControl(0x00000004)
	QStyle__SC_GroupBoxCheckBox          QStyle__SubControl = QStyle__SubControl(0x00000001)
	QStyle__SC_GroupBoxLabel             QStyle__SubControl = QStyle__SubControl(0x00000002)
	QStyle__SC_GroupBoxContents          QStyle__SubControl = QStyle__SubControl(0x00000004)
	QStyle__SC_GroupBoxFrame             QStyle__SubControl = QStyle__SubControl(0x00000008)
	QStyle__SC_MdiMinButton              QStyle__SubControl = QStyle__SubControl(0x00000001)
	QStyle__SC_MdiNormalButton           QStyle__SubControl = QStyle__SubControl(0x00000002)
	QStyle__SC_MdiCloseButton            QStyle__SubControl = QStyle__SubControl(0x00000004)
	QStyle__SC_CustomBase                QStyle__SubControl = QStyle__SubControl(0xf0000000)
	QStyle__SC_All                       QStyle__SubControl = QStyle__SubControl(0xffffffff)
)

//go:generate stringer -type=QStyle__SubElement
//QStyle::SubElement
type QStyle__SubElement int64

const (
	QStyle__SE_PushButtonContents         QStyle__SubElement = QStyle__SubElement(0)
	QStyle__SE_PushButtonFocusRect        QStyle__SubElement = QStyle__SubElement(1)
	QStyle__SE_CheckBoxIndicator          QStyle__SubElement = QStyle__SubElement(2)
	QStyle__SE_CheckBoxContents           QStyle__SubElement = QStyle__SubElement(3)
	QStyle__SE_CheckBoxFocusRect          QStyle__SubElement = QStyle__SubElement(4)
	QStyle__SE_CheckBoxClickRect          QStyle__SubElement = QStyle__SubElement(5)
	QStyle__SE_RadioButtonIndicator       QStyle__SubElement = QStyle__SubElement(6)
	QStyle__SE_RadioButtonContents        QStyle__SubElement = QStyle__SubElement(7)
	QStyle__SE_RadioButtonFocusRect       QStyle__SubElement = QStyle__SubElement(8)
	QStyle__SE_RadioButtonClickRect       QStyle__SubElement = QStyle__SubElement(9)
	QStyle__SE_ComboBoxFocusRect          QStyle__SubElement = QStyle__SubElement(10)
	QStyle__SE_SliderFocusRect            QStyle__SubElement = QStyle__SubElement(11)
	QStyle__SE_ProgressBarGroove          QStyle__SubElement = QStyle__SubElement(12)
	QStyle__SE_ProgressBarContents        QStyle__SubElement = QStyle__SubElement(13)
	QStyle__SE_ProgressBarLabel           QStyle__SubElement = QStyle__SubElement(14)
	QStyle__SE_ToolBoxTabContents         QStyle__SubElement = QStyle__SubElement(15)
	QStyle__SE_HeaderLabel                QStyle__SubElement = QStyle__SubElement(16)
	QStyle__SE_HeaderArrow                QStyle__SubElement = QStyle__SubElement(17)
	QStyle__SE_TabWidgetTabBar            QStyle__SubElement = QStyle__SubElement(18)
	QStyle__SE_TabWidgetTabPane           QStyle__SubElement = QStyle__SubElement(19)
	QStyle__SE_TabWidgetTabContents       QStyle__SubElement = QStyle__SubElement(20)
	QStyle__SE_TabWidgetLeftCorner        QStyle__SubElement = QStyle__SubElement(21)
	QStyle__SE_TabWidgetRightCorner       QStyle__SubElement = QStyle__SubElement(22)
	QStyle__SE_ViewItemCheckIndicator     QStyle__SubElement = QStyle__SubElement(23)
	QStyle__SE_ItemViewItemCheckIndicator QStyle__SubElement = QStyle__SubElement(QStyle__SE_ViewItemCheckIndicator)
	QStyle__SE_TabBarTearIndicator        QStyle__SubElement = QStyle__SubElement(24)
	QStyle__SE_TabBarTearIndicatorLeft    QStyle__SubElement = QStyle__SubElement(QStyle__SE_TabBarTearIndicator)
	QStyle__SE_TreeViewDisclosureItem     QStyle__SubElement = QStyle__SubElement(25)
	QStyle__SE_LineEditContents           QStyle__SubElement = QStyle__SubElement(26)
	QStyle__SE_FrameContents              QStyle__SubElement = QStyle__SubElement(27)
	QStyle__SE_DockWidgetCloseButton      QStyle__SubElement = QStyle__SubElement(28)
	QStyle__SE_DockWidgetFloatButton      QStyle__SubElement = QStyle__SubElement(29)
	QStyle__SE_DockWidgetTitleBarText     QStyle__SubElement = QStyle__SubElement(30)
	QStyle__SE_DockWidgetIcon             QStyle__SubElement = QStyle__SubElement(31)
	QStyle__SE_CheckBoxLayoutItem         QStyle__SubElement = QStyle__SubElement(32)
	QStyle__SE_ComboBoxLayoutItem         QStyle__SubElement = QStyle__SubElement(33)
	QStyle__SE_DateTimeEditLayoutItem     QStyle__SubElement = QStyle__SubElement(34)
	QStyle__SE_DialogButtonBoxLayoutItem  QStyle__SubElement = QStyle__SubElement(35)
	QStyle__SE_LabelLayoutItem            QStyle__SubElement = QStyle__SubElement(36)
	QStyle__SE_ProgressBarLayoutItem      QStyle__SubElement = QStyle__SubElement(37)
	QStyle__SE_PushButtonLayoutItem       QStyle__SubElement = QStyle__SubElement(38)
	QStyle__SE_RadioButtonLayoutItem      QStyle__SubElement = QStyle__SubElement(39)
	QStyle__SE_SliderLayoutItem           QStyle__SubElement = QStyle__SubElement(40)
	QStyle__SE_SpinBoxLayoutItem          QStyle__SubElement = QStyle__SubElement(41)
	QStyle__SE_ToolButtonLayoutItem       QStyle__SubElement = QStyle__SubElement(42)
	QStyle__SE_FrameLayoutItem            QStyle__SubElement = QStyle__SubElement(43)
	QStyle__SE_GroupBoxLayoutItem         QStyle__SubElement = QStyle__SubElement(44)
	QStyle__SE_TabWidgetLayoutItem        QStyle__SubElement = QStyle__SubElement(45)
	QStyle__SE_ItemViewItemDecoration     QStyle__SubElement = QStyle__SubElement(46)
	QStyle__SE_ItemViewItemText           QStyle__SubElement = QStyle__SubElement(47)
	QStyle__SE_ItemViewItemFocusRect      QStyle__SubElement = QStyle__SubElement(48)
	QStyle__SE_TabBarTabLeftButton        QStyle__SubElement = QStyle__SubElement(49)
	QStyle__SE_TabBarTabRightButton       QStyle__SubElement = QStyle__SubElement(50)
	QStyle__SE_TabBarTabText              QStyle__SubElement = QStyle__SubElement(51)
	QStyle__SE_ShapedFrameContents        QStyle__SubElement = QStyle__SubElement(52)
	QStyle__SE_ToolBarHandle              QStyle__SubElement = QStyle__SubElement(53)
	QStyle__SE_TabBarScrollLeftButton     QStyle__SubElement = QStyle__SubElement(54)
	QStyle__SE_TabBarScrollRightButton    QStyle__SubElement = QStyle__SubElement(55)
	QStyle__SE_TabBarTearIndicatorRight   QStyle__SubElement = QStyle__SubElement(56)
	QStyle__SE_CustomBase                 QStyle__SubElement = QStyle__SubElement(0xf0000000)
)

func QStyle_VisualPos(direction core.Qt__LayoutDirection, boundingRectangle core.QRect_ITF, logicalPosition core.QPoint_ITF) *core.QPoint {
	tmpValue := core.NewQPointFromPointer(C.QStyle_QStyle_VisualPos(C.longlong(direction), core.PointerFromQRect(boundingRectangle), core.PointerFromQPoint(logicalPosition)))
	runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
	return tmpValue
}

func (ptr *QStyle) VisualPos(direction core.Qt__LayoutDirection, boundingRectangle core.QRect_ITF, logicalPosition core.QPoint_ITF) *core.QPoint {
	tmpValue := core.NewQPointFromPointer(C.QStyle_QStyle_VisualPos(C.longlong(direction), core.PointerFromQRect(boundingRectangle), core.PointerFromQPoint(logicalPosition)))
	runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
	return tmpValue
}

func QStyle_AlignedRect(direction core.Qt__LayoutDirection, alignment core.Qt__AlignmentFlag, size core.QSize_ITF, rectangle core.QRect_ITF) *core.QRect {
	tmpValue := core.NewQRectFromPointer(C.QStyle_QStyle_AlignedRect(C.longlong(direction), C.longlong(alignment), core.PointerFromQSize(size), core.PointerFromQRect(rectangle)))
	runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
	return tmpValue
}

func (ptr *QStyle) AlignedRect(direction core.Qt__LayoutDirection, alignment core.Qt__AlignmentFlag, size core.QSize_ITF, rectangle core.QRect_ITF) *core.QRect {
	tmpValue := core.NewQRectFromPointer(C.QStyle_QStyle_AlignedRect(C.longlong(direction), C.longlong(alignment), core.PointerFromQSize(size), core.PointerFromQRect(rectangle)))
	runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
	return tmpValue
}

func QStyle_VisualRect(direction core.Qt__LayoutDirection, boundingRectangle core.QRect_ITF, logicalRectangle core.QRect_ITF) *core.QRect {
	tmpValue := core.NewQRectFromPointer(C.QStyle_QStyle_VisualRect(C.longlong(direction), core.PointerFromQRect(boundingRectangle), core.PointerFromQRect(logicalRectangle)))
	runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
	return tmpValue
}

func (ptr *QStyle) VisualRect(direction core.Qt__LayoutDirection, boundingRectangle core.QRect_ITF, logicalRectangle core.QRect_ITF) *core.QRect {
	tmpValue := core.NewQRectFromPointer(C.QStyle_QStyle_VisualRect(C.longlong(direction), core.PointerFromQRect(boundingRectangle), core.PointerFromQRect(logicalRectangle)))
	runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
	return tmpValue
}

func QStyle_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QStyle_QStyle_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QStyle) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QStyle_QStyle_Tr(sC, cC, C.int(int32(n))))
}

func NewQStyle() *QStyle {
	tmpValue := NewQStyleFromPointer(C.QStyle_NewQStyle())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QStyle_VisualAlignment(direction core.Qt__LayoutDirection, alignment core.Qt__AlignmentFlag) core.Qt__AlignmentFlag {
	return core.Qt__AlignmentFlag(C.QStyle_QStyle_VisualAlignment(C.longlong(direction), C.longlong(alignment)))
}

func (ptr *QStyle) VisualAlignment(direction core.Qt__LayoutDirection, alignment core.Qt__AlignmentFlag) core.Qt__AlignmentFlag {
	return core.Qt__AlignmentFlag(C.QStyle_QStyle_VisualAlignment(C.longlong(direction), C.longlong(alignment)))
}

func QStyle_SliderPositionFromValue(min int, max int, logicalValue int, span int, upsideDown bool) int {
	return int(int32(C.QStyle_QStyle_SliderPositionFromValue(C.int(int32(min)), C.int(int32(max)), C.int(int32(logicalValue)), C.int(int32(span)), C.char(int8(qt.GoBoolToInt(upsideDown))))))
}

func (ptr *QStyle) SliderPositionFromValue(min int, max int, logicalValue int, span int, upsideDown bool) int {
	return int(int32(C.QStyle_QStyle_SliderPositionFromValue(C.int(int32(min)), C.int(int32(max)), C.int(int32(logicalValue)), C.int(int32(span)), C.char(int8(qt.GoBoolToInt(upsideDown))))))
}

func QStyle_SliderValueFromPosition(min int, max int, position int, span int, upsideDown bool) int {
	return int(int32(C.QStyle_QStyle_SliderValueFromPosition(C.int(int32(min)), C.int(int32(max)), C.int(int32(position)), C.int(int32(span)), C.char(int8(qt.GoBoolToInt(upsideDown))))))
}

func (ptr *QStyle) SliderValueFromPosition(min int, max int, position int, span int, upsideDown bool) int {
	return int(int32(C.QStyle_QStyle_SliderValueFromPosition(C.int(int32(min)), C.int(int32(max)), C.int(int32(position)), C.int(int32(span)), C.char(int8(qt.GoBoolToInt(upsideDown))))))
}

//export callbackQStyle_Polish2
func callbackQStyle_Polish2(ptr unsafe.Pointer, application unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "polish2"); signal != nil {
		(*(*func(*QApplication))(signal))(NewQApplicationFromPointer(application))
	} else {
		NewQStyleFromPointer(ptr).Polish2Default(NewQApplicationFromPointer(application))
	}
}

func (ptr *QStyle) ConnectPolish2(f func(application *QApplication)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "polish2"); signal != nil {
			f := func(application *QApplication) {
				(*(*func(*QApplication))(signal))(application)
				f(application)
			}
			qt.ConnectSignal(ptr.Pointer(), "polish2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "polish2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectPolish2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "polish2")
	}
}

func (ptr *QStyle) Polish2(application QApplication_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_Polish2(ptr.Pointer(), PointerFromQApplication(application))
	}
}

func (ptr *QStyle) Polish2Default(application QApplication_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_Polish2Default(ptr.Pointer(), PointerFromQApplication(application))
	}
}

//export callbackQStyle_Polish3
func callbackQStyle_Polish3(ptr unsafe.Pointer, palette unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "polish3"); signal != nil {
		(*(*func(*gui.QPalette))(signal))(gui.NewQPaletteFromPointer(palette))
	} else {
		NewQStyleFromPointer(ptr).Polish3Default(gui.NewQPaletteFromPointer(palette))
	}
}

func (ptr *QStyle) ConnectPolish3(f func(palette *gui.QPalette)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "polish3"); signal != nil {
			f := func(palette *gui.QPalette) {
				(*(*func(*gui.QPalette))(signal))(palette)
				f(palette)
			}
			qt.ConnectSignal(ptr.Pointer(), "polish3", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "polish3", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectPolish3() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "polish3")
	}
}

func (ptr *QStyle) Polish3(palette gui.QPalette_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_Polish3(ptr.Pointer(), gui.PointerFromQPalette(palette))
	}
}

func (ptr *QStyle) Polish3Default(palette gui.QPalette_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_Polish3Default(ptr.Pointer(), gui.PointerFromQPalette(palette))
	}
}

//export callbackQStyle_Polish
func callbackQStyle_Polish(ptr unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "polish"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(widget))
	} else {
		NewQStyleFromPointer(ptr).PolishDefault(NewQWidgetFromPointer(widget))
	}
}

func (ptr *QStyle) ConnectPolish(f func(widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "polish"); signal != nil {
			f := func(widget *QWidget) {
				(*(*func(*QWidget))(signal))(widget)
				f(widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "polish", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "polish", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectPolish() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "polish")
	}
}

func (ptr *QStyle) Polish(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_Polish(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QStyle) PolishDefault(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_PolishDefault(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQStyle_Unpolish2
func callbackQStyle_Unpolish2(ptr unsafe.Pointer, application unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "unpolish2"); signal != nil {
		(*(*func(*QApplication))(signal))(NewQApplicationFromPointer(application))
	} else {
		NewQStyleFromPointer(ptr).Unpolish2Default(NewQApplicationFromPointer(application))
	}
}

func (ptr *QStyle) ConnectUnpolish2(f func(application *QApplication)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "unpolish2"); signal != nil {
			f := func(application *QApplication) {
				(*(*func(*QApplication))(signal))(application)
				f(application)
			}
			qt.ConnectSignal(ptr.Pointer(), "unpolish2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "unpolish2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectUnpolish2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "unpolish2")
	}
}

func (ptr *QStyle) Unpolish2(application QApplication_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_Unpolish2(ptr.Pointer(), PointerFromQApplication(application))
	}
}

func (ptr *QStyle) Unpolish2Default(application QApplication_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_Unpolish2Default(ptr.Pointer(), PointerFromQApplication(application))
	}
}

//export callbackQStyle_Unpolish
func callbackQStyle_Unpolish(ptr unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "unpolish"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(widget))
	} else {
		NewQStyleFromPointer(ptr).UnpolishDefault(NewQWidgetFromPointer(widget))
	}
}

func (ptr *QStyle) ConnectUnpolish(f func(widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "unpolish"); signal != nil {
			f := func(widget *QWidget) {
				(*(*func(*QWidget))(signal))(widget)
				f(widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "unpolish", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "unpolish", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectUnpolish() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "unpolish")
	}
}

func (ptr *QStyle) Unpolish(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_Unpolish(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QStyle) UnpolishDefault(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_UnpolishDefault(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQStyle_DestroyQStyle
func callbackQStyle_DestroyQStyle(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QStyle"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStyleFromPointer(ptr).DestroyQStyleDefault()
	}
}

func (ptr *QStyle) ConnectDestroyQStyle(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QStyle"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QStyle", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QStyle", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectDestroyQStyle() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QStyle")
	}
}

func (ptr *QStyle) DestroyQStyle() {
	if ptr.Pointer() != nil {
		C.QStyle_DestroyQStyle(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStyle) DestroyQStyleDefault() {
	if ptr.Pointer() != nil {
		C.QStyle_DestroyQStyleDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQStyle_StandardIcon
func callbackQStyle_StandardIcon(ptr unsafe.Pointer, standardIcon C.longlong, option unsafe.Pointer, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "standardIcon"); signal != nil {
		return gui.PointerFromQIcon((*(*func(QStyle__StandardPixmap, *QStyleOption, *QWidget) *gui.QIcon)(signal))(QStyle__StandardPixmap(standardIcon), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget)))
	}

	return gui.PointerFromQIcon(gui.NewQIcon())
}

func (ptr *QStyle) ConnectStandardIcon(f func(standardIcon QStyle__StandardPixmap, option *QStyleOption, widget *QWidget) *gui.QIcon) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "standardIcon"); signal != nil {
			f := func(standardIcon QStyle__StandardPixmap, option *QStyleOption, widget *QWidget) *gui.QIcon {
				(*(*func(QStyle__StandardPixmap, *QStyleOption, *QWidget) *gui.QIcon)(signal))(standardIcon, option, widget)
				return f(standardIcon, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "standardIcon", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "standardIcon", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectStandardIcon() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "standardIcon")
	}
}

func (ptr *QStyle) StandardIcon(standardIcon QStyle__StandardPixmap, option QStyleOption_ITF, widget QWidget_ITF) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyle_StandardIcon(ptr.Pointer(), C.longlong(standardIcon), PointerFromQStyleOption(option), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

//export callbackQStyle_StandardPalette
func callbackQStyle_StandardPalette(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "standardPalette"); signal != nil {
		return gui.PointerFromQPalette((*(*func() *gui.QPalette)(signal))())
	}

	return gui.PointerFromQPalette(NewQStyleFromPointer(ptr).StandardPaletteDefault())
}

func (ptr *QStyle) ConnectStandardPalette(f func() *gui.QPalette) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "standardPalette"); signal != nil {
			f := func() *gui.QPalette {
				(*(*func() *gui.QPalette)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "standardPalette", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "standardPalette", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectStandardPalette() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "standardPalette")
	}
}

func (ptr *QStyle) StandardPalette() *gui.QPalette {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPaletteFromPointer(C.QStyle_StandardPalette(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) StandardPaletteDefault() *gui.QPalette {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPaletteFromPointer(C.QStyle_StandardPaletteDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
		return tmpValue
	}
	return nil
}

//export callbackQStyle_GeneratedIconPixmap
func callbackQStyle_GeneratedIconPixmap(ptr unsafe.Pointer, iconMode C.longlong, pixmap unsafe.Pointer, option unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "generatedIconPixmap"); signal != nil {
		return gui.PointerFromQPixmap((*(*func(gui.QIcon__Mode, *gui.QPixmap, *QStyleOption) *gui.QPixmap)(signal))(gui.QIcon__Mode(iconMode), gui.NewQPixmapFromPointer(pixmap), NewQStyleOptionFromPointer(option)))
	}

	return gui.PointerFromQPixmap(gui.NewQPixmap())
}

func (ptr *QStyle) ConnectGeneratedIconPixmap(f func(iconMode gui.QIcon__Mode, pixmap *gui.QPixmap, option *QStyleOption) *gui.QPixmap) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "generatedIconPixmap"); signal != nil {
			f := func(iconMode gui.QIcon__Mode, pixmap *gui.QPixmap, option *QStyleOption) *gui.QPixmap {
				(*(*func(gui.QIcon__Mode, *gui.QPixmap, *QStyleOption) *gui.QPixmap)(signal))(iconMode, pixmap, option)
				return f(iconMode, pixmap, option)
			}
			qt.ConnectSignal(ptr.Pointer(), "generatedIconPixmap", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "generatedIconPixmap", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectGeneratedIconPixmap() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "generatedIconPixmap")
	}
}

func (ptr *QStyle) GeneratedIconPixmap(iconMode gui.QIcon__Mode, pixmap gui.QPixmap_ITF, option QStyleOption_ITF) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QStyle_GeneratedIconPixmap(ptr.Pointer(), C.longlong(iconMode), gui.PointerFromQPixmap(pixmap), PointerFromQStyleOption(option)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

//export callbackQStyle_ItemPixmapRect
func callbackQStyle_ItemPixmapRect(ptr unsafe.Pointer, rectangle unsafe.Pointer, alignment C.int, pixmap unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemPixmapRect"); signal != nil {
		return core.PointerFromQRect((*(*func(*core.QRect, int, *gui.QPixmap) *core.QRect)(signal))(core.NewQRectFromPointer(rectangle), int(int32(alignment)), gui.NewQPixmapFromPointer(pixmap)))
	}

	return core.PointerFromQRect(NewQStyleFromPointer(ptr).ItemPixmapRectDefault(core.NewQRectFromPointer(rectangle), int(int32(alignment)), gui.NewQPixmapFromPointer(pixmap)))
}

func (ptr *QStyle) ConnectItemPixmapRect(f func(rectangle *core.QRect, alignment int, pixmap *gui.QPixmap) *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemPixmapRect"); signal != nil {
			f := func(rectangle *core.QRect, alignment int, pixmap *gui.QPixmap) *core.QRect {
				(*(*func(*core.QRect, int, *gui.QPixmap) *core.QRect)(signal))(rectangle, alignment, pixmap)
				return f(rectangle, alignment, pixmap)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemPixmapRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemPixmapRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectItemPixmapRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemPixmapRect")
	}
}

func (ptr *QStyle) ItemPixmapRect(rectangle core.QRect_ITF, alignment int, pixmap gui.QPixmap_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyle_ItemPixmapRect(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(int32(alignment)), gui.PointerFromQPixmap(pixmap)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) ItemPixmapRectDefault(rectangle core.QRect_ITF, alignment int, pixmap gui.QPixmap_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyle_ItemPixmapRectDefault(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(int32(alignment)), gui.PointerFromQPixmap(pixmap)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQStyle_ItemTextRect
func callbackQStyle_ItemTextRect(ptr unsafe.Pointer, metrics unsafe.Pointer, rectangle unsafe.Pointer, alignment C.int, enabled C.char, text C.struct_QtWidgets_PackedString) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "itemTextRect"); signal != nil {
		return core.PointerFromQRect((*(*func(*gui.QFontMetrics, *core.QRect, int, bool, string) *core.QRect)(signal))(gui.NewQFontMetricsFromPointer(metrics), core.NewQRectFromPointer(rectangle), int(int32(alignment)), int8(enabled) != 0, cGoUnpackString(text)))
	}

	return core.PointerFromQRect(NewQStyleFromPointer(ptr).ItemTextRectDefault(gui.NewQFontMetricsFromPointer(metrics), core.NewQRectFromPointer(rectangle), int(int32(alignment)), int8(enabled) != 0, cGoUnpackString(text)))
}

func (ptr *QStyle) ConnectItemTextRect(f func(metrics *gui.QFontMetrics, rectangle *core.QRect, alignment int, enabled bool, text string) *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemTextRect"); signal != nil {
			f := func(metrics *gui.QFontMetrics, rectangle *core.QRect, alignment int, enabled bool, text string) *core.QRect {
				(*(*func(*gui.QFontMetrics, *core.QRect, int, bool, string) *core.QRect)(signal))(metrics, rectangle, alignment, enabled, text)
				return f(metrics, rectangle, alignment, enabled, text)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemTextRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemTextRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectItemTextRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemTextRect")
	}
}

func (ptr *QStyle) ItemTextRect(metrics gui.QFontMetrics_ITF, rectangle core.QRect_ITF, alignment int, enabled bool, text string) *core.QRect {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := core.NewQRectFromPointer(C.QStyle_ItemTextRect(ptr.Pointer(), gui.PointerFromQFontMetrics(metrics), core.PointerFromQRect(rectangle), C.int(int32(alignment)), C.char(int8(qt.GoBoolToInt(enabled))), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) ItemTextRectDefault(metrics gui.QFontMetrics_ITF, rectangle core.QRect_ITF, alignment int, enabled bool, text string) *core.QRect {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := core.NewQRectFromPointer(C.QStyle_ItemTextRectDefault(ptr.Pointer(), gui.PointerFromQFontMetrics(metrics), core.PointerFromQRect(rectangle), C.int(int32(alignment)), C.char(int8(qt.GoBoolToInt(enabled))), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQStyle_SubControlRect
func callbackQStyle_SubControlRect(ptr unsafe.Pointer, control C.longlong, option unsafe.Pointer, subControl C.longlong, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "subControlRect"); signal != nil {
		return core.PointerFromQRect((*(*func(QStyle__ComplexControl, *QStyleOptionComplex, QStyle__SubControl, *QWidget) *core.QRect)(signal))(QStyle__ComplexControl(control), NewQStyleOptionComplexFromPointer(option), QStyle__SubControl(subControl), NewQWidgetFromPointer(widget)))
	}

	return core.PointerFromQRect(core.NewQRect())
}

func (ptr *QStyle) ConnectSubControlRect(f func(control QStyle__ComplexControl, option *QStyleOptionComplex, subControl QStyle__SubControl, widget *QWidget) *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "subControlRect"); signal != nil {
			f := func(control QStyle__ComplexControl, option *QStyleOptionComplex, subControl QStyle__SubControl, widget *QWidget) *core.QRect {
				(*(*func(QStyle__ComplexControl, *QStyleOptionComplex, QStyle__SubControl, *QWidget) *core.QRect)(signal))(control, option, subControl, widget)
				return f(control, option, subControl, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "subControlRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "subControlRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectSubControlRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "subControlRect")
	}
}

func (ptr *QStyle) SubControlRect(control QStyle__ComplexControl, option QStyleOptionComplex_ITF, subControl QStyle__SubControl, widget QWidget_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyle_SubControlRect(ptr.Pointer(), C.longlong(control), PointerFromQStyleOptionComplex(option), C.longlong(subControl), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQStyle_SubElementRect
func callbackQStyle_SubElementRect(ptr unsafe.Pointer, element C.longlong, option unsafe.Pointer, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "subElementRect"); signal != nil {
		return core.PointerFromQRect((*(*func(QStyle__SubElement, *QStyleOption, *QWidget) *core.QRect)(signal))(QStyle__SubElement(element), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget)))
	}

	return core.PointerFromQRect(core.NewQRect())
}

func (ptr *QStyle) ConnectSubElementRect(f func(element QStyle__SubElement, option *QStyleOption, widget *QWidget) *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "subElementRect"); signal != nil {
			f := func(element QStyle__SubElement, option *QStyleOption, widget *QWidget) *core.QRect {
				(*(*func(QStyle__SubElement, *QStyleOption, *QWidget) *core.QRect)(signal))(element, option, widget)
				return f(element, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "subElementRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "subElementRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectSubElementRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "subElementRect")
	}
}

func (ptr *QStyle) SubElementRect(element QStyle__SubElement, option QStyleOption_ITF, widget QWidget_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyle_SubElementRect(ptr.Pointer(), C.longlong(element), PointerFromQStyleOption(option), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQStyle_SizeFromContents
func callbackQStyle_SizeFromContents(ptr unsafe.Pointer, ty C.longlong, option unsafe.Pointer, contentsSize unsafe.Pointer, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeFromContents"); signal != nil {
		return core.PointerFromQSize((*(*func(QStyle__ContentsType, *QStyleOption, *core.QSize, *QWidget) *core.QSize)(signal))(QStyle__ContentsType(ty), NewQStyleOptionFromPointer(option), core.NewQSizeFromPointer(contentsSize), NewQWidgetFromPointer(widget)))
	}

	return core.PointerFromQSize(core.NewQSize())
}

func (ptr *QStyle) ConnectSizeFromContents(f func(ty QStyle__ContentsType, option *QStyleOption, contentsSize *core.QSize, widget *QWidget) *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeFromContents"); signal != nil {
			f := func(ty QStyle__ContentsType, option *QStyleOption, contentsSize *core.QSize, widget *QWidget) *core.QSize {
				(*(*func(QStyle__ContentsType, *QStyleOption, *core.QSize, *QWidget) *core.QSize)(signal))(ty, option, contentsSize, widget)
				return f(ty, option, contentsSize, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeFromContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeFromContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectSizeFromContents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeFromContents")
	}
}

func (ptr *QStyle) SizeFromContents(ty QStyle__ContentsType, option QStyleOption_ITF, contentsSize core.QSize_ITF, widget QWidget_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyle_SizeFromContents(ptr.Pointer(), C.longlong(ty), PointerFromQStyleOption(option), core.PointerFromQSize(contentsSize), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQStyle_HitTestComplexControl
func callbackQStyle_HitTestComplexControl(ptr unsafe.Pointer, control C.longlong, option unsafe.Pointer, position unsafe.Pointer, widget unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "hitTestComplexControl"); signal != nil {
		return C.longlong((*(*func(QStyle__ComplexControl, *QStyleOptionComplex, *core.QPoint, *QWidget) QStyle__SubControl)(signal))(QStyle__ComplexControl(control), NewQStyleOptionComplexFromPointer(option), core.NewQPointFromPointer(position), NewQWidgetFromPointer(widget)))
	}

	return C.longlong(0)
}

func (ptr *QStyle) ConnectHitTestComplexControl(f func(control QStyle__ComplexControl, option *QStyleOptionComplex, position *core.QPoint, widget *QWidget) QStyle__SubControl) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hitTestComplexControl"); signal != nil {
			f := func(control QStyle__ComplexControl, option *QStyleOptionComplex, position *core.QPoint, widget *QWidget) QStyle__SubControl {
				(*(*func(QStyle__ComplexControl, *QStyleOptionComplex, *core.QPoint, *QWidget) QStyle__SubControl)(signal))(control, option, position, widget)
				return f(control, option, position, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "hitTestComplexControl", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hitTestComplexControl", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectHitTestComplexControl() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hitTestComplexControl")
	}
}

func (ptr *QStyle) HitTestComplexControl(control QStyle__ComplexControl, option QStyleOptionComplex_ITF, position core.QPoint_ITF, widget QWidget_ITF) QStyle__SubControl {
	if ptr.Pointer() != nil {
		return QStyle__SubControl(C.QStyle_HitTestComplexControl(ptr.Pointer(), C.longlong(control), PointerFromQStyleOptionComplex(option), core.PointerFromQPoint(position), PointerFromQWidget(widget)))
	}
	return 0
}

//export callbackQStyle_MetaObject
func callbackQStyle_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQStyleFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QStyle) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QStyle_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStyle) Proxy() *QStyle {
	if ptr.Pointer() != nil {
		tmpValue := NewQStyleFromPointer(C.QStyle_Proxy(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) CombinedLayoutSpacing(controls1 QSizePolicy__ControlType, controls2 QSizePolicy__ControlType, orientation core.Qt__Orientation, option QStyleOption_ITF, widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyle_CombinedLayoutSpacing(ptr.Pointer(), C.longlong(controls1), C.longlong(controls2), C.longlong(orientation), PointerFromQStyleOption(option), PointerFromQWidget(widget))))
	}
	return 0
}

//export callbackQStyle_LayoutSpacing
func callbackQStyle_LayoutSpacing(ptr unsafe.Pointer, control1 C.longlong, control2 C.longlong, orientation C.longlong, option unsafe.Pointer, widget unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "layoutSpacing"); signal != nil {
		return C.int(int32((*(*func(QSizePolicy__ControlType, QSizePolicy__ControlType, core.Qt__Orientation, *QStyleOption, *QWidget) int)(signal))(QSizePolicy__ControlType(control1), QSizePolicy__ControlType(control2), core.Qt__Orientation(orientation), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget))))
	}

	return C.int(int32(0))
}

func (ptr *QStyle) ConnectLayoutSpacing(f func(control1 QSizePolicy__ControlType, control2 QSizePolicy__ControlType, orientation core.Qt__Orientation, option *QStyleOption, widget *QWidget) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "layoutSpacing"); signal != nil {
			f := func(control1 QSizePolicy__ControlType, control2 QSizePolicy__ControlType, orientation core.Qt__Orientation, option *QStyleOption, widget *QWidget) int {
				(*(*func(QSizePolicy__ControlType, QSizePolicy__ControlType, core.Qt__Orientation, *QStyleOption, *QWidget) int)(signal))(control1, control2, orientation, option, widget)
				return f(control1, control2, orientation, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "layoutSpacing", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "layoutSpacing", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectLayoutSpacing() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "layoutSpacing")
	}
}

func (ptr *QStyle) LayoutSpacing(control1 QSizePolicy__ControlType, control2 QSizePolicy__ControlType, orientation core.Qt__Orientation, option QStyleOption_ITF, widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyle_LayoutSpacing(ptr.Pointer(), C.longlong(control1), C.longlong(control2), C.longlong(orientation), PointerFromQStyleOption(option), PointerFromQWidget(widget))))
	}
	return 0
}

//export callbackQStyle_PixelMetric
func callbackQStyle_PixelMetric(ptr unsafe.Pointer, metric C.longlong, option unsafe.Pointer, widget unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "pixelMetric"); signal != nil {
		return C.int(int32((*(*func(QStyle__PixelMetric, *QStyleOption, *QWidget) int)(signal))(QStyle__PixelMetric(metric), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget))))
	}

	return C.int(int32(0))
}

func (ptr *QStyle) ConnectPixelMetric(f func(metric QStyle__PixelMetric, option *QStyleOption, widget *QWidget) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "pixelMetric"); signal != nil {
			f := func(metric QStyle__PixelMetric, option *QStyleOption, widget *QWidget) int {
				(*(*func(QStyle__PixelMetric, *QStyleOption, *QWidget) int)(signal))(metric, option, widget)
				return f(metric, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "pixelMetric", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "pixelMetric", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectPixelMetric() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "pixelMetric")
	}
}

func (ptr *QStyle) PixelMetric(metric QStyle__PixelMetric, option QStyleOption_ITF, widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyle_PixelMetric(ptr.Pointer(), C.longlong(metric), PointerFromQStyleOption(option), PointerFromQWidget(widget))))
	}
	return 0
}

//export callbackQStyle_StyleHint
func callbackQStyle_StyleHint(ptr unsafe.Pointer, hint C.longlong, option unsafe.Pointer, widget unsafe.Pointer, returnData unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "styleHint"); signal != nil {
		return C.int(int32((*(*func(QStyle__StyleHint, *QStyleOption, *QWidget, *QStyleHintReturn) int)(signal))(QStyle__StyleHint(hint), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget), NewQStyleHintReturnFromPointer(returnData))))
	}

	return C.int(int32(0))
}

func (ptr *QStyle) ConnectStyleHint(f func(hint QStyle__StyleHint, option *QStyleOption, widget *QWidget, returnData *QStyleHintReturn) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "styleHint"); signal != nil {
			f := func(hint QStyle__StyleHint, option *QStyleOption, widget *QWidget, returnData *QStyleHintReturn) int {
				(*(*func(QStyle__StyleHint, *QStyleOption, *QWidget, *QStyleHintReturn) int)(signal))(hint, option, widget, returnData)
				return f(hint, option, widget, returnData)
			}
			qt.ConnectSignal(ptr.Pointer(), "styleHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "styleHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectStyleHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "styleHint")
	}
}

func (ptr *QStyle) StyleHint(hint QStyle__StyleHint, option QStyleOption_ITF, widget QWidget_ITF, returnData QStyleHintReturn_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyle_StyleHint(ptr.Pointer(), C.longlong(hint), PointerFromQStyleOption(option), PointerFromQWidget(widget), PointerFromQStyleHintReturn(returnData))))
	}
	return 0
}

//export callbackQStyle_DrawComplexControl
func callbackQStyle_DrawComplexControl(ptr unsafe.Pointer, control C.longlong, option unsafe.Pointer, painter unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawComplexControl"); signal != nil {
		(*(*func(QStyle__ComplexControl, *QStyleOptionComplex, *gui.QPainter, *QWidget))(signal))(QStyle__ComplexControl(control), NewQStyleOptionComplexFromPointer(option), gui.NewQPainterFromPointer(painter), NewQWidgetFromPointer(widget))
	}

}

func (ptr *QStyle) ConnectDrawComplexControl(f func(control QStyle__ComplexControl, option *QStyleOptionComplex, painter *gui.QPainter, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawComplexControl"); signal != nil {
			f := func(control QStyle__ComplexControl, option *QStyleOptionComplex, painter *gui.QPainter, widget *QWidget) {
				(*(*func(QStyle__ComplexControl, *QStyleOptionComplex, *gui.QPainter, *QWidget))(signal))(control, option, painter, widget)
				f(control, option, painter, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawComplexControl", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawComplexControl", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectDrawComplexControl() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawComplexControl")
	}
}

func (ptr *QStyle) DrawComplexControl(control QStyle__ComplexControl, option QStyleOptionComplex_ITF, painter gui.QPainter_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_DrawComplexControl(ptr.Pointer(), C.longlong(control), PointerFromQStyleOptionComplex(option), gui.PointerFromQPainter(painter), PointerFromQWidget(widget))
	}
}

//export callbackQStyle_DrawControl
func callbackQStyle_DrawControl(ptr unsafe.Pointer, element C.longlong, option unsafe.Pointer, painter unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawControl"); signal != nil {
		(*(*func(QStyle__ControlElement, *QStyleOption, *gui.QPainter, *QWidget))(signal))(QStyle__ControlElement(element), NewQStyleOptionFromPointer(option), gui.NewQPainterFromPointer(painter), NewQWidgetFromPointer(widget))
	}

}

func (ptr *QStyle) ConnectDrawControl(f func(element QStyle__ControlElement, option *QStyleOption, painter *gui.QPainter, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawControl"); signal != nil {
			f := func(element QStyle__ControlElement, option *QStyleOption, painter *gui.QPainter, widget *QWidget) {
				(*(*func(QStyle__ControlElement, *QStyleOption, *gui.QPainter, *QWidget))(signal))(element, option, painter, widget)
				f(element, option, painter, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawControl", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawControl", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectDrawControl() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawControl")
	}
}

func (ptr *QStyle) DrawControl(element QStyle__ControlElement, option QStyleOption_ITF, painter gui.QPainter_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_DrawControl(ptr.Pointer(), C.longlong(element), PointerFromQStyleOption(option), gui.PointerFromQPainter(painter), PointerFromQWidget(widget))
	}
}

//export callbackQStyle_DrawItemPixmap
func callbackQStyle_DrawItemPixmap(ptr unsafe.Pointer, painter unsafe.Pointer, rectangle unsafe.Pointer, alignment C.int, pixmap unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawItemPixmap"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRect, int, *gui.QPixmap))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rectangle), int(int32(alignment)), gui.NewQPixmapFromPointer(pixmap))
	} else {
		NewQStyleFromPointer(ptr).DrawItemPixmapDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rectangle), int(int32(alignment)), gui.NewQPixmapFromPointer(pixmap))
	}
}

func (ptr *QStyle) ConnectDrawItemPixmap(f func(painter *gui.QPainter, rectangle *core.QRect, alignment int, pixmap *gui.QPixmap)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawItemPixmap"); signal != nil {
			f := func(painter *gui.QPainter, rectangle *core.QRect, alignment int, pixmap *gui.QPixmap) {
				(*(*func(*gui.QPainter, *core.QRect, int, *gui.QPixmap))(signal))(painter, rectangle, alignment, pixmap)
				f(painter, rectangle, alignment, pixmap)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawItemPixmap", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawItemPixmap", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectDrawItemPixmap() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawItemPixmap")
	}
}

func (ptr *QStyle) DrawItemPixmap(painter gui.QPainter_ITF, rectangle core.QRect_ITF, alignment int, pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_DrawItemPixmap(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rectangle), C.int(int32(alignment)), gui.PointerFromQPixmap(pixmap))
	}
}

func (ptr *QStyle) DrawItemPixmapDefault(painter gui.QPainter_ITF, rectangle core.QRect_ITF, alignment int, pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_DrawItemPixmapDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rectangle), C.int(int32(alignment)), gui.PointerFromQPixmap(pixmap))
	}
}

//export callbackQStyle_DrawItemText
func callbackQStyle_DrawItemText(ptr unsafe.Pointer, painter unsafe.Pointer, rectangle unsafe.Pointer, alignment C.int, palette unsafe.Pointer, enabled C.char, text C.struct_QtWidgets_PackedString, textRole C.longlong) {
	if signal := qt.GetSignal(ptr, "drawItemText"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRect, int, *gui.QPalette, bool, string, gui.QPalette__ColorRole))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rectangle), int(int32(alignment)), gui.NewQPaletteFromPointer(palette), int8(enabled) != 0, cGoUnpackString(text), gui.QPalette__ColorRole(textRole))
	} else {
		NewQStyleFromPointer(ptr).DrawItemTextDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rectangle), int(int32(alignment)), gui.NewQPaletteFromPointer(palette), int8(enabled) != 0, cGoUnpackString(text), gui.QPalette__ColorRole(textRole))
	}
}

func (ptr *QStyle) ConnectDrawItemText(f func(painter *gui.QPainter, rectangle *core.QRect, alignment int, palette *gui.QPalette, enabled bool, text string, textRole gui.QPalette__ColorRole)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawItemText"); signal != nil {
			f := func(painter *gui.QPainter, rectangle *core.QRect, alignment int, palette *gui.QPalette, enabled bool, text string, textRole gui.QPalette__ColorRole) {
				(*(*func(*gui.QPainter, *core.QRect, int, *gui.QPalette, bool, string, gui.QPalette__ColorRole))(signal))(painter, rectangle, alignment, palette, enabled, text, textRole)
				f(painter, rectangle, alignment, palette, enabled, text, textRole)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawItemText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawItemText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectDrawItemText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawItemText")
	}
}

func (ptr *QStyle) DrawItemText(painter gui.QPainter_ITF, rectangle core.QRect_ITF, alignment int, palette gui.QPalette_ITF, enabled bool, text string, textRole gui.QPalette__ColorRole) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QStyle_DrawItemText(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rectangle), C.int(int32(alignment)), gui.PointerFromQPalette(palette), C.char(int8(qt.GoBoolToInt(enabled))), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(textRole))
	}
}

func (ptr *QStyle) DrawItemTextDefault(painter gui.QPainter_ITF, rectangle core.QRect_ITF, alignment int, palette gui.QPalette_ITF, enabled bool, text string, textRole gui.QPalette__ColorRole) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QStyle_DrawItemTextDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rectangle), C.int(int32(alignment)), gui.PointerFromQPalette(palette), C.char(int8(qt.GoBoolToInt(enabled))), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(textRole))
	}
}

//export callbackQStyle_DrawPrimitive
func callbackQStyle_DrawPrimitive(ptr unsafe.Pointer, element C.longlong, option unsafe.Pointer, painter unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawPrimitive"); signal != nil {
		(*(*func(QStyle__PrimitiveElement, *QStyleOption, *gui.QPainter, *QWidget))(signal))(QStyle__PrimitiveElement(element), NewQStyleOptionFromPointer(option), gui.NewQPainterFromPointer(painter), NewQWidgetFromPointer(widget))
	}

}

func (ptr *QStyle) ConnectDrawPrimitive(f func(element QStyle__PrimitiveElement, option *QStyleOption, painter *gui.QPainter, widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawPrimitive"); signal != nil {
			f := func(element QStyle__PrimitiveElement, option *QStyleOption, painter *gui.QPainter, widget *QWidget) {
				(*(*func(QStyle__PrimitiveElement, *QStyleOption, *gui.QPainter, *QWidget))(signal))(element, option, painter, widget)
				f(element, option, painter, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawPrimitive", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawPrimitive", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectDrawPrimitive() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawPrimitive")
	}
}

func (ptr *QStyle) DrawPrimitive(element QStyle__PrimitiveElement, option QStyleOption_ITF, painter gui.QPainter_ITF, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_DrawPrimitive(ptr.Pointer(), C.longlong(element), PointerFromQStyleOption(option), gui.PointerFromQPainter(painter), PointerFromQWidget(widget))
	}
}

//export callbackQStyle_StandardPixmap
func callbackQStyle_StandardPixmap(ptr unsafe.Pointer, standardIcon C.longlong, option unsafe.Pointer, widget unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "standardPixmap"); signal != nil {
		return gui.PointerFromQPixmap((*(*func(QStyle__StandardPixmap, *QStyleOption, *QWidget) *gui.QPixmap)(signal))(QStyle__StandardPixmap(standardIcon), NewQStyleOptionFromPointer(option), NewQWidgetFromPointer(widget)))
	}

	return gui.PointerFromQPixmap(gui.NewQPixmap())
}

func (ptr *QStyle) ConnectStandardPixmap(f func(standardIcon QStyle__StandardPixmap, option *QStyleOption, widget *QWidget) *gui.QPixmap) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "standardPixmap"); signal != nil {
			f := func(standardIcon QStyle__StandardPixmap, option *QStyleOption, widget *QWidget) *gui.QPixmap {
				(*(*func(QStyle__StandardPixmap, *QStyleOption, *QWidget) *gui.QPixmap)(signal))(standardIcon, option, widget)
				return f(standardIcon, option, widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "standardPixmap", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "standardPixmap", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyle) DisconnectStandardPixmap() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "standardPixmap")
	}
}

func (ptr *QStyle) StandardPixmap(standardIcon QStyle__StandardPixmap, option QStyleOption_ITF, widget QWidget_ITF) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QStyle_StandardPixmap(ptr.Pointer(), C.longlong(standardIcon), PointerFromQStyleOption(option), PointerFromQWidget(widget)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QStyle___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QStyle) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QStyle___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QStyle) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QStyle___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QStyle) __findChildren_newList2() unsafe.Pointer {
	return C.QStyle___findChildren_newList2(ptr.Pointer())
}

func (ptr *QStyle) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QStyle___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QStyle) __findChildren_newList3() unsafe.Pointer {
	return C.QStyle___findChildren_newList3(ptr.Pointer())
}

func (ptr *QStyle) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QStyle___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QStyle) __findChildren_newList() unsafe.Pointer {
	return C.QStyle___findChildren_newList(ptr.Pointer())
}

func (ptr *QStyle) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QStyle___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStyle) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QStyle) __children_newList() unsafe.Pointer {
	return C.QStyle___children_newList(ptr.Pointer())
}

//export callbackQStyle_Event
func callbackQStyle_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQStyleFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QStyle) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyle_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQStyle_EventFilter
func callbackQStyle_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQStyleFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QStyle) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyle_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQStyle_ChildEvent
func callbackQStyle_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQStyleFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QStyle) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQStyle_ConnectNotify
func callbackQStyle_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQStyleFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QStyle) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQStyle_CustomEvent
func callbackQStyle_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQStyleFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QStyle) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQStyle_DeleteLater
func callbackQStyle_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStyleFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QStyle) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QStyle_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQStyle_Destroyed
func callbackQStyle_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQStyle_DisconnectNotify
func callbackQStyle_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQStyleFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QStyle) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQStyle_ObjectNameChanged
func callbackQStyle_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQStyle_TimerEvent
func callbackQStyle_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQStyleFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QStyle) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QStyle_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QStyleFactory struct {
	ptr unsafe.Pointer
}

type QStyleFactory_ITF interface {
	QStyleFactory_PTR() *QStyleFactory
}

func (ptr *QStyleFactory) QStyleFactory_PTR() *QStyleFactory {
	return ptr
}

func (ptr *QStyleFactory) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QStyleFactory) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQStyleFactory(ptr QStyleFactory_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleFactory_PTR().Pointer()
	}
	return nil
}

func NewQStyleFactoryFromPointer(ptr unsafe.Pointer) (n *QStyleFactory) {
	n = new(QStyleFactory)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleFactory) DestroyQStyleFactory() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func QStyleFactory_Keys() []string {
	return strings.Split(cGoUnpackString(C.QStyleFactory_QStyleFactory_Keys()), "|")
}

func (ptr *QStyleFactory) Keys() []string {
	return strings.Split(cGoUnpackString(C.QStyleFactory_QStyleFactory_Keys()), "|")
}

func QStyleFactory_Create(key string) *QStyle {
	var keyC *C.char
	if key != "" {
		keyC = C.CString(key)
		defer C.free(unsafe.Pointer(keyC))
	}
	tmpValue := NewQStyleFromPointer(C.QStyleFactory_QStyleFactory_Create(C.struct_QtWidgets_PackedString{data: keyC, len: C.longlong(len(key))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QStyleFactory) Create(key string) *QStyle {
	var keyC *C.char
	if key != "" {
		keyC = C.CString(key)
		defer C.free(unsafe.Pointer(keyC))
	}
	tmpValue := NewQStyleFromPointer(C.QStyleFactory_QStyleFactory_Create(C.struct_QtWidgets_PackedString{data: keyC, len: C.longlong(len(key))}))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

type QStyleHelper struct {
	ptr unsafe.Pointer
}

type QStyleHelper_ITF interface {
	QStyleHelper_PTR() *QStyleHelper
}

func (ptr *QStyleHelper) QStyleHelper_PTR() *QStyleHelper {
	return ptr
}

func (ptr *QStyleHelper) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QStyleHelper) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQStyleHelper(ptr QStyleHelper_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleHelper_PTR().Pointer()
	}
	return nil
}

func NewQStyleHelperFromPointer(ptr unsafe.Pointer) (n *QStyleHelper) {
	n = new(QStyleHelper)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleHelper) DestroyQStyleHelper() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleHelper__WidgetSizePolicy
//QStyleHelper::WidgetSizePolicy
type QStyleHelper__WidgetSizePolicy int64

const (
	QStyleHelper__SizeLarge   QStyleHelper__WidgetSizePolicy = QStyleHelper__WidgetSizePolicy(0)
	QStyleHelper__SizeSmall   QStyleHelper__WidgetSizePolicy = QStyleHelper__WidgetSizePolicy(1)
	QStyleHelper__SizeMini    QStyleHelper__WidgetSizePolicy = QStyleHelper__WidgetSizePolicy(2)
	QStyleHelper__SizeDefault QStyleHelper__WidgetSizePolicy = QStyleHelper__WidgetSizePolicy(-1)
)

type QStyleHintReturn struct {
	ptr unsafe.Pointer
}

type QStyleHintReturn_ITF interface {
	QStyleHintReturn_PTR() *QStyleHintReturn
}

func (ptr *QStyleHintReturn) QStyleHintReturn_PTR() *QStyleHintReturn {
	return ptr
}

func (ptr *QStyleHintReturn) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QStyleHintReturn) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQStyleHintReturn(ptr QStyleHintReturn_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleHintReturn_PTR().Pointer()
	}
	return nil
}

func NewQStyleHintReturnFromPointer(ptr unsafe.Pointer) (n *QStyleHintReturn) {
	n = new(QStyleHintReturn)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleHintReturn) DestroyQStyleHintReturn() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleHintReturn__HintReturnType
//QStyleHintReturn::HintReturnType
type QStyleHintReturn__HintReturnType int64

const (
	QStyleHintReturn__SH_Default QStyleHintReturn__HintReturnType = QStyleHintReturn__HintReturnType(0xf000)
	QStyleHintReturn__SH_Mask    QStyleHintReturn__HintReturnType = QStyleHintReturn__HintReturnType(0xf001)
	QStyleHintReturn__SH_Variant QStyleHintReturn__HintReturnType = QStyleHintReturn__HintReturnType(0xf002)
)

//go:generate stringer -type=QStyleHintReturn__StyleOptionType
//QStyleHintReturn::StyleOptionType
type QStyleHintReturn__StyleOptionType int64

var (
	QStyleHintReturn__Type QStyleHintReturn__StyleOptionType = QStyleHintReturn__StyleOptionType(QStyleHintReturn__SH_Default)
)

//go:generate stringer -type=QStyleHintReturn__StyleOptionVersion
//QStyleHintReturn::StyleOptionVersion
type QStyleHintReturn__StyleOptionVersion int64

var (
	QStyleHintReturn__Version QStyleHintReturn__StyleOptionVersion = QStyleHintReturn__StyleOptionVersion(1)
)

func NewQStyleHintReturn(version int, ty int) *QStyleHintReturn {
	tmpValue := NewQStyleHintReturnFromPointer(C.QStyleHintReturn_NewQStyleHintReturn(C.int(int32(version)), C.int(int32(ty))))
	runtime.SetFinalizer(tmpValue, (*QStyleHintReturn).DestroyQStyleHintReturn)
	return tmpValue
}

func (ptr *QStyleHintReturn) Type() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleHintReturn_Type(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleHintReturn) SetType(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleHintReturn_SetType(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleHintReturn) Version() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleHintReturn_Version(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleHintReturn) SetVersion(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleHintReturn_SetVersion(ptr.Pointer(), C.int(int32(vin)))
	}
}

type QStyleHintReturnMask struct {
	QStyleHintReturn
}

type QStyleHintReturnMask_ITF interface {
	QStyleHintReturn_ITF
	QStyleHintReturnMask_PTR() *QStyleHintReturnMask
}

func (ptr *QStyleHintReturnMask) QStyleHintReturnMask_PTR() *QStyleHintReturnMask {
	return ptr
}

func (ptr *QStyleHintReturnMask) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleHintReturn_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleHintReturnMask) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleHintReturn_PTR().SetPointer(p)
	}
}

func PointerFromQStyleHintReturnMask(ptr QStyleHintReturnMask_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleHintReturnMask_PTR().Pointer()
	}
	return nil
}

func NewQStyleHintReturnMaskFromPointer(ptr unsafe.Pointer) (n *QStyleHintReturnMask) {
	n = new(QStyleHintReturnMask)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QStyleHintReturnMask__StyleOptionType
//QStyleHintReturnMask::StyleOptionType
type QStyleHintReturnMask__StyleOptionType int64

var (
	QStyleHintReturnMask__Type QStyleHintReturnMask__StyleOptionType = QStyleHintReturnMask__StyleOptionType(QStyleHintReturn__SH_Mask)
)

//go:generate stringer -type=QStyleHintReturnMask__StyleOptionVersion
//QStyleHintReturnMask::StyleOptionVersion
type QStyleHintReturnMask__StyleOptionVersion int64

var (
	QStyleHintReturnMask__Version QStyleHintReturnMask__StyleOptionVersion = QStyleHintReturnMask__StyleOptionVersion(1)
)

func NewQStyleHintReturnMask() *QStyleHintReturnMask {
	tmpValue := NewQStyleHintReturnMaskFromPointer(C.QStyleHintReturnMask_NewQStyleHintReturnMask())
	runtime.SetFinalizer(tmpValue, (*QStyleHintReturnMask).DestroyQStyleHintReturnMask)
	return tmpValue
}

func (ptr *QStyleHintReturnMask) DestroyQStyleHintReturnMask() {
	if ptr.Pointer() != nil {
		C.QStyleHintReturnMask_DestroyQStyleHintReturnMask(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStyleHintReturnMask) Region() *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QStyleHintReturnMask_Region(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleHintReturnMask) SetRegion(vqr gui.QRegion_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleHintReturnMask_SetRegion(ptr.Pointer(), gui.PointerFromQRegion(vqr))
	}
}

type QStyleHintReturnVariant struct {
	QStyleHintReturn
}

type QStyleHintReturnVariant_ITF interface {
	QStyleHintReturn_ITF
	QStyleHintReturnVariant_PTR() *QStyleHintReturnVariant
}

func (ptr *QStyleHintReturnVariant) QStyleHintReturnVariant_PTR() *QStyleHintReturnVariant {
	return ptr
}

func (ptr *QStyleHintReturnVariant) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleHintReturn_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleHintReturnVariant) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleHintReturn_PTR().SetPointer(p)
	}
}

func PointerFromQStyleHintReturnVariant(ptr QStyleHintReturnVariant_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleHintReturnVariant_PTR().Pointer()
	}
	return nil
}

func NewQStyleHintReturnVariantFromPointer(ptr unsafe.Pointer) (n *QStyleHintReturnVariant) {
	n = new(QStyleHintReturnVariant)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QStyleHintReturnVariant__StyleOptionType
//QStyleHintReturnVariant::StyleOptionType
type QStyleHintReturnVariant__StyleOptionType int64

var (
	QStyleHintReturnVariant__Type QStyleHintReturnVariant__StyleOptionType = QStyleHintReturnVariant__StyleOptionType(QStyleHintReturn__SH_Variant)
)

//go:generate stringer -type=QStyleHintReturnVariant__StyleOptionVersion
//QStyleHintReturnVariant::StyleOptionVersion
type QStyleHintReturnVariant__StyleOptionVersion int64

var (
	QStyleHintReturnVariant__Version QStyleHintReturnVariant__StyleOptionVersion = QStyleHintReturnVariant__StyleOptionVersion(1)
)

func NewQStyleHintReturnVariant() *QStyleHintReturnVariant {
	tmpValue := NewQStyleHintReturnVariantFromPointer(C.QStyleHintReturnVariant_NewQStyleHintReturnVariant())
	runtime.SetFinalizer(tmpValue, (*QStyleHintReturnVariant).DestroyQStyleHintReturnVariant)
	return tmpValue
}

func (ptr *QStyleHintReturnVariant) DestroyQStyleHintReturnVariant() {
	if ptr.Pointer() != nil {
		C.QStyleHintReturnVariant_DestroyQStyleHintReturnVariant(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStyleHintReturnVariant) Variant() *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QStyleHintReturnVariant_Variant(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleHintReturnVariant) SetVariant(vqv core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleHintReturnVariant_SetVariant(ptr.Pointer(), core.PointerFromQVariant(vqv))
	}
}

type QStyleOption struct {
	ptr unsafe.Pointer
}

type QStyleOption_ITF interface {
	QStyleOption_PTR() *QStyleOption
}

func (ptr *QStyleOption) QStyleOption_PTR() *QStyleOption {
	return ptr
}

func (ptr *QStyleOption) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QStyleOption) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQStyleOption(ptr QStyleOption_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionFromPointer(ptr unsafe.Pointer) (n *QStyleOption) {
	n = new(QStyleOption)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QStyleOption__OptionType
//QStyleOption::OptionType
type QStyleOption__OptionType int64

const (
	QStyleOption__SO_Default           QStyleOption__OptionType = QStyleOption__OptionType(0)
	QStyleOption__SO_FocusRect         QStyleOption__OptionType = QStyleOption__OptionType(1)
	QStyleOption__SO_Button            QStyleOption__OptionType = QStyleOption__OptionType(2)
	QStyleOption__SO_Tab               QStyleOption__OptionType = QStyleOption__OptionType(3)
	QStyleOption__SO_MenuItem          QStyleOption__OptionType = QStyleOption__OptionType(4)
	QStyleOption__SO_Frame             QStyleOption__OptionType = QStyleOption__OptionType(5)
	QStyleOption__SO_ProgressBar       QStyleOption__OptionType = QStyleOption__OptionType(6)
	QStyleOption__SO_ToolBox           QStyleOption__OptionType = QStyleOption__OptionType(7)
	QStyleOption__SO_Header            QStyleOption__OptionType = QStyleOption__OptionType(8)
	QStyleOption__SO_DockWidget        QStyleOption__OptionType = QStyleOption__OptionType(9)
	QStyleOption__SO_ViewItem          QStyleOption__OptionType = QStyleOption__OptionType(10)
	QStyleOption__SO_TabWidgetFrame    QStyleOption__OptionType = QStyleOption__OptionType(11)
	QStyleOption__SO_TabBarBase        QStyleOption__OptionType = QStyleOption__OptionType(12)
	QStyleOption__SO_RubberBand        QStyleOption__OptionType = QStyleOption__OptionType(13)
	QStyleOption__SO_ToolBar           QStyleOption__OptionType = QStyleOption__OptionType(14)
	QStyleOption__SO_GraphicsItem      QStyleOption__OptionType = QStyleOption__OptionType(15)
	QStyleOption__SO_Complex           QStyleOption__OptionType = QStyleOption__OptionType(0xf0000)
	QStyleOption__SO_Slider            QStyleOption__OptionType = QStyleOption__OptionType(0xf0001)
	QStyleOption__SO_SpinBox           QStyleOption__OptionType = QStyleOption__OptionType(0xf0002)
	QStyleOption__SO_ToolButton        QStyleOption__OptionType = QStyleOption__OptionType(0xf0003)
	QStyleOption__SO_ComboBox          QStyleOption__OptionType = QStyleOption__OptionType(0xf0004)
	QStyleOption__SO_TitleBar          QStyleOption__OptionType = QStyleOption__OptionType(0xf0005)
	QStyleOption__SO_GroupBox          QStyleOption__OptionType = QStyleOption__OptionType(0xf0006)
	QStyleOption__SO_SizeGrip          QStyleOption__OptionType = QStyleOption__OptionType(0xf0007)
	QStyleOption__SO_CustomBase        QStyleOption__OptionType = QStyleOption__OptionType(0xf00)
	QStyleOption__SO_ComplexCustomBase QStyleOption__OptionType = QStyleOption__OptionType(0xf000000)
)

//go:generate stringer -type=QStyleOption__StyleOptionType
//QStyleOption::StyleOptionType
type QStyleOption__StyleOptionType int64

var (
	QStyleOption__Type QStyleOption__StyleOptionType = QStyleOption__StyleOptionType(QStyleOption__SO_Default)
)

//go:generate stringer -type=QStyleOption__StyleOptionVersion
//QStyleOption::StyleOptionVersion
type QStyleOption__StyleOptionVersion int64

var (
	QStyleOption__Version QStyleOption__StyleOptionVersion = QStyleOption__StyleOptionVersion(1)
)

func NewQStyleOption2(other QStyleOption_ITF) *QStyleOption {
	tmpValue := NewQStyleOptionFromPointer(C.QStyleOption_NewQStyleOption2(PointerFromQStyleOption(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOption).DestroyQStyleOption)
	return tmpValue
}

func NewQStyleOption(version int, ty int) *QStyleOption {
	tmpValue := NewQStyleOptionFromPointer(C.QStyleOption_NewQStyleOption(C.int(int32(version)), C.int(int32(ty))))
	runtime.SetFinalizer(tmpValue, (*QStyleOption).DestroyQStyleOption)
	return tmpValue
}

func (ptr *QStyleOption) InitFrom(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOption_InitFrom(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QStyleOption) DestroyQStyleOption() {
	if ptr.Pointer() != nil {
		C.QStyleOption_DestroyQStyleOption(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStyleOption) Direction() core.Qt__LayoutDirection {
	if ptr.Pointer() != nil {
		return core.Qt__LayoutDirection(C.QStyleOption_Direction(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOption) SetDirection(vqt core.Qt__LayoutDirection) {
	if ptr.Pointer() != nil {
		C.QStyleOption_SetDirection(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOption) FontMetrics() *gui.QFontMetrics {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontMetricsFromPointer(C.QStyleOption_FontMetrics(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFontMetrics).DestroyQFontMetrics)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOption) SetFontMetrics(vqf gui.QFontMetrics_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOption_SetFontMetrics(ptr.Pointer(), gui.PointerFromQFontMetrics(vqf))
	}
}

func (ptr *QStyleOption) Palette() *gui.QPalette {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPaletteFromPointer(C.QStyleOption_Palette(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOption) SetPalette(vqp gui.QPalette_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOption_SetPalette(ptr.Pointer(), gui.PointerFromQPalette(vqp))
	}
}

func (ptr *QStyleOption) Rect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyleOption_Rect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOption) SetRect(vqr core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOption_SetRect(ptr.Pointer(), core.PointerFromQRect(vqr))
	}
}

func (ptr *QStyleOption) State() QStyle__StateFlag {
	if ptr.Pointer() != nil {
		return QStyle__StateFlag(C.QStyleOption_State(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOption) SetState(vqs QStyle__StateFlag) {
	if ptr.Pointer() != nil {
		C.QStyleOption_SetState(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOption) StyleObject() *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QStyleOption_StyleObject(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOption) SetStyleObject(vqo core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOption_SetStyleObject(ptr.Pointer(), core.PointerFromQObject(vqo))
	}
}

func (ptr *QStyleOption) Type() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOption_Type(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOption) SetType(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOption_SetType(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOption) Version() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOption_Version(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOption) SetVersion(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOption_SetVersion(ptr.Pointer(), C.int(int32(vin)))
	}
}

type QStyleOptionButton struct {
	QStyleOption
}

type QStyleOptionButton_ITF interface {
	QStyleOption_ITF
	QStyleOptionButton_PTR() *QStyleOptionButton
}

func (ptr *QStyleOptionButton) QStyleOptionButton_PTR() *QStyleOptionButton {
	return ptr
}

func (ptr *QStyleOptionButton) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionButton) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionButton(ptr QStyleOptionButton_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionButton_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionButtonFromPointer(ptr unsafe.Pointer) (n *QStyleOptionButton) {
	n = new(QStyleOptionButton)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionButton) DestroyQStyleOptionButton() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionButton__ButtonFeature
//QStyleOptionButton::ButtonFeature
type QStyleOptionButton__ButtonFeature int64

const (
	QStyleOptionButton__None              QStyleOptionButton__ButtonFeature = QStyleOptionButton__ButtonFeature(0x00)
	QStyleOptionButton__Flat              QStyleOptionButton__ButtonFeature = QStyleOptionButton__ButtonFeature(0x01)
	QStyleOptionButton__HasMenu           QStyleOptionButton__ButtonFeature = QStyleOptionButton__ButtonFeature(0x02)
	QStyleOptionButton__DefaultButton     QStyleOptionButton__ButtonFeature = QStyleOptionButton__ButtonFeature(0x04)
	QStyleOptionButton__AutoDefaultButton QStyleOptionButton__ButtonFeature = QStyleOptionButton__ButtonFeature(0x08)
	QStyleOptionButton__CommandLinkButton QStyleOptionButton__ButtonFeature = QStyleOptionButton__ButtonFeature(0x10)
)

//go:generate stringer -type=QStyleOptionButton__StyleOptionType
//QStyleOptionButton::StyleOptionType
type QStyleOptionButton__StyleOptionType int64

var (
	QStyleOptionButton__Type QStyleOptionButton__StyleOptionType = QStyleOptionButton__StyleOptionType(QStyleOption__SO_Button)
)

//go:generate stringer -type=QStyleOptionButton__StyleOptionVersion
//QStyleOptionButton::StyleOptionVersion
type QStyleOptionButton__StyleOptionVersion int64

var (
	QStyleOptionButton__Version QStyleOptionButton__StyleOptionVersion = QStyleOptionButton__StyleOptionVersion(1)
)

func NewQStyleOptionButton() *QStyleOptionButton {
	tmpValue := NewQStyleOptionButtonFromPointer(C.QStyleOptionButton_NewQStyleOptionButton())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionButton).DestroyQStyleOptionButton)
	return tmpValue
}

func NewQStyleOptionButton2(other QStyleOptionButton_ITF) *QStyleOptionButton {
	tmpValue := NewQStyleOptionButtonFromPointer(C.QStyleOptionButton_NewQStyleOptionButton2(PointerFromQStyleOptionButton(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionButton).DestroyQStyleOptionButton)
	return tmpValue
}

func (ptr *QStyleOptionButton) Features() QStyleOptionButton__ButtonFeature {
	if ptr.Pointer() != nil {
		return QStyleOptionButton__ButtonFeature(C.QStyleOptionButton_Features(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionButton) SetFeatures(vqs QStyleOptionButton__ButtonFeature) {
	if ptr.Pointer() != nil {
		C.QStyleOptionButton_SetFeatures(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionButton) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyleOptionButton_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionButton) SetIcon(vqi gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionButton_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(vqi))
	}
}

func (ptr *QStyleOptionButton) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionButton_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionButton) SetIconSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionButton_SetIconSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QStyleOptionButton) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionButton_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionButton) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionButton_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

type QStyleOptionComboBox struct {
	QStyleOptionComplex
}

type QStyleOptionComboBox_ITF interface {
	QStyleOptionComplex_ITF
	QStyleOptionComboBox_PTR() *QStyleOptionComboBox
}

func (ptr *QStyleOptionComboBox) QStyleOptionComboBox_PTR() *QStyleOptionComboBox {
	return ptr
}

func (ptr *QStyleOptionComboBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionComplex_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionComboBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOptionComplex_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionComboBox(ptr QStyleOptionComboBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionComboBox_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionComboBoxFromPointer(ptr unsafe.Pointer) (n *QStyleOptionComboBox) {
	n = new(QStyleOptionComboBox)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionComboBox) DestroyQStyleOptionComboBox() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionComboBox__StyleOptionType
//QStyleOptionComboBox::StyleOptionType
type QStyleOptionComboBox__StyleOptionType int64

var (
	QStyleOptionComboBox__Type QStyleOptionComboBox__StyleOptionType = QStyleOptionComboBox__StyleOptionType(QStyleOption__SO_ComboBox)
)

//go:generate stringer -type=QStyleOptionComboBox__StyleOptionVersion
//QStyleOptionComboBox::StyleOptionVersion
type QStyleOptionComboBox__StyleOptionVersion int64

var (
	QStyleOptionComboBox__Version QStyleOptionComboBox__StyleOptionVersion = QStyleOptionComboBox__StyleOptionVersion(1)
)

func NewQStyleOptionComboBox() *QStyleOptionComboBox {
	tmpValue := NewQStyleOptionComboBoxFromPointer(C.QStyleOptionComboBox_NewQStyleOptionComboBox())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionComboBox).DestroyQStyleOptionComboBox)
	return tmpValue
}

func NewQStyleOptionComboBox2(other QStyleOptionComboBox_ITF) *QStyleOptionComboBox {
	tmpValue := NewQStyleOptionComboBoxFromPointer(C.QStyleOptionComboBox_NewQStyleOptionComboBox2(PointerFromQStyleOptionComboBox(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionComboBox).DestroyQStyleOptionComboBox)
	return tmpValue
}

func (ptr *QStyleOptionComboBox) CurrentIcon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyleOptionComboBox_CurrentIcon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionComboBox) SetCurrentIcon(vqi gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionComboBox_SetCurrentIcon(ptr.Pointer(), gui.PointerFromQIcon(vqi))
	}
}

func (ptr *QStyleOptionComboBox) CurrentText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionComboBox_CurrentText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionComboBox) SetCurrentText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionComboBox_SetCurrentText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QStyleOptionComboBox) Editable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionComboBox_Editable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionComboBox) SetEditable(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionComboBox_SetEditable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionComboBox) Frame() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionComboBox_Frame(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionComboBox) SetFrame(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionComboBox_SetFrame(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionComboBox) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionComboBox_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionComboBox) SetIconSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionComboBox_SetIconSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QStyleOptionComboBox) PopupRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyleOptionComboBox_PopupRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionComboBox) SetPopupRect(vqr core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionComboBox_SetPopupRect(ptr.Pointer(), core.PointerFromQRect(vqr))
	}
}

type QStyleOptionComplex struct {
	QStyleOption
}

type QStyleOptionComplex_ITF interface {
	QStyleOption_ITF
	QStyleOptionComplex_PTR() *QStyleOptionComplex
}

func (ptr *QStyleOptionComplex) QStyleOptionComplex_PTR() *QStyleOptionComplex {
	return ptr
}

func (ptr *QStyleOptionComplex) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionComplex) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionComplex(ptr QStyleOptionComplex_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionComplex_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionComplexFromPointer(ptr unsafe.Pointer) (n *QStyleOptionComplex) {
	n = new(QStyleOptionComplex)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionComplex) DestroyQStyleOptionComplex() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionComplex__StyleOptionType
//QStyleOptionComplex::StyleOptionType
type QStyleOptionComplex__StyleOptionType int64

var (
	QStyleOptionComplex__Type QStyleOptionComplex__StyleOptionType = QStyleOptionComplex__StyleOptionType(QStyleOption__SO_Complex)
)

//go:generate stringer -type=QStyleOptionComplex__StyleOptionVersion
//QStyleOptionComplex::StyleOptionVersion
type QStyleOptionComplex__StyleOptionVersion int64

var (
	QStyleOptionComplex__Version QStyleOptionComplex__StyleOptionVersion = QStyleOptionComplex__StyleOptionVersion(1)
)

func NewQStyleOptionComplex2(other QStyleOptionComplex_ITF) *QStyleOptionComplex {
	tmpValue := NewQStyleOptionComplexFromPointer(C.QStyleOptionComplex_NewQStyleOptionComplex2(PointerFromQStyleOptionComplex(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionComplex).DestroyQStyleOptionComplex)
	return tmpValue
}

func NewQStyleOptionComplex(version int, ty int) *QStyleOptionComplex {
	tmpValue := NewQStyleOptionComplexFromPointer(C.QStyleOptionComplex_NewQStyleOptionComplex(C.int(int32(version)), C.int(int32(ty))))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionComplex).DestroyQStyleOptionComplex)
	return tmpValue
}

func (ptr *QStyleOptionComplex) ActiveSubControls() QStyle__SubControl {
	if ptr.Pointer() != nil {
		return QStyle__SubControl(C.QStyleOptionComplex_ActiveSubControls(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionComplex) SetActiveSubControls(vqs QStyle__SubControl) {
	if ptr.Pointer() != nil {
		C.QStyleOptionComplex_SetActiveSubControls(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionComplex) SubControls() QStyle__SubControl {
	if ptr.Pointer() != nil {
		return QStyle__SubControl(C.QStyleOptionComplex_SubControls(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionComplex) SetSubControls(vqs QStyle__SubControl) {
	if ptr.Pointer() != nil {
		C.QStyleOptionComplex_SetSubControls(ptr.Pointer(), C.longlong(vqs))
	}
}

type QStyleOptionDockWidget struct {
	QStyleOption
}

type QStyleOptionDockWidget_ITF interface {
	QStyleOption_ITF
	QStyleOptionDockWidget_PTR() *QStyleOptionDockWidget
}

func (ptr *QStyleOptionDockWidget) QStyleOptionDockWidget_PTR() *QStyleOptionDockWidget {
	return ptr
}

func (ptr *QStyleOptionDockWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionDockWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionDockWidget(ptr QStyleOptionDockWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionDockWidget_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionDockWidgetFromPointer(ptr unsafe.Pointer) (n *QStyleOptionDockWidget) {
	n = new(QStyleOptionDockWidget)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionDockWidget) DestroyQStyleOptionDockWidget() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionDockWidget__StyleOptionType
//QStyleOptionDockWidget::StyleOptionType
type QStyleOptionDockWidget__StyleOptionType int64

var (
	QStyleOptionDockWidget__Type QStyleOptionDockWidget__StyleOptionType = QStyleOptionDockWidget__StyleOptionType(QStyleOption__SO_DockWidget)
)

//go:generate stringer -type=QStyleOptionDockWidget__StyleOptionVersion
//QStyleOptionDockWidget::StyleOptionVersion
type QStyleOptionDockWidget__StyleOptionVersion int64

var (
	QStyleOptionDockWidget__Version QStyleOptionDockWidget__StyleOptionVersion = QStyleOptionDockWidget__StyleOptionVersion(2)
)

func NewQStyleOptionDockWidget() *QStyleOptionDockWidget {
	tmpValue := NewQStyleOptionDockWidgetFromPointer(C.QStyleOptionDockWidget_NewQStyleOptionDockWidget())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionDockWidget).DestroyQStyleOptionDockWidget)
	return tmpValue
}

func NewQStyleOptionDockWidget2(other QStyleOptionDockWidget_ITF) *QStyleOptionDockWidget {
	tmpValue := NewQStyleOptionDockWidgetFromPointer(C.QStyleOptionDockWidget_NewQStyleOptionDockWidget2(PointerFromQStyleOptionDockWidget(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionDockWidget).DestroyQStyleOptionDockWidget)
	return tmpValue
}

func (ptr *QStyleOptionDockWidget) Closable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionDockWidget_Closable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionDockWidget) SetClosable(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionDockWidget_SetClosable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionDockWidget) Floatable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionDockWidget_Floatable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionDockWidget) SetFloatable(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionDockWidget_SetFloatable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionDockWidget) Movable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionDockWidget_Movable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionDockWidget) SetMovable(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionDockWidget_SetMovable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionDockWidget) Title() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionDockWidget_Title(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionDockWidget) SetTitle(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionDockWidget_SetTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QStyleOptionDockWidget) VerticalTitleBar() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionDockWidget_VerticalTitleBar(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionDockWidget) SetVerticalTitleBar(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionDockWidget_SetVerticalTitleBar(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

type QStyleOptionFocusRect struct {
	QStyleOption
}

type QStyleOptionFocusRect_ITF interface {
	QStyleOption_ITF
	QStyleOptionFocusRect_PTR() *QStyleOptionFocusRect
}

func (ptr *QStyleOptionFocusRect) QStyleOptionFocusRect_PTR() *QStyleOptionFocusRect {
	return ptr
}

func (ptr *QStyleOptionFocusRect) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionFocusRect) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionFocusRect(ptr QStyleOptionFocusRect_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionFocusRect_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionFocusRectFromPointer(ptr unsafe.Pointer) (n *QStyleOptionFocusRect) {
	n = new(QStyleOptionFocusRect)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionFocusRect) DestroyQStyleOptionFocusRect() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionFocusRect__StyleOptionType
//QStyleOptionFocusRect::StyleOptionType
type QStyleOptionFocusRect__StyleOptionType int64

var (
	QStyleOptionFocusRect__Type QStyleOptionFocusRect__StyleOptionType = QStyleOptionFocusRect__StyleOptionType(QStyleOption__SO_FocusRect)
)

//go:generate stringer -type=QStyleOptionFocusRect__StyleOptionVersion
//QStyleOptionFocusRect::StyleOptionVersion
type QStyleOptionFocusRect__StyleOptionVersion int64

var (
	QStyleOptionFocusRect__Version QStyleOptionFocusRect__StyleOptionVersion = QStyleOptionFocusRect__StyleOptionVersion(1)
)

func NewQStyleOptionFocusRect() *QStyleOptionFocusRect {
	tmpValue := NewQStyleOptionFocusRectFromPointer(C.QStyleOptionFocusRect_NewQStyleOptionFocusRect())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionFocusRect).DestroyQStyleOptionFocusRect)
	return tmpValue
}

func NewQStyleOptionFocusRect2(other QStyleOptionFocusRect_ITF) *QStyleOptionFocusRect {
	tmpValue := NewQStyleOptionFocusRectFromPointer(C.QStyleOptionFocusRect_NewQStyleOptionFocusRect2(PointerFromQStyleOptionFocusRect(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionFocusRect).DestroyQStyleOptionFocusRect)
	return tmpValue
}

func (ptr *QStyleOptionFocusRect) BackgroundColor() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QStyleOptionFocusRect_BackgroundColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionFocusRect) SetBackgroundColor(vqc gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionFocusRect_SetBackgroundColor(ptr.Pointer(), gui.PointerFromQColor(vqc))
	}
}

type QStyleOptionFrame struct {
	QStyleOption
}

type QStyleOptionFrame_ITF interface {
	QStyleOption_ITF
	QStyleOptionFrame_PTR() *QStyleOptionFrame
}

func (ptr *QStyleOptionFrame) QStyleOptionFrame_PTR() *QStyleOptionFrame {
	return ptr
}

func (ptr *QStyleOptionFrame) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionFrame) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionFrame(ptr QStyleOptionFrame_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionFrame_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionFrameFromPointer(ptr unsafe.Pointer) (n *QStyleOptionFrame) {
	n = new(QStyleOptionFrame)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionFrame) DestroyQStyleOptionFrame() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionFrame__FrameFeature
//QStyleOptionFrame::FrameFeature
type QStyleOptionFrame__FrameFeature int64

const (
	QStyleOptionFrame__None    QStyleOptionFrame__FrameFeature = QStyleOptionFrame__FrameFeature(0x00)
	QStyleOptionFrame__Flat    QStyleOptionFrame__FrameFeature = QStyleOptionFrame__FrameFeature(0x01)
	QStyleOptionFrame__Rounded QStyleOptionFrame__FrameFeature = QStyleOptionFrame__FrameFeature(0x02)
)

//go:generate stringer -type=QStyleOptionFrame__StyleOptionType
//QStyleOptionFrame::StyleOptionType
type QStyleOptionFrame__StyleOptionType int64

var (
	QStyleOptionFrame__Type QStyleOptionFrame__StyleOptionType = QStyleOptionFrame__StyleOptionType(QStyleOption__SO_Frame)
)

//go:generate stringer -type=QStyleOptionFrame__StyleOptionVersion
//QStyleOptionFrame::StyleOptionVersion
type QStyleOptionFrame__StyleOptionVersion int64

var (
	QStyleOptionFrame__Version QStyleOptionFrame__StyleOptionVersion = QStyleOptionFrame__StyleOptionVersion(3)
)

func NewQStyleOptionFrame() *QStyleOptionFrame {
	tmpValue := NewQStyleOptionFrameFromPointer(C.QStyleOptionFrame_NewQStyleOptionFrame())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionFrame).DestroyQStyleOptionFrame)
	return tmpValue
}

func NewQStyleOptionFrame2(other QStyleOptionFrame_ITF) *QStyleOptionFrame {
	tmpValue := NewQStyleOptionFrameFromPointer(C.QStyleOptionFrame_NewQStyleOptionFrame2(PointerFromQStyleOptionFrame(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionFrame).DestroyQStyleOptionFrame)
	return tmpValue
}

func (ptr *QStyleOptionFrame) Features() QStyleOptionFrame__FrameFeature {
	if ptr.Pointer() != nil {
		return QStyleOptionFrame__FrameFeature(C.QStyleOptionFrame_Features(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionFrame) SetFeatures(vqs QStyleOptionFrame__FrameFeature) {
	if ptr.Pointer() != nil {
		C.QStyleOptionFrame_SetFeatures(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionFrame) FrameShape() QFrame__Shape {
	if ptr.Pointer() != nil {
		return QFrame__Shape(C.QStyleOptionFrame_FrameShape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionFrame) SetFrameShape(vqf QFrame__Shape) {
	if ptr.Pointer() != nil {
		C.QStyleOptionFrame_SetFrameShape(ptr.Pointer(), C.longlong(vqf))
	}
}

func (ptr *QStyleOptionFrame) LineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionFrame_LineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionFrame) SetLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionFrame_SetLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionFrame) MidLineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionFrame_MidLineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionFrame) SetMidLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionFrame_SetMidLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

type QStyleOptionGraphicsItem struct {
	QStyleOption
}

type QStyleOptionGraphicsItem_ITF interface {
	QStyleOption_ITF
	QStyleOptionGraphicsItem_PTR() *QStyleOptionGraphicsItem
}

func (ptr *QStyleOptionGraphicsItem) QStyleOptionGraphicsItem_PTR() *QStyleOptionGraphicsItem {
	return ptr
}

func (ptr *QStyleOptionGraphicsItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionGraphicsItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionGraphicsItem(ptr QStyleOptionGraphicsItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionGraphicsItem_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionGraphicsItemFromPointer(ptr unsafe.Pointer) (n *QStyleOptionGraphicsItem) {
	n = new(QStyleOptionGraphicsItem)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionGraphicsItem) DestroyQStyleOptionGraphicsItem() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionGraphicsItem__StyleOptionType
//QStyleOptionGraphicsItem::StyleOptionType
type QStyleOptionGraphicsItem__StyleOptionType int64

var (
	QStyleOptionGraphicsItem__Type QStyleOptionGraphicsItem__StyleOptionType = QStyleOptionGraphicsItem__StyleOptionType(QStyleOption__SO_GraphicsItem)
)

//go:generate stringer -type=QStyleOptionGraphicsItem__StyleOptionVersion
//QStyleOptionGraphicsItem::StyleOptionVersion
type QStyleOptionGraphicsItem__StyleOptionVersion int64

var (
	QStyleOptionGraphicsItem__Version QStyleOptionGraphicsItem__StyleOptionVersion = QStyleOptionGraphicsItem__StyleOptionVersion(1)
)

func NewQStyleOptionGraphicsItem() *QStyleOptionGraphicsItem {
	tmpValue := NewQStyleOptionGraphicsItemFromPointer(C.QStyleOptionGraphicsItem_NewQStyleOptionGraphicsItem())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionGraphicsItem).DestroyQStyleOptionGraphicsItem)
	return tmpValue
}

func NewQStyleOptionGraphicsItem2(other QStyleOptionGraphicsItem_ITF) *QStyleOptionGraphicsItem {
	tmpValue := NewQStyleOptionGraphicsItemFromPointer(C.QStyleOptionGraphicsItem_NewQStyleOptionGraphicsItem2(PointerFromQStyleOptionGraphicsItem(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionGraphicsItem).DestroyQStyleOptionGraphicsItem)
	return tmpValue
}

func QStyleOptionGraphicsItem_LevelOfDetailFromTransform(worldTransform gui.QTransform_ITF) float64 {
	return float64(C.QStyleOptionGraphicsItem_QStyleOptionGraphicsItem_LevelOfDetailFromTransform(gui.PointerFromQTransform(worldTransform)))
}

func (ptr *QStyleOptionGraphicsItem) LevelOfDetailFromTransform(worldTransform gui.QTransform_ITF) float64 {
	return float64(C.QStyleOptionGraphicsItem_QStyleOptionGraphicsItem_LevelOfDetailFromTransform(gui.PointerFromQTransform(worldTransform)))
}

func (ptr *QStyleOptionGraphicsItem) ExposedRect() *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QStyleOptionGraphicsItem_ExposedRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionGraphicsItem) SetExposedRect(vqr core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionGraphicsItem_SetExposedRect(ptr.Pointer(), core.PointerFromQRectF(vqr))
	}
}

type QStyleOptionGroupBox struct {
	QStyleOptionComplex
}

type QStyleOptionGroupBox_ITF interface {
	QStyleOptionComplex_ITF
	QStyleOptionGroupBox_PTR() *QStyleOptionGroupBox
}

func (ptr *QStyleOptionGroupBox) QStyleOptionGroupBox_PTR() *QStyleOptionGroupBox {
	return ptr
}

func (ptr *QStyleOptionGroupBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionComplex_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionGroupBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOptionComplex_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionGroupBox(ptr QStyleOptionGroupBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionGroupBox_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionGroupBoxFromPointer(ptr unsafe.Pointer) (n *QStyleOptionGroupBox) {
	n = new(QStyleOptionGroupBox)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionGroupBox) DestroyQStyleOptionGroupBox() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionGroupBox__StyleOptionType
//QStyleOptionGroupBox::StyleOptionType
type QStyleOptionGroupBox__StyleOptionType int64

var (
	QStyleOptionGroupBox__Type QStyleOptionGroupBox__StyleOptionType = QStyleOptionGroupBox__StyleOptionType(QStyleOption__SO_GroupBox)
)

//go:generate stringer -type=QStyleOptionGroupBox__StyleOptionVersion
//QStyleOptionGroupBox::StyleOptionVersion
type QStyleOptionGroupBox__StyleOptionVersion int64

var (
	QStyleOptionGroupBox__Version QStyleOptionGroupBox__StyleOptionVersion = QStyleOptionGroupBox__StyleOptionVersion(1)
)

func NewQStyleOptionGroupBox() *QStyleOptionGroupBox {
	tmpValue := NewQStyleOptionGroupBoxFromPointer(C.QStyleOptionGroupBox_NewQStyleOptionGroupBox())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionGroupBox).DestroyQStyleOptionGroupBox)
	return tmpValue
}

func NewQStyleOptionGroupBox2(other QStyleOptionGroupBox_ITF) *QStyleOptionGroupBox {
	tmpValue := NewQStyleOptionGroupBoxFromPointer(C.QStyleOptionGroupBox_NewQStyleOptionGroupBox2(PointerFromQStyleOptionGroupBox(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionGroupBox).DestroyQStyleOptionGroupBox)
	return tmpValue
}

func (ptr *QStyleOptionGroupBox) Features() QStyleOptionFrame__FrameFeature {
	if ptr.Pointer() != nil {
		return QStyleOptionFrame__FrameFeature(C.QStyleOptionGroupBox_Features(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionGroupBox) SetFeatures(vqs QStyleOptionFrame__FrameFeature) {
	if ptr.Pointer() != nil {
		C.QStyleOptionGroupBox_SetFeatures(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionGroupBox) LineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionGroupBox_LineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionGroupBox) SetLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionGroupBox_SetLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionGroupBox) MidLineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionGroupBox_MidLineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionGroupBox) SetMidLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionGroupBox_SetMidLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionGroupBox) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionGroupBox_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionGroupBox) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionGroupBox_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QStyleOptionGroupBox) TextAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QStyleOptionGroupBox_TextAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionGroupBox) SetTextAlignment(vqt core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QStyleOptionGroupBox_SetTextAlignment(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionGroupBox) TextColor() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QStyleOptionGroupBox_TextColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionGroupBox) SetTextColor(vqc gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionGroupBox_SetTextColor(ptr.Pointer(), gui.PointerFromQColor(vqc))
	}
}

type QStyleOptionHeader struct {
	QStyleOption
}

type QStyleOptionHeader_ITF interface {
	QStyleOption_ITF
	QStyleOptionHeader_PTR() *QStyleOptionHeader
}

func (ptr *QStyleOptionHeader) QStyleOptionHeader_PTR() *QStyleOptionHeader {
	return ptr
}

func (ptr *QStyleOptionHeader) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionHeader) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionHeader(ptr QStyleOptionHeader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionHeader_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionHeaderFromPointer(ptr unsafe.Pointer) (n *QStyleOptionHeader) {
	n = new(QStyleOptionHeader)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionHeader) DestroyQStyleOptionHeader() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionHeader__SectionPosition
//QStyleOptionHeader::SectionPosition
type QStyleOptionHeader__SectionPosition int64

const (
	QStyleOptionHeader__Beginning      QStyleOptionHeader__SectionPosition = QStyleOptionHeader__SectionPosition(0)
	QStyleOptionHeader__Middle         QStyleOptionHeader__SectionPosition = QStyleOptionHeader__SectionPosition(1)
	QStyleOptionHeader__End            QStyleOptionHeader__SectionPosition = QStyleOptionHeader__SectionPosition(2)
	QStyleOptionHeader__OnlyOneSection QStyleOptionHeader__SectionPosition = QStyleOptionHeader__SectionPosition(3)
)

//go:generate stringer -type=QStyleOptionHeader__SelectedPosition
//QStyleOptionHeader::SelectedPosition
type QStyleOptionHeader__SelectedPosition int64

const (
	QStyleOptionHeader__NotAdjacent                QStyleOptionHeader__SelectedPosition = QStyleOptionHeader__SelectedPosition(0)
	QStyleOptionHeader__NextIsSelected             QStyleOptionHeader__SelectedPosition = QStyleOptionHeader__SelectedPosition(1)
	QStyleOptionHeader__PreviousIsSelected         QStyleOptionHeader__SelectedPosition = QStyleOptionHeader__SelectedPosition(2)
	QStyleOptionHeader__NextAndPreviousAreSelected QStyleOptionHeader__SelectedPosition = QStyleOptionHeader__SelectedPosition(3)
)

//go:generate stringer -type=QStyleOptionHeader__SortIndicator
//QStyleOptionHeader::SortIndicator
type QStyleOptionHeader__SortIndicator int64

const (
	QStyleOptionHeader__None     QStyleOptionHeader__SortIndicator = QStyleOptionHeader__SortIndicator(0)
	QStyleOptionHeader__SortUp   QStyleOptionHeader__SortIndicator = QStyleOptionHeader__SortIndicator(1)
	QStyleOptionHeader__SortDown QStyleOptionHeader__SortIndicator = QStyleOptionHeader__SortIndicator(2)
)

//go:generate stringer -type=QStyleOptionHeader__StyleOptionType
//QStyleOptionHeader::StyleOptionType
type QStyleOptionHeader__StyleOptionType int64

var (
	QStyleOptionHeader__Type QStyleOptionHeader__StyleOptionType = QStyleOptionHeader__StyleOptionType(QStyleOption__SO_Header)
)

//go:generate stringer -type=QStyleOptionHeader__StyleOptionVersion
//QStyleOptionHeader::StyleOptionVersion
type QStyleOptionHeader__StyleOptionVersion int64

var (
	QStyleOptionHeader__Version QStyleOptionHeader__StyleOptionVersion = QStyleOptionHeader__StyleOptionVersion(1)
)

func NewQStyleOptionHeader() *QStyleOptionHeader {
	tmpValue := NewQStyleOptionHeaderFromPointer(C.QStyleOptionHeader_NewQStyleOptionHeader())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionHeader).DestroyQStyleOptionHeader)
	return tmpValue
}

func NewQStyleOptionHeader2(other QStyleOptionHeader_ITF) *QStyleOptionHeader {
	tmpValue := NewQStyleOptionHeaderFromPointer(C.QStyleOptionHeader_NewQStyleOptionHeader2(PointerFromQStyleOptionHeader(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionHeader).DestroyQStyleOptionHeader)
	return tmpValue
}

func (ptr *QStyleOptionHeader) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyleOptionHeader_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionHeader) SetIcon(vqi gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionHeader_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(vqi))
	}
}

func (ptr *QStyleOptionHeader) IconAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QStyleOptionHeader_IconAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionHeader) SetIconAlignment(vqt core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QStyleOptionHeader_SetIconAlignment(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionHeader) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QStyleOptionHeader_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionHeader) SetOrientation(vqt core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QStyleOptionHeader_SetOrientation(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionHeader) Position() QStyleOptionHeader__SectionPosition {
	if ptr.Pointer() != nil {
		return QStyleOptionHeader__SectionPosition(C.QStyleOptionHeader_Position(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionHeader) SetPosition(vqs QStyleOptionHeader__SectionPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionHeader_SetPosition(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionHeader) Section() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionHeader_Section(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionHeader) SetSection(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionHeader_SetSection(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionHeader) SelectedPosition() QStyleOptionHeader__SelectedPosition {
	if ptr.Pointer() != nil {
		return QStyleOptionHeader__SelectedPosition(C.QStyleOptionHeader_SelectedPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionHeader) SetSelectedPosition(vqs QStyleOptionHeader__SelectedPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionHeader_SetSelectedPosition(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionHeader) SortIndicator() QStyleOptionHeader__SortIndicator {
	if ptr.Pointer() != nil {
		return QStyleOptionHeader__SortIndicator(C.QStyleOptionHeader_SortIndicator(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionHeader) SetSortIndicator(vqs QStyleOptionHeader__SortIndicator) {
	if ptr.Pointer() != nil {
		C.QStyleOptionHeader_SetSortIndicator(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionHeader) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionHeader_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionHeader) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionHeader_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QStyleOptionHeader) TextAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QStyleOptionHeader_TextAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionHeader) SetTextAlignment(vqt core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QStyleOptionHeader_SetTextAlignment(ptr.Pointer(), C.longlong(vqt))
	}
}

type QStyleOptionMenuItem struct {
	QStyleOption
}

type QStyleOptionMenuItem_ITF interface {
	QStyleOption_ITF
	QStyleOptionMenuItem_PTR() *QStyleOptionMenuItem
}

func (ptr *QStyleOptionMenuItem) QStyleOptionMenuItem_PTR() *QStyleOptionMenuItem {
	return ptr
}

func (ptr *QStyleOptionMenuItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionMenuItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionMenuItem(ptr QStyleOptionMenuItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionMenuItem_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionMenuItemFromPointer(ptr unsafe.Pointer) (n *QStyleOptionMenuItem) {
	n = new(QStyleOptionMenuItem)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionMenuItem) DestroyQStyleOptionMenuItem() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionMenuItem__CheckType
//QStyleOptionMenuItem::CheckType
type QStyleOptionMenuItem__CheckType int64

const (
	QStyleOptionMenuItem__NotCheckable QStyleOptionMenuItem__CheckType = QStyleOptionMenuItem__CheckType(0)
	QStyleOptionMenuItem__Exclusive    QStyleOptionMenuItem__CheckType = QStyleOptionMenuItem__CheckType(1)
	QStyleOptionMenuItem__NonExclusive QStyleOptionMenuItem__CheckType = QStyleOptionMenuItem__CheckType(2)
)

//go:generate stringer -type=QStyleOptionMenuItem__MenuItemType
//QStyleOptionMenuItem::MenuItemType
type QStyleOptionMenuItem__MenuItemType int64

const (
	QStyleOptionMenuItem__Normal      QStyleOptionMenuItem__MenuItemType = QStyleOptionMenuItem__MenuItemType(0)
	QStyleOptionMenuItem__DefaultItem QStyleOptionMenuItem__MenuItemType = QStyleOptionMenuItem__MenuItemType(1)
	QStyleOptionMenuItem__Separator   QStyleOptionMenuItem__MenuItemType = QStyleOptionMenuItem__MenuItemType(2)
	QStyleOptionMenuItem__SubMenu     QStyleOptionMenuItem__MenuItemType = QStyleOptionMenuItem__MenuItemType(3)
	QStyleOptionMenuItem__Scroller    QStyleOptionMenuItem__MenuItemType = QStyleOptionMenuItem__MenuItemType(4)
	QStyleOptionMenuItem__TearOff     QStyleOptionMenuItem__MenuItemType = QStyleOptionMenuItem__MenuItemType(5)
	QStyleOptionMenuItem__Margin      QStyleOptionMenuItem__MenuItemType = QStyleOptionMenuItem__MenuItemType(6)
	QStyleOptionMenuItem__EmptyArea   QStyleOptionMenuItem__MenuItemType = QStyleOptionMenuItem__MenuItemType(7)
)

//go:generate stringer -type=QStyleOptionMenuItem__StyleOptionType
//QStyleOptionMenuItem::StyleOptionType
type QStyleOptionMenuItem__StyleOptionType int64

var (
	QStyleOptionMenuItem__Type QStyleOptionMenuItem__StyleOptionType = QStyleOptionMenuItem__StyleOptionType(QStyleOption__SO_MenuItem)
)

//go:generate stringer -type=QStyleOptionMenuItem__StyleOptionVersion
//QStyleOptionMenuItem::StyleOptionVersion
type QStyleOptionMenuItem__StyleOptionVersion int64

var (
	QStyleOptionMenuItem__Version QStyleOptionMenuItem__StyleOptionVersion = QStyleOptionMenuItem__StyleOptionVersion(1)
)

func NewQStyleOptionMenuItem() *QStyleOptionMenuItem {
	tmpValue := NewQStyleOptionMenuItemFromPointer(C.QStyleOptionMenuItem_NewQStyleOptionMenuItem())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionMenuItem).DestroyQStyleOptionMenuItem)
	return tmpValue
}

func NewQStyleOptionMenuItem2(other QStyleOptionMenuItem_ITF) *QStyleOptionMenuItem {
	tmpValue := NewQStyleOptionMenuItemFromPointer(C.QStyleOptionMenuItem_NewQStyleOptionMenuItem2(PointerFromQStyleOptionMenuItem(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionMenuItem).DestroyQStyleOptionMenuItem)
	return tmpValue
}

func (ptr *QStyleOptionMenuItem) CheckType() QStyleOptionMenuItem__CheckType {
	if ptr.Pointer() != nil {
		return QStyleOptionMenuItem__CheckType(C.QStyleOptionMenuItem_CheckType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionMenuItem) SetCheckType(vqs QStyleOptionMenuItem__CheckType) {
	if ptr.Pointer() != nil {
		C.QStyleOptionMenuItem_SetCheckType(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionMenuItem) Checked() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionMenuItem_Checked(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionMenuItem) SetChecked(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionMenuItem_SetChecked(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionMenuItem) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QStyleOptionMenuItem_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionMenuItem) SetFont(vqf gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionMenuItem_SetFont(ptr.Pointer(), gui.PointerFromQFont(vqf))
	}
}

func (ptr *QStyleOptionMenuItem) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyleOptionMenuItem_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionMenuItem) SetIcon(vqi gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionMenuItem_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(vqi))
	}
}

func (ptr *QStyleOptionMenuItem) MaxIconWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionMenuItem_MaxIconWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionMenuItem) SetMaxIconWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionMenuItem_SetMaxIconWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionMenuItem) MenuHasCheckableItems() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionMenuItem_MenuHasCheckableItems(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionMenuItem) SetMenuHasCheckableItems(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionMenuItem_SetMenuHasCheckableItems(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionMenuItem) MenuItemType() QStyleOptionMenuItem__MenuItemType {
	if ptr.Pointer() != nil {
		return QStyleOptionMenuItem__MenuItemType(C.QStyleOptionMenuItem_MenuItemType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionMenuItem) SetMenuItemType(vqs QStyleOptionMenuItem__MenuItemType) {
	if ptr.Pointer() != nil {
		C.QStyleOptionMenuItem_SetMenuItemType(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionMenuItem) MenuRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyleOptionMenuItem_MenuRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionMenuItem) SetMenuRect(vqr core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionMenuItem_SetMenuRect(ptr.Pointer(), core.PointerFromQRect(vqr))
	}
}

func (ptr *QStyleOptionMenuItem) TabWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionMenuItem_TabWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionMenuItem) SetTabWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionMenuItem_SetTabWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionMenuItem) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionMenuItem_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionMenuItem) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionMenuItem_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

type QStyleOptionProgressBar struct {
	QStyleOption
}

type QStyleOptionProgressBar_ITF interface {
	QStyleOption_ITF
	QStyleOptionProgressBar_PTR() *QStyleOptionProgressBar
}

func (ptr *QStyleOptionProgressBar) QStyleOptionProgressBar_PTR() *QStyleOptionProgressBar {
	return ptr
}

func (ptr *QStyleOptionProgressBar) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionProgressBar) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionProgressBar(ptr QStyleOptionProgressBar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionProgressBar_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionProgressBarFromPointer(ptr unsafe.Pointer) (n *QStyleOptionProgressBar) {
	n = new(QStyleOptionProgressBar)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionProgressBar) DestroyQStyleOptionProgressBar() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionProgressBar__StyleOptionType
//QStyleOptionProgressBar::StyleOptionType
type QStyleOptionProgressBar__StyleOptionType int64

var (
	QStyleOptionProgressBar__Type QStyleOptionProgressBar__StyleOptionType = QStyleOptionProgressBar__StyleOptionType(QStyleOption__SO_ProgressBar)
)

//go:generate stringer -type=QStyleOptionProgressBar__StyleOptionVersion
//QStyleOptionProgressBar::StyleOptionVersion
type QStyleOptionProgressBar__StyleOptionVersion int64

var (
	QStyleOptionProgressBar__Version QStyleOptionProgressBar__StyleOptionVersion = QStyleOptionProgressBar__StyleOptionVersion(2)
)

func NewQStyleOptionProgressBar() *QStyleOptionProgressBar {
	tmpValue := NewQStyleOptionProgressBarFromPointer(C.QStyleOptionProgressBar_NewQStyleOptionProgressBar())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionProgressBar).DestroyQStyleOptionProgressBar)
	return tmpValue
}

func NewQStyleOptionProgressBar2(other QStyleOptionProgressBar_ITF) *QStyleOptionProgressBar {
	tmpValue := NewQStyleOptionProgressBarFromPointer(C.QStyleOptionProgressBar_NewQStyleOptionProgressBar2(PointerFromQStyleOptionProgressBar(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionProgressBar).DestroyQStyleOptionProgressBar)
	return tmpValue
}

func (ptr *QStyleOptionProgressBar) BottomToTop() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionProgressBar_BottomToTop(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionProgressBar) SetBottomToTop(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionProgressBar_SetBottomToTop(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionProgressBar) InvertedAppearance() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionProgressBar_InvertedAppearance(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionProgressBar) SetInvertedAppearance(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionProgressBar_SetInvertedAppearance(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionProgressBar) Maximum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionProgressBar_Maximum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionProgressBar) SetMaximum(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionProgressBar_SetMaximum(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionProgressBar) Minimum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionProgressBar_Minimum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionProgressBar) SetMinimum(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionProgressBar_SetMinimum(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionProgressBar) Progress() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionProgressBar_Progress(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionProgressBar) SetProgress(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionProgressBar_SetProgress(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionProgressBar) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionProgressBar_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionProgressBar) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionProgressBar_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QStyleOptionProgressBar) TextAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QStyleOptionProgressBar_TextAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionProgressBar) SetTextAlignment(vqt core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QStyleOptionProgressBar_SetTextAlignment(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionProgressBar) TextVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionProgressBar_TextVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionProgressBar) SetTextVisible(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionProgressBar_SetTextVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

type QStyleOptionRubberBand struct {
	QStyleOption
}

type QStyleOptionRubberBand_ITF interface {
	QStyleOption_ITF
	QStyleOptionRubberBand_PTR() *QStyleOptionRubberBand
}

func (ptr *QStyleOptionRubberBand) QStyleOptionRubberBand_PTR() *QStyleOptionRubberBand {
	return ptr
}

func (ptr *QStyleOptionRubberBand) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionRubberBand) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionRubberBand(ptr QStyleOptionRubberBand_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionRubberBand_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionRubberBandFromPointer(ptr unsafe.Pointer) (n *QStyleOptionRubberBand) {
	n = new(QStyleOptionRubberBand)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionRubberBand) DestroyQStyleOptionRubberBand() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionRubberBand__StyleOptionType
//QStyleOptionRubberBand::StyleOptionType
type QStyleOptionRubberBand__StyleOptionType int64

var (
	QStyleOptionRubberBand__Type QStyleOptionRubberBand__StyleOptionType = QStyleOptionRubberBand__StyleOptionType(QStyleOption__SO_RubberBand)
)

//go:generate stringer -type=QStyleOptionRubberBand__StyleOptionVersion
//QStyleOptionRubberBand::StyleOptionVersion
type QStyleOptionRubberBand__StyleOptionVersion int64

var (
	QStyleOptionRubberBand__Version QStyleOptionRubberBand__StyleOptionVersion = QStyleOptionRubberBand__StyleOptionVersion(1)
)

func NewQStyleOptionRubberBand() *QStyleOptionRubberBand {
	tmpValue := NewQStyleOptionRubberBandFromPointer(C.QStyleOptionRubberBand_NewQStyleOptionRubberBand())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionRubberBand).DestroyQStyleOptionRubberBand)
	return tmpValue
}

func NewQStyleOptionRubberBand2(other QStyleOptionRubberBand_ITF) *QStyleOptionRubberBand {
	tmpValue := NewQStyleOptionRubberBandFromPointer(C.QStyleOptionRubberBand_NewQStyleOptionRubberBand2(PointerFromQStyleOptionRubberBand(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionRubberBand).DestroyQStyleOptionRubberBand)
	return tmpValue
}

func (ptr *QStyleOptionRubberBand) Opaque() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionRubberBand_Opaque(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionRubberBand) SetOpaque(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionRubberBand_SetOpaque(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionRubberBand) Shape() QRubberBand__Shape {
	if ptr.Pointer() != nil {
		return QRubberBand__Shape(C.QStyleOptionRubberBand_Shape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionRubberBand) SetShape(vqr QRubberBand__Shape) {
	if ptr.Pointer() != nil {
		C.QStyleOptionRubberBand_SetShape(ptr.Pointer(), C.longlong(vqr))
	}
}

type QStyleOptionSizeGrip struct {
	QStyleOptionComplex
}

type QStyleOptionSizeGrip_ITF interface {
	QStyleOptionComplex_ITF
	QStyleOptionSizeGrip_PTR() *QStyleOptionSizeGrip
}

func (ptr *QStyleOptionSizeGrip) QStyleOptionSizeGrip_PTR() *QStyleOptionSizeGrip {
	return ptr
}

func (ptr *QStyleOptionSizeGrip) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionComplex_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionSizeGrip) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOptionComplex_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionSizeGrip(ptr QStyleOptionSizeGrip_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionSizeGrip_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionSizeGripFromPointer(ptr unsafe.Pointer) (n *QStyleOptionSizeGrip) {
	n = new(QStyleOptionSizeGrip)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionSizeGrip) DestroyQStyleOptionSizeGrip() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionSizeGrip__StyleOptionType
//QStyleOptionSizeGrip::StyleOptionType
type QStyleOptionSizeGrip__StyleOptionType int64

var (
	QStyleOptionSizeGrip__Type QStyleOptionSizeGrip__StyleOptionType = QStyleOptionSizeGrip__StyleOptionType(QStyleOption__SO_SizeGrip)
)

//go:generate stringer -type=QStyleOptionSizeGrip__StyleOptionVersion
//QStyleOptionSizeGrip::StyleOptionVersion
type QStyleOptionSizeGrip__StyleOptionVersion int64

var (
	QStyleOptionSizeGrip__Version QStyleOptionSizeGrip__StyleOptionVersion = QStyleOptionSizeGrip__StyleOptionVersion(1)
)

func NewQStyleOptionSizeGrip() *QStyleOptionSizeGrip {
	tmpValue := NewQStyleOptionSizeGripFromPointer(C.QStyleOptionSizeGrip_NewQStyleOptionSizeGrip())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionSizeGrip).DestroyQStyleOptionSizeGrip)
	return tmpValue
}

func NewQStyleOptionSizeGrip2(other QStyleOptionSizeGrip_ITF) *QStyleOptionSizeGrip {
	tmpValue := NewQStyleOptionSizeGripFromPointer(C.QStyleOptionSizeGrip_NewQStyleOptionSizeGrip2(PointerFromQStyleOptionSizeGrip(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionSizeGrip).DestroyQStyleOptionSizeGrip)
	return tmpValue
}

func (ptr *QStyleOptionSizeGrip) Corner() core.Qt__Corner {
	if ptr.Pointer() != nil {
		return core.Qt__Corner(C.QStyleOptionSizeGrip_Corner(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionSizeGrip) SetCorner(vqt core.Qt__Corner) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSizeGrip_SetCorner(ptr.Pointer(), C.longlong(vqt))
	}
}

type QStyleOptionSlider struct {
	QStyleOptionComplex
}

type QStyleOptionSlider_ITF interface {
	QStyleOptionComplex_ITF
	QStyleOptionSlider_PTR() *QStyleOptionSlider
}

func (ptr *QStyleOptionSlider) QStyleOptionSlider_PTR() *QStyleOptionSlider {
	return ptr
}

func (ptr *QStyleOptionSlider) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionComplex_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionSlider) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOptionComplex_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionSlider(ptr QStyleOptionSlider_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionSlider_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionSliderFromPointer(ptr unsafe.Pointer) (n *QStyleOptionSlider) {
	n = new(QStyleOptionSlider)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionSlider) DestroyQStyleOptionSlider() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionSlider__StyleOptionType
//QStyleOptionSlider::StyleOptionType
type QStyleOptionSlider__StyleOptionType int64

var (
	QStyleOptionSlider__Type QStyleOptionSlider__StyleOptionType = QStyleOptionSlider__StyleOptionType(QStyleOption__SO_Slider)
)

//go:generate stringer -type=QStyleOptionSlider__StyleOptionVersion
//QStyleOptionSlider::StyleOptionVersion
type QStyleOptionSlider__StyleOptionVersion int64

var (
	QStyleOptionSlider__Version QStyleOptionSlider__StyleOptionVersion = QStyleOptionSlider__StyleOptionVersion(1)
)

func NewQStyleOptionSlider() *QStyleOptionSlider {
	tmpValue := NewQStyleOptionSliderFromPointer(C.QStyleOptionSlider_NewQStyleOptionSlider())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionSlider).DestroyQStyleOptionSlider)
	return tmpValue
}

func NewQStyleOptionSlider2(other QStyleOptionSlider_ITF) *QStyleOptionSlider {
	tmpValue := NewQStyleOptionSliderFromPointer(C.QStyleOptionSlider_NewQStyleOptionSlider2(PointerFromQStyleOptionSlider(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionSlider).DestroyQStyleOptionSlider)
	return tmpValue
}

func (ptr *QStyleOptionSlider) DialWrapping() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionSlider_DialWrapping(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionSlider) SetDialWrapping(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetDialWrapping(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionSlider) Maximum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionSlider_Maximum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetMaximum(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetMaximum(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionSlider) Minimum() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionSlider_Minimum(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetMinimum(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetMinimum(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionSlider) NotchTarget() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QStyleOptionSlider_NotchTarget(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetNotchTarget(vqr float64) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetNotchTarget(ptr.Pointer(), C.double(vqr))
	}
}

func (ptr *QStyleOptionSlider) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QStyleOptionSlider_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetOrientation(vqt core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetOrientation(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionSlider) PageStep() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionSlider_PageStep(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetPageStep(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetPageStep(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionSlider) SingleStep() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionSlider_SingleStep(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetSingleStep(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetSingleStep(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionSlider) SliderPosition() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionSlider_SliderPosition(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetSliderPosition(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetSliderPosition(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionSlider) SliderValue() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionSlider_SliderValue(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetSliderValue(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetSliderValue(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionSlider) TickInterval() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionSlider_TickInterval(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetTickInterval(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetTickInterval(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionSlider) TickPosition() QSlider__TickPosition {
	if ptr.Pointer() != nil {
		return QSlider__TickPosition(C.QStyleOptionSlider_TickPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionSlider) SetTickPosition(vqs QSlider__TickPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetTickPosition(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionSlider) UpsideDown() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionSlider_UpsideDown(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionSlider) SetUpsideDown(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSlider_SetUpsideDown(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

type QStyleOptionSpinBox struct {
	QStyleOptionComplex
}

type QStyleOptionSpinBox_ITF interface {
	QStyleOptionComplex_ITF
	QStyleOptionSpinBox_PTR() *QStyleOptionSpinBox
}

func (ptr *QStyleOptionSpinBox) QStyleOptionSpinBox_PTR() *QStyleOptionSpinBox {
	return ptr
}

func (ptr *QStyleOptionSpinBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionComplex_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionSpinBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOptionComplex_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionSpinBox(ptr QStyleOptionSpinBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionSpinBox_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionSpinBoxFromPointer(ptr unsafe.Pointer) (n *QStyleOptionSpinBox) {
	n = new(QStyleOptionSpinBox)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionSpinBox) DestroyQStyleOptionSpinBox() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionSpinBox__StyleOptionType
//QStyleOptionSpinBox::StyleOptionType
type QStyleOptionSpinBox__StyleOptionType int64

var (
	QStyleOptionSpinBox__Type QStyleOptionSpinBox__StyleOptionType = QStyleOptionSpinBox__StyleOptionType(QStyleOption__SO_SpinBox)
)

//go:generate stringer -type=QStyleOptionSpinBox__StyleOptionVersion
//QStyleOptionSpinBox::StyleOptionVersion
type QStyleOptionSpinBox__StyleOptionVersion int64

var (
	QStyleOptionSpinBox__Version QStyleOptionSpinBox__StyleOptionVersion = QStyleOptionSpinBox__StyleOptionVersion(1)
)

func NewQStyleOptionSpinBox() *QStyleOptionSpinBox {
	tmpValue := NewQStyleOptionSpinBoxFromPointer(C.QStyleOptionSpinBox_NewQStyleOptionSpinBox())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionSpinBox).DestroyQStyleOptionSpinBox)
	return tmpValue
}

func NewQStyleOptionSpinBox2(other QStyleOptionSpinBox_ITF) *QStyleOptionSpinBox {
	tmpValue := NewQStyleOptionSpinBoxFromPointer(C.QStyleOptionSpinBox_NewQStyleOptionSpinBox2(PointerFromQStyleOptionSpinBox(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionSpinBox).DestroyQStyleOptionSpinBox)
	return tmpValue
}

func (ptr *QStyleOptionSpinBox) ButtonSymbols() QAbstractSpinBox__ButtonSymbols {
	if ptr.Pointer() != nil {
		return QAbstractSpinBox__ButtonSymbols(C.QStyleOptionSpinBox_ButtonSymbols(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionSpinBox) SetButtonSymbols(vqa QAbstractSpinBox__ButtonSymbols) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSpinBox_SetButtonSymbols(ptr.Pointer(), C.longlong(vqa))
	}
}

func (ptr *QStyleOptionSpinBox) Frame() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionSpinBox_Frame(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionSpinBox) SetFrame(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSpinBox_SetFrame(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionSpinBox) StepEnabled() QAbstractSpinBox__StepEnabledFlag {
	if ptr.Pointer() != nil {
		return QAbstractSpinBox__StepEnabledFlag(C.QStyleOptionSpinBox_StepEnabled(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionSpinBox) SetStepEnabled(vqa QAbstractSpinBox__StepEnabledFlag) {
	if ptr.Pointer() != nil {
		C.QStyleOptionSpinBox_SetStepEnabled(ptr.Pointer(), C.longlong(vqa))
	}
}

type QStyleOptionTab struct {
	QStyleOption
}

type QStyleOptionTab_ITF interface {
	QStyleOption_ITF
	QStyleOptionTab_PTR() *QStyleOptionTab
}

func (ptr *QStyleOptionTab) QStyleOptionTab_PTR() *QStyleOptionTab {
	return ptr
}

func (ptr *QStyleOptionTab) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionTab) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionTab(ptr QStyleOptionTab_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionTab_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionTabFromPointer(ptr unsafe.Pointer) (n *QStyleOptionTab) {
	n = new(QStyleOptionTab)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionTab) DestroyQStyleOptionTab() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionTab__CornerWidget
//QStyleOptionTab::CornerWidget
type QStyleOptionTab__CornerWidget int64

const (
	QStyleOptionTab__NoCornerWidgets   QStyleOptionTab__CornerWidget = QStyleOptionTab__CornerWidget(0x00)
	QStyleOptionTab__LeftCornerWidget  QStyleOptionTab__CornerWidget = QStyleOptionTab__CornerWidget(0x01)
	QStyleOptionTab__RightCornerWidget QStyleOptionTab__CornerWidget = QStyleOptionTab__CornerWidget(0x02)
)

//go:generate stringer -type=QStyleOptionTab__SelectedPosition
//QStyleOptionTab::SelectedPosition
type QStyleOptionTab__SelectedPosition int64

const (
	QStyleOptionTab__NotAdjacent        QStyleOptionTab__SelectedPosition = QStyleOptionTab__SelectedPosition(0)
	QStyleOptionTab__NextIsSelected     QStyleOptionTab__SelectedPosition = QStyleOptionTab__SelectedPosition(1)
	QStyleOptionTab__PreviousIsSelected QStyleOptionTab__SelectedPosition = QStyleOptionTab__SelectedPosition(2)
)

//go:generate stringer -type=QStyleOptionTab__StyleOptionType
//QStyleOptionTab::StyleOptionType
type QStyleOptionTab__StyleOptionType int64

var (
	QStyleOptionTab__Type QStyleOptionTab__StyleOptionType = QStyleOptionTab__StyleOptionType(QStyleOption__SO_Tab)
)

//go:generate stringer -type=QStyleOptionTab__StyleOptionVersion
//QStyleOptionTab::StyleOptionVersion
type QStyleOptionTab__StyleOptionVersion int64

var (
	QStyleOptionTab__Version QStyleOptionTab__StyleOptionVersion = QStyleOptionTab__StyleOptionVersion(3)
)

//go:generate stringer -type=QStyleOptionTab__TabFeature
//QStyleOptionTab::TabFeature
type QStyleOptionTab__TabFeature int64

const (
	QStyleOptionTab__None     QStyleOptionTab__TabFeature = QStyleOptionTab__TabFeature(0x00)
	QStyleOptionTab__HasFrame QStyleOptionTab__TabFeature = QStyleOptionTab__TabFeature(0x01)
)

//go:generate stringer -type=QStyleOptionTab__TabPosition
//QStyleOptionTab::TabPosition
type QStyleOptionTab__TabPosition int64

const (
	QStyleOptionTab__Beginning  QStyleOptionTab__TabPosition = QStyleOptionTab__TabPosition(0)
	QStyleOptionTab__Middle     QStyleOptionTab__TabPosition = QStyleOptionTab__TabPosition(1)
	QStyleOptionTab__End        QStyleOptionTab__TabPosition = QStyleOptionTab__TabPosition(2)
	QStyleOptionTab__OnlyOneTab QStyleOptionTab__TabPosition = QStyleOptionTab__TabPosition(3)
)

func NewQStyleOptionTab() *QStyleOptionTab {
	tmpValue := NewQStyleOptionTabFromPointer(C.QStyleOptionTab_NewQStyleOptionTab())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionTab).DestroyQStyleOptionTab)
	return tmpValue
}

func NewQStyleOptionTab2(other QStyleOptionTab_ITF) *QStyleOptionTab {
	tmpValue := NewQStyleOptionTabFromPointer(C.QStyleOptionTab_NewQStyleOptionTab2(PointerFromQStyleOptionTab(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionTab).DestroyQStyleOptionTab)
	return tmpValue
}

func (ptr *QStyleOptionTab) CornerWidgets() QStyleOptionTab__CornerWidget {
	if ptr.Pointer() != nil {
		return QStyleOptionTab__CornerWidget(C.QStyleOptionTab_CornerWidgets(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionTab) SetCornerWidgets(vqs QStyleOptionTab__CornerWidget) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetCornerWidgets(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionTab) DocumentMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionTab_DocumentMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionTab) SetDocumentMode(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetDocumentMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionTab) Features() QStyleOptionTab__TabFeature {
	if ptr.Pointer() != nil {
		return QStyleOptionTab__TabFeature(C.QStyleOptionTab_Features(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionTab) SetFeatures(vqs QStyleOptionTab__TabFeature) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetFeatures(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionTab) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyleOptionTab_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTab) SetIcon(vqi gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(vqi))
	}
}

func (ptr *QStyleOptionTab) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionTab_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTab) SetIconSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetIconSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QStyleOptionTab) LeftButtonSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionTab_LeftButtonSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTab) SetLeftButtonSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetLeftButtonSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QStyleOptionTab) Position() QStyleOptionTab__TabPosition {
	if ptr.Pointer() != nil {
		return QStyleOptionTab__TabPosition(C.QStyleOptionTab_Position(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionTab) SetPosition(vqs QStyleOptionTab__TabPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetPosition(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionTab) RightButtonSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionTab_RightButtonSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTab) SetRightButtonSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetRightButtonSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QStyleOptionTab) Row() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionTab_Row(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionTab) SetRow(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetRow(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionTab) SelectedPosition() QStyleOptionTab__SelectedPosition {
	if ptr.Pointer() != nil {
		return QStyleOptionTab__SelectedPosition(C.QStyleOptionTab_SelectedPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionTab) SetSelectedPosition(vqs QStyleOptionTab__SelectedPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetSelectedPosition(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionTab) Shape() QTabBar__Shape {
	if ptr.Pointer() != nil {
		return QTabBar__Shape(C.QStyleOptionTab_Shape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionTab) SetShape(vqt QTabBar__Shape) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTab_SetShape(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionTab) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionTab_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionTab) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionTab_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

type QStyleOptionTabBarBase struct {
	QStyleOption
}

type QStyleOptionTabBarBase_ITF interface {
	QStyleOption_ITF
	QStyleOptionTabBarBase_PTR() *QStyleOptionTabBarBase
}

func (ptr *QStyleOptionTabBarBase) QStyleOptionTabBarBase_PTR() *QStyleOptionTabBarBase {
	return ptr
}

func (ptr *QStyleOptionTabBarBase) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionTabBarBase) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionTabBarBase(ptr QStyleOptionTabBarBase_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionTabBarBase_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionTabBarBaseFromPointer(ptr unsafe.Pointer) (n *QStyleOptionTabBarBase) {
	n = new(QStyleOptionTabBarBase)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionTabBarBase) DestroyQStyleOptionTabBarBase() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionTabBarBase__StyleOptionType
//QStyleOptionTabBarBase::StyleOptionType
type QStyleOptionTabBarBase__StyleOptionType int64

var (
	QStyleOptionTabBarBase__Type QStyleOptionTabBarBase__StyleOptionType = QStyleOptionTabBarBase__StyleOptionType(QStyleOption__SO_TabBarBase)
)

//go:generate stringer -type=QStyleOptionTabBarBase__StyleOptionVersion
//QStyleOptionTabBarBase::StyleOptionVersion
type QStyleOptionTabBarBase__StyleOptionVersion int64

var (
	QStyleOptionTabBarBase__Version QStyleOptionTabBarBase__StyleOptionVersion = QStyleOptionTabBarBase__StyleOptionVersion(2)
)

func NewQStyleOptionTabBarBase() *QStyleOptionTabBarBase {
	tmpValue := NewQStyleOptionTabBarBaseFromPointer(C.QStyleOptionTabBarBase_NewQStyleOptionTabBarBase())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionTabBarBase).DestroyQStyleOptionTabBarBase)
	return tmpValue
}

func NewQStyleOptionTabBarBase2(other QStyleOptionTabBarBase_ITF) *QStyleOptionTabBarBase {
	tmpValue := NewQStyleOptionTabBarBaseFromPointer(C.QStyleOptionTabBarBase_NewQStyleOptionTabBarBase2(PointerFromQStyleOptionTabBarBase(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionTabBarBase).DestroyQStyleOptionTabBarBase)
	return tmpValue
}

func (ptr *QStyleOptionTabBarBase) DocumentMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionTabBarBase_DocumentMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionTabBarBase) SetDocumentMode(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabBarBase_SetDocumentMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionTabBarBase) SelectedTabRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyleOptionTabBarBase_SelectedTabRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTabBarBase) SetSelectedTabRect(vqr core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabBarBase_SetSelectedTabRect(ptr.Pointer(), core.PointerFromQRect(vqr))
	}
}

func (ptr *QStyleOptionTabBarBase) Shape() QTabBar__Shape {
	if ptr.Pointer() != nil {
		return QTabBar__Shape(C.QStyleOptionTabBarBase_Shape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionTabBarBase) SetShape(vqt QTabBar__Shape) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabBarBase_SetShape(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionTabBarBase) TabBarRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyleOptionTabBarBase_TabBarRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTabBarBase) SetTabBarRect(vqr core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabBarBase_SetTabBarRect(ptr.Pointer(), core.PointerFromQRect(vqr))
	}
}

type QStyleOptionTabWidgetFrame struct {
	QStyleOption
}

type QStyleOptionTabWidgetFrame_ITF interface {
	QStyleOption_ITF
	QStyleOptionTabWidgetFrame_PTR() *QStyleOptionTabWidgetFrame
}

func (ptr *QStyleOptionTabWidgetFrame) QStyleOptionTabWidgetFrame_PTR() *QStyleOptionTabWidgetFrame {
	return ptr
}

func (ptr *QStyleOptionTabWidgetFrame) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionTabWidgetFrame) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionTabWidgetFrame(ptr QStyleOptionTabWidgetFrame_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionTabWidgetFrame_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionTabWidgetFrameFromPointer(ptr unsafe.Pointer) (n *QStyleOptionTabWidgetFrame) {
	n = new(QStyleOptionTabWidgetFrame)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionTabWidgetFrame) DestroyQStyleOptionTabWidgetFrame() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionTabWidgetFrame__StyleOptionType
//QStyleOptionTabWidgetFrame::StyleOptionType
type QStyleOptionTabWidgetFrame__StyleOptionType int64

var (
	QStyleOptionTabWidgetFrame__Type QStyleOptionTabWidgetFrame__StyleOptionType = QStyleOptionTabWidgetFrame__StyleOptionType(QStyleOption__SO_TabWidgetFrame)
)

//go:generate stringer -type=QStyleOptionTabWidgetFrame__StyleOptionVersion
//QStyleOptionTabWidgetFrame::StyleOptionVersion
type QStyleOptionTabWidgetFrame__StyleOptionVersion int64

var (
	QStyleOptionTabWidgetFrame__Version QStyleOptionTabWidgetFrame__StyleOptionVersion = QStyleOptionTabWidgetFrame__StyleOptionVersion(2)
)

func NewQStyleOptionTabWidgetFrame() *QStyleOptionTabWidgetFrame {
	tmpValue := NewQStyleOptionTabWidgetFrameFromPointer(C.QStyleOptionTabWidgetFrame_NewQStyleOptionTabWidgetFrame())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionTabWidgetFrame).DestroyQStyleOptionTabWidgetFrame)
	return tmpValue
}

func NewQStyleOptionTabWidgetFrame2(other QStyleOptionTabWidgetFrame_ITF) *QStyleOptionTabWidgetFrame {
	tmpValue := NewQStyleOptionTabWidgetFrameFromPointer(C.QStyleOptionTabWidgetFrame_NewQStyleOptionTabWidgetFrame2(PointerFromQStyleOptionTabWidgetFrame(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionTabWidgetFrame).DestroyQStyleOptionTabWidgetFrame)
	return tmpValue
}

func (ptr *QStyleOptionTabWidgetFrame) LeftCornerWidgetSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionTabWidgetFrame_LeftCornerWidgetSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTabWidgetFrame) SetLeftCornerWidgetSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabWidgetFrame_SetLeftCornerWidgetSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QStyleOptionTabWidgetFrame) LineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionTabWidgetFrame_LineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionTabWidgetFrame) SetLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabWidgetFrame_SetLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionTabWidgetFrame) MidLineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionTabWidgetFrame_MidLineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionTabWidgetFrame) SetMidLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabWidgetFrame_SetMidLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionTabWidgetFrame) RightCornerWidgetSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionTabWidgetFrame_RightCornerWidgetSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTabWidgetFrame) SetRightCornerWidgetSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabWidgetFrame_SetRightCornerWidgetSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QStyleOptionTabWidgetFrame) SelectedTabRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyleOptionTabWidgetFrame_SelectedTabRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTabWidgetFrame) SetSelectedTabRect(vqr core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabWidgetFrame_SetSelectedTabRect(ptr.Pointer(), core.PointerFromQRect(vqr))
	}
}

func (ptr *QStyleOptionTabWidgetFrame) Shape() QTabBar__Shape {
	if ptr.Pointer() != nil {
		return QTabBar__Shape(C.QStyleOptionTabWidgetFrame_Shape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionTabWidgetFrame) SetShape(vqt QTabBar__Shape) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabWidgetFrame_SetShape(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionTabWidgetFrame) TabBarRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStyleOptionTabWidgetFrame_TabBarRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTabWidgetFrame) SetTabBarRect(vqr core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabWidgetFrame_SetTabBarRect(ptr.Pointer(), core.PointerFromQRect(vqr))
	}
}

func (ptr *QStyleOptionTabWidgetFrame) TabBarSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionTabWidgetFrame_TabBarSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTabWidgetFrame) SetTabBarSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTabWidgetFrame_SetTabBarSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

type QStyleOptionTitleBar struct {
	QStyleOptionComplex
}

type QStyleOptionTitleBar_ITF interface {
	QStyleOptionComplex_ITF
	QStyleOptionTitleBar_PTR() *QStyleOptionTitleBar
}

func (ptr *QStyleOptionTitleBar) QStyleOptionTitleBar_PTR() *QStyleOptionTitleBar {
	return ptr
}

func (ptr *QStyleOptionTitleBar) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionComplex_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionTitleBar) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOptionComplex_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionTitleBar(ptr QStyleOptionTitleBar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionTitleBar_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionTitleBarFromPointer(ptr unsafe.Pointer) (n *QStyleOptionTitleBar) {
	n = new(QStyleOptionTitleBar)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionTitleBar) DestroyQStyleOptionTitleBar() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionTitleBar__StyleOptionType
//QStyleOptionTitleBar::StyleOptionType
type QStyleOptionTitleBar__StyleOptionType int64

var (
	QStyleOptionTitleBar__Type QStyleOptionTitleBar__StyleOptionType = QStyleOptionTitleBar__StyleOptionType(QStyleOption__SO_TitleBar)
)

//go:generate stringer -type=QStyleOptionTitleBar__StyleOptionVersion
//QStyleOptionTitleBar::StyleOptionVersion
type QStyleOptionTitleBar__StyleOptionVersion int64

var (
	QStyleOptionTitleBar__Version QStyleOptionTitleBar__StyleOptionVersion = QStyleOptionTitleBar__StyleOptionVersion(1)
)

func NewQStyleOptionTitleBar() *QStyleOptionTitleBar {
	tmpValue := NewQStyleOptionTitleBarFromPointer(C.QStyleOptionTitleBar_NewQStyleOptionTitleBar())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionTitleBar).DestroyQStyleOptionTitleBar)
	return tmpValue
}

func NewQStyleOptionTitleBar2(other QStyleOptionTitleBar_ITF) *QStyleOptionTitleBar {
	tmpValue := NewQStyleOptionTitleBarFromPointer(C.QStyleOptionTitleBar_NewQStyleOptionTitleBar2(PointerFromQStyleOptionTitleBar(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionTitleBar).DestroyQStyleOptionTitleBar)
	return tmpValue
}

func (ptr *QStyleOptionTitleBar) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyleOptionTitleBar_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionTitleBar) SetIcon(vqi gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTitleBar_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(vqi))
	}
}

func (ptr *QStyleOptionTitleBar) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionTitleBar_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionTitleBar) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionTitleBar_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QStyleOptionTitleBar) TitleBarFlags() core.Qt__WindowType {
	if ptr.Pointer() != nil {
		return core.Qt__WindowType(C.QStyleOptionTitleBar_TitleBarFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionTitleBar) SetTitleBarFlags(vqt core.Qt__WindowType) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTitleBar_SetTitleBarFlags(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionTitleBar) TitleBarState() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionTitleBar_TitleBarState(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionTitleBar) SetTitleBarState(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionTitleBar_SetTitleBarState(ptr.Pointer(), C.int(int32(vin)))
	}
}

type QStyleOptionToolBar struct {
	QStyleOption
}

type QStyleOptionToolBar_ITF interface {
	QStyleOption_ITF
	QStyleOptionToolBar_PTR() *QStyleOptionToolBar
}

func (ptr *QStyleOptionToolBar) QStyleOptionToolBar_PTR() *QStyleOptionToolBar {
	return ptr
}

func (ptr *QStyleOptionToolBar) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionToolBar) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionToolBar(ptr QStyleOptionToolBar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionToolBar_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionToolBarFromPointer(ptr unsafe.Pointer) (n *QStyleOptionToolBar) {
	n = new(QStyleOptionToolBar)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionToolBar) DestroyQStyleOptionToolBar() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionToolBar__StyleOptionType
//QStyleOptionToolBar::StyleOptionType
type QStyleOptionToolBar__StyleOptionType int64

var (
	QStyleOptionToolBar__Type QStyleOptionToolBar__StyleOptionType = QStyleOptionToolBar__StyleOptionType(QStyleOption__SO_ToolBar)
)

//go:generate stringer -type=QStyleOptionToolBar__StyleOptionVersion
//QStyleOptionToolBar::StyleOptionVersion
type QStyleOptionToolBar__StyleOptionVersion int64

var (
	QStyleOptionToolBar__Version QStyleOptionToolBar__StyleOptionVersion = QStyleOptionToolBar__StyleOptionVersion(1)
)

//go:generate stringer -type=QStyleOptionToolBar__ToolBarFeature
//QStyleOptionToolBar::ToolBarFeature
type QStyleOptionToolBar__ToolBarFeature int64

const (
	QStyleOptionToolBar__None    QStyleOptionToolBar__ToolBarFeature = QStyleOptionToolBar__ToolBarFeature(0x0)
	QStyleOptionToolBar__Movable QStyleOptionToolBar__ToolBarFeature = QStyleOptionToolBar__ToolBarFeature(0x1)
)

//go:generate stringer -type=QStyleOptionToolBar__ToolBarPosition
//QStyleOptionToolBar::ToolBarPosition
type QStyleOptionToolBar__ToolBarPosition int64

const (
	QStyleOptionToolBar__Beginning QStyleOptionToolBar__ToolBarPosition = QStyleOptionToolBar__ToolBarPosition(0)
	QStyleOptionToolBar__Middle    QStyleOptionToolBar__ToolBarPosition = QStyleOptionToolBar__ToolBarPosition(1)
	QStyleOptionToolBar__End       QStyleOptionToolBar__ToolBarPosition = QStyleOptionToolBar__ToolBarPosition(2)
	QStyleOptionToolBar__OnlyOne   QStyleOptionToolBar__ToolBarPosition = QStyleOptionToolBar__ToolBarPosition(3)
)

func NewQStyleOptionToolBar() *QStyleOptionToolBar {
	tmpValue := NewQStyleOptionToolBarFromPointer(C.QStyleOptionToolBar_NewQStyleOptionToolBar())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionToolBar).DestroyQStyleOptionToolBar)
	return tmpValue
}

func NewQStyleOptionToolBar2(other QStyleOptionToolBar_ITF) *QStyleOptionToolBar {
	tmpValue := NewQStyleOptionToolBarFromPointer(C.QStyleOptionToolBar_NewQStyleOptionToolBar2(PointerFromQStyleOptionToolBar(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionToolBar).DestroyQStyleOptionToolBar)
	return tmpValue
}

func (ptr *QStyleOptionToolBar) Features() QStyleOptionToolBar__ToolBarFeature {
	if ptr.Pointer() != nil {
		return QStyleOptionToolBar__ToolBarFeature(C.QStyleOptionToolBar_Features(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionToolBar) SetFeatures(vqs QStyleOptionToolBar__ToolBarFeature) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolBar_SetFeatures(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionToolBar) LineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionToolBar_LineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionToolBar) SetLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolBar_SetLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionToolBar) MidLineWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QStyleOptionToolBar_MidLineWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QStyleOptionToolBar) SetMidLineWidth(vin int) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolBar_SetMidLineWidth(ptr.Pointer(), C.int(int32(vin)))
	}
}

func (ptr *QStyleOptionToolBar) PositionOfLine() QStyleOptionToolBar__ToolBarPosition {
	if ptr.Pointer() != nil {
		return QStyleOptionToolBar__ToolBarPosition(C.QStyleOptionToolBar_PositionOfLine(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionToolBar) SetPositionOfLine(vqs QStyleOptionToolBar__ToolBarPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolBar_SetPositionOfLine(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionToolBar) PositionWithinLine() QStyleOptionToolBar__ToolBarPosition {
	if ptr.Pointer() != nil {
		return QStyleOptionToolBar__ToolBarPosition(C.QStyleOptionToolBar_PositionWithinLine(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionToolBar) SetPositionWithinLine(vqs QStyleOptionToolBar__ToolBarPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolBar_SetPositionWithinLine(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionToolBar) ToolBarArea() core.Qt__ToolBarArea {
	if ptr.Pointer() != nil {
		return core.Qt__ToolBarArea(C.QStyleOptionToolBar_ToolBarArea(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionToolBar) SetToolBarArea(vqt core.Qt__ToolBarArea) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolBar_SetToolBarArea(ptr.Pointer(), C.longlong(vqt))
	}
}

type QStyleOptionToolBox struct {
	QStyleOption
}

type QStyleOptionToolBox_ITF interface {
	QStyleOption_ITF
	QStyleOptionToolBox_PTR() *QStyleOptionToolBox
}

func (ptr *QStyleOptionToolBox) QStyleOptionToolBox_PTR() *QStyleOptionToolBox {
	return ptr
}

func (ptr *QStyleOptionToolBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionToolBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionToolBox(ptr QStyleOptionToolBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionToolBox_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionToolBoxFromPointer(ptr unsafe.Pointer) (n *QStyleOptionToolBox) {
	n = new(QStyleOptionToolBox)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionToolBox) DestroyQStyleOptionToolBox() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionToolBox__SelectedPosition
//QStyleOptionToolBox::SelectedPosition
type QStyleOptionToolBox__SelectedPosition int64

const (
	QStyleOptionToolBox__NotAdjacent        QStyleOptionToolBox__SelectedPosition = QStyleOptionToolBox__SelectedPosition(0)
	QStyleOptionToolBox__NextIsSelected     QStyleOptionToolBox__SelectedPosition = QStyleOptionToolBox__SelectedPosition(1)
	QStyleOptionToolBox__PreviousIsSelected QStyleOptionToolBox__SelectedPosition = QStyleOptionToolBox__SelectedPosition(2)
)

//go:generate stringer -type=QStyleOptionToolBox__StyleOptionType
//QStyleOptionToolBox::StyleOptionType
type QStyleOptionToolBox__StyleOptionType int64

var (
	QStyleOptionToolBox__Type QStyleOptionToolBox__StyleOptionType = QStyleOptionToolBox__StyleOptionType(QStyleOption__SO_ToolBox)
)

//go:generate stringer -type=QStyleOptionToolBox__StyleOptionVersion
//QStyleOptionToolBox::StyleOptionVersion
type QStyleOptionToolBox__StyleOptionVersion int64

var (
	QStyleOptionToolBox__Version QStyleOptionToolBox__StyleOptionVersion = QStyleOptionToolBox__StyleOptionVersion(2)
)

//go:generate stringer -type=QStyleOptionToolBox__TabPosition
//QStyleOptionToolBox::TabPosition
type QStyleOptionToolBox__TabPosition int64

const (
	QStyleOptionToolBox__Beginning  QStyleOptionToolBox__TabPosition = QStyleOptionToolBox__TabPosition(0)
	QStyleOptionToolBox__Middle     QStyleOptionToolBox__TabPosition = QStyleOptionToolBox__TabPosition(1)
	QStyleOptionToolBox__End        QStyleOptionToolBox__TabPosition = QStyleOptionToolBox__TabPosition(2)
	QStyleOptionToolBox__OnlyOneTab QStyleOptionToolBox__TabPosition = QStyleOptionToolBox__TabPosition(3)
)

func NewQStyleOptionToolBox() *QStyleOptionToolBox {
	tmpValue := NewQStyleOptionToolBoxFromPointer(C.QStyleOptionToolBox_NewQStyleOptionToolBox())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionToolBox).DestroyQStyleOptionToolBox)
	return tmpValue
}

func NewQStyleOptionToolBox2(other QStyleOptionToolBox_ITF) *QStyleOptionToolBox {
	tmpValue := NewQStyleOptionToolBoxFromPointer(C.QStyleOptionToolBox_NewQStyleOptionToolBox2(PointerFromQStyleOptionToolBox(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionToolBox).DestroyQStyleOptionToolBox)
	return tmpValue
}

func (ptr *QStyleOptionToolBox) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyleOptionToolBox_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionToolBox) SetIcon(vqi gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolBox_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(vqi))
	}
}

func (ptr *QStyleOptionToolBox) Position() QStyleOptionToolBox__TabPosition {
	if ptr.Pointer() != nil {
		return QStyleOptionToolBox__TabPosition(C.QStyleOptionToolBox_Position(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionToolBox) SetPosition(vqs QStyleOptionToolBox__TabPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolBox_SetPosition(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionToolBox) SelectedPosition() QStyleOptionToolBox__SelectedPosition {
	if ptr.Pointer() != nil {
		return QStyleOptionToolBox__SelectedPosition(C.QStyleOptionToolBox_SelectedPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionToolBox) SetSelectedPosition(vqs QStyleOptionToolBox__SelectedPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolBox_SetSelectedPosition(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionToolBox) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionToolBox_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionToolBox) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionToolBox_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

type QStyleOptionToolButton struct {
	QStyleOptionComplex
}

type QStyleOptionToolButton_ITF interface {
	QStyleOptionComplex_ITF
	QStyleOptionToolButton_PTR() *QStyleOptionToolButton
}

func (ptr *QStyleOptionToolButton) QStyleOptionToolButton_PTR() *QStyleOptionToolButton {
	return ptr
}

func (ptr *QStyleOptionToolButton) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionComplex_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionToolButton) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOptionComplex_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionToolButton(ptr QStyleOptionToolButton_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionToolButton_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionToolButtonFromPointer(ptr unsafe.Pointer) (n *QStyleOptionToolButton) {
	n = new(QStyleOptionToolButton)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionToolButton) DestroyQStyleOptionToolButton() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionToolButton__StyleOptionType
//QStyleOptionToolButton::StyleOptionType
type QStyleOptionToolButton__StyleOptionType int64

var (
	QStyleOptionToolButton__Type QStyleOptionToolButton__StyleOptionType = QStyleOptionToolButton__StyleOptionType(QStyleOption__SO_ToolButton)
)

//go:generate stringer -type=QStyleOptionToolButton__StyleOptionVersion
//QStyleOptionToolButton::StyleOptionVersion
type QStyleOptionToolButton__StyleOptionVersion int64

var (
	QStyleOptionToolButton__Version QStyleOptionToolButton__StyleOptionVersion = QStyleOptionToolButton__StyleOptionVersion(1)
)

//go:generate stringer -type=QStyleOptionToolButton__ToolButtonFeature
//QStyleOptionToolButton::ToolButtonFeature
type QStyleOptionToolButton__ToolButtonFeature int64

const (
	QStyleOptionToolButton__None            QStyleOptionToolButton__ToolButtonFeature = QStyleOptionToolButton__ToolButtonFeature(0x00)
	QStyleOptionToolButton__Arrow           QStyleOptionToolButton__ToolButtonFeature = QStyleOptionToolButton__ToolButtonFeature(0x01)
	QStyleOptionToolButton__Menu            QStyleOptionToolButton__ToolButtonFeature = QStyleOptionToolButton__ToolButtonFeature(0x04)
	QStyleOptionToolButton__MenuButtonPopup QStyleOptionToolButton__ToolButtonFeature = QStyleOptionToolButton__ToolButtonFeature(QStyleOptionToolButton__Menu)
	QStyleOptionToolButton__PopupDelay      QStyleOptionToolButton__ToolButtonFeature = QStyleOptionToolButton__ToolButtonFeature(0x08)
	QStyleOptionToolButton__HasMenu         QStyleOptionToolButton__ToolButtonFeature = QStyleOptionToolButton__ToolButtonFeature(0x10)
)

func NewQStyleOptionToolButton() *QStyleOptionToolButton {
	tmpValue := NewQStyleOptionToolButtonFromPointer(C.QStyleOptionToolButton_NewQStyleOptionToolButton())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionToolButton).DestroyQStyleOptionToolButton)
	return tmpValue
}

func NewQStyleOptionToolButton2(other QStyleOptionToolButton_ITF) *QStyleOptionToolButton {
	tmpValue := NewQStyleOptionToolButtonFromPointer(C.QStyleOptionToolButton_NewQStyleOptionToolButton2(PointerFromQStyleOptionToolButton(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionToolButton).DestroyQStyleOptionToolButton)
	return tmpValue
}

func (ptr *QStyleOptionToolButton) ArrowType() core.Qt__ArrowType {
	if ptr.Pointer() != nil {
		return core.Qt__ArrowType(C.QStyleOptionToolButton_ArrowType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionToolButton) SetArrowType(vqt core.Qt__ArrowType) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolButton_SetArrowType(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionToolButton) Features() QStyleOptionToolButton__ToolButtonFeature {
	if ptr.Pointer() != nil {
		return QStyleOptionToolButton__ToolButtonFeature(C.QStyleOptionToolButton_Features(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionToolButton) SetFeatures(vqs QStyleOptionToolButton__ToolButtonFeature) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolButton_SetFeatures(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionToolButton) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QStyleOptionToolButton_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionToolButton) SetFont(vqf gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolButton_SetFont(ptr.Pointer(), gui.PointerFromQFont(vqf))
	}
}

func (ptr *QStyleOptionToolButton) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyleOptionToolButton_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionToolButton) SetIcon(vqi gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolButton_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(vqi))
	}
}

func (ptr *QStyleOptionToolButton) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionToolButton_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionToolButton) SetIconSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolButton_SetIconSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QStyleOptionToolButton) Pos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QStyleOptionToolButton_Pos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionToolButton) SetPos(vqp core.QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolButton_SetPos(ptr.Pointer(), core.PointerFromQPoint(vqp))
	}
}

func (ptr *QStyleOptionToolButton) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionToolButton_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionToolButton) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionToolButton_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QStyleOptionToolButton) ToolButtonStyle() core.Qt__ToolButtonStyle {
	if ptr.Pointer() != nil {
		return core.Qt__ToolButtonStyle(C.QStyleOptionToolButton_ToolButtonStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionToolButton) SetToolButtonStyle(vqt core.Qt__ToolButtonStyle) {
	if ptr.Pointer() != nil {
		C.QStyleOptionToolButton_SetToolButtonStyle(ptr.Pointer(), C.longlong(vqt))
	}
}

type QStyleOptionViewItem struct {
	QStyleOption
}

type QStyleOptionViewItem_ITF interface {
	QStyleOption_ITF
	QStyleOptionViewItem_PTR() *QStyleOptionViewItem
}

func (ptr *QStyleOptionViewItem) QStyleOptionViewItem_PTR() *QStyleOptionViewItem {
	return ptr
}

func (ptr *QStyleOptionViewItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOption_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyleOptionViewItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QStyleOption_PTR().SetPointer(p)
	}
}

func PointerFromQStyleOptionViewItem(ptr QStyleOptionViewItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleOptionViewItem_PTR().Pointer()
	}
	return nil
}

func NewQStyleOptionViewItemFromPointer(ptr unsafe.Pointer) (n *QStyleOptionViewItem) {
	n = new(QStyleOptionViewItem)
	n.SetPointer(ptr)
	return
}

func (ptr *QStyleOptionViewItem) DestroyQStyleOptionViewItem() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//go:generate stringer -type=QStyleOptionViewItem__Position
//QStyleOptionViewItem::Position
type QStyleOptionViewItem__Position int64

const (
	QStyleOptionViewItem__Left   QStyleOptionViewItem__Position = QStyleOptionViewItem__Position(0)
	QStyleOptionViewItem__Right  QStyleOptionViewItem__Position = QStyleOptionViewItem__Position(1)
	QStyleOptionViewItem__Top    QStyleOptionViewItem__Position = QStyleOptionViewItem__Position(2)
	QStyleOptionViewItem__Bottom QStyleOptionViewItem__Position = QStyleOptionViewItem__Position(3)
)

//go:generate stringer -type=QStyleOptionViewItem__StyleOptionType
//QStyleOptionViewItem::StyleOptionType
type QStyleOptionViewItem__StyleOptionType int64

var (
	QStyleOptionViewItem__Type QStyleOptionViewItem__StyleOptionType = QStyleOptionViewItem__StyleOptionType(QStyleOption__SO_ViewItem)
)

//go:generate stringer -type=QStyleOptionViewItem__StyleOptionVersion
//QStyleOptionViewItem::StyleOptionVersion
type QStyleOptionViewItem__StyleOptionVersion int64

var (
	QStyleOptionViewItem__Version QStyleOptionViewItem__StyleOptionVersion = QStyleOptionViewItem__StyleOptionVersion(4)
)

//go:generate stringer -type=QStyleOptionViewItem__ViewItemFeature
//QStyleOptionViewItem::ViewItemFeature
type QStyleOptionViewItem__ViewItemFeature int64

const (
	QStyleOptionViewItem__None              QStyleOptionViewItem__ViewItemFeature = QStyleOptionViewItem__ViewItemFeature(0x00)
	QStyleOptionViewItem__WrapText          QStyleOptionViewItem__ViewItemFeature = QStyleOptionViewItem__ViewItemFeature(0x01)
	QStyleOptionViewItem__Alternate         QStyleOptionViewItem__ViewItemFeature = QStyleOptionViewItem__ViewItemFeature(0x02)
	QStyleOptionViewItem__HasCheckIndicator QStyleOptionViewItem__ViewItemFeature = QStyleOptionViewItem__ViewItemFeature(0x04)
	QStyleOptionViewItem__HasDisplay        QStyleOptionViewItem__ViewItemFeature = QStyleOptionViewItem__ViewItemFeature(0x08)
	QStyleOptionViewItem__HasDecoration     QStyleOptionViewItem__ViewItemFeature = QStyleOptionViewItem__ViewItemFeature(0x10)
)

//go:generate stringer -type=QStyleOptionViewItem__ViewItemPosition
//QStyleOptionViewItem::ViewItemPosition
type QStyleOptionViewItem__ViewItemPosition int64

const (
	QStyleOptionViewItem__Invalid   QStyleOptionViewItem__ViewItemPosition = QStyleOptionViewItem__ViewItemPosition(0)
	QStyleOptionViewItem__Beginning QStyleOptionViewItem__ViewItemPosition = QStyleOptionViewItem__ViewItemPosition(1)
	QStyleOptionViewItem__Middle    QStyleOptionViewItem__ViewItemPosition = QStyleOptionViewItem__ViewItemPosition(2)
	QStyleOptionViewItem__End       QStyleOptionViewItem__ViewItemPosition = QStyleOptionViewItem__ViewItemPosition(3)
	QStyleOptionViewItem__OnlyOne   QStyleOptionViewItem__ViewItemPosition = QStyleOptionViewItem__ViewItemPosition(4)
)

func NewQStyleOptionViewItem() *QStyleOptionViewItem {
	tmpValue := NewQStyleOptionViewItemFromPointer(C.QStyleOptionViewItem_NewQStyleOptionViewItem())
	runtime.SetFinalizer(tmpValue, (*QStyleOptionViewItem).DestroyQStyleOptionViewItem)
	return tmpValue
}

func NewQStyleOptionViewItem2(other QStyleOptionViewItem_ITF) *QStyleOptionViewItem {
	tmpValue := NewQStyleOptionViewItemFromPointer(C.QStyleOptionViewItem_NewQStyleOptionViewItem2(PointerFromQStyleOptionViewItem(other)))
	runtime.SetFinalizer(tmpValue, (*QStyleOptionViewItem).DestroyQStyleOptionViewItem)
	return tmpValue
}

func (ptr *QStyleOptionViewItem) BackgroundBrush() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QStyleOptionViewItem_BackgroundBrush(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionViewItem) SetBackgroundBrush(vqb gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetBackgroundBrush(ptr.Pointer(), gui.PointerFromQBrush(vqb))
	}
}

func (ptr *QStyleOptionViewItem) CheckState() core.Qt__CheckState {
	if ptr.Pointer() != nil {
		return core.Qt__CheckState(C.QStyleOptionViewItem_CheckState(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionViewItem) SetCheckState(vqt core.Qt__CheckState) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetCheckState(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionViewItem) DecorationAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QStyleOptionViewItem_DecorationAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionViewItem) SetDecorationAlignment(vqt core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetDecorationAlignment(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionViewItem) DecorationPosition() QStyleOptionViewItem__Position {
	if ptr.Pointer() != nil {
		return QStyleOptionViewItem__Position(C.QStyleOptionViewItem_DecorationPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionViewItem) SetDecorationPosition(vqs QStyleOptionViewItem__Position) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetDecorationPosition(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionViewItem) DecorationSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyleOptionViewItem_DecorationSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionViewItem) SetDecorationSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetDecorationSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QStyleOptionViewItem) DisplayAlignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QStyleOptionViewItem_DisplayAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionViewItem) SetDisplayAlignment(vqt core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetDisplayAlignment(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionViewItem) Features() QStyleOptionViewItem__ViewItemFeature {
	if ptr.Pointer() != nil {
		return QStyleOptionViewItem__ViewItemFeature(C.QStyleOptionViewItem_Features(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionViewItem) SetFeatures(vqs QStyleOptionViewItem__ViewItemFeature) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetFeatures(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionViewItem) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QStyleOptionViewItem_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionViewItem) SetFont(vqf gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetFont(ptr.Pointer(), gui.PointerFromQFont(vqf))
	}
}

func (ptr *QStyleOptionViewItem) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QStyleOptionViewItem_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionViewItem) SetIcon(vqi gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(vqi))
	}
}

func (ptr *QStyleOptionViewItem) Index() *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QStyleOptionViewItem_Index(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionViewItem) SetIndex(vqm core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetIndex(ptr.Pointer(), core.PointerFromQModelIndex(vqm))
	}
}

func (ptr *QStyleOptionViewItem) Locale() *core.QLocale {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQLocaleFromPointer(C.QStyleOptionViewItem_Locale(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QLocale).DestroyQLocale)
		return tmpValue
	}
	return nil
}

func (ptr *QStyleOptionViewItem) SetLocale(vql core.QLocale_ITF) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetLocale(ptr.Pointer(), core.PointerFromQLocale(vql))
	}
}

func (ptr *QStyleOptionViewItem) ShowDecorationSelected() bool {
	if ptr.Pointer() != nil {
		return int8(C.QStyleOptionViewItem_ShowDecorationSelected(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QStyleOptionViewItem) SetShowDecorationSelected(vbo bool) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetShowDecorationSelected(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QStyleOptionViewItem) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyleOptionViewItem_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStyleOptionViewItem) SetText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QStyleOptionViewItem_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QStyleOptionViewItem) TextElideMode() core.Qt__TextElideMode {
	if ptr.Pointer() != nil {
		return core.Qt__TextElideMode(C.QStyleOptionViewItem_TextElideMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionViewItem) SetTextElideMode(vqt core.Qt__TextElideMode) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetTextElideMode(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QStyleOptionViewItem) ViewItemPosition() QStyleOptionViewItem__ViewItemPosition {
	if ptr.Pointer() != nil {
		return QStyleOptionViewItem__ViewItemPosition(C.QStyleOptionViewItem_ViewItemPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleOptionViewItem) SetViewItemPosition(vqs QStyleOptionViewItem__ViewItemPosition) {
	if ptr.Pointer() != nil {
		C.QStyleOptionViewItem_SetViewItemPosition(ptr.Pointer(), C.longlong(vqs))
	}
}

func (ptr *QStyleOptionViewItem) Widget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QStyleOptionViewItem_Widget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

type QStylePainter struct {
	gui.QPainter
}

type QStylePainter_ITF interface {
	gui.QPainter_ITF
	QStylePainter_PTR() *QStylePainter
}

func (ptr *QStylePainter) QStylePainter_PTR() *QStylePainter {
	return ptr
}

func (ptr *QStylePainter) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QPainter_PTR().Pointer()
	}
	return nil
}

func (ptr *QStylePainter) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QPainter_PTR().SetPointer(p)
	}
}

func PointerFromQStylePainter(ptr QStylePainter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStylePainter_PTR().Pointer()
	}
	return nil
}

func NewQStylePainterFromPointer(ptr unsafe.Pointer) (n *QStylePainter) {
	n = new(QStylePainter)
	n.SetPointer(ptr)
	return
}

func (ptr *QStylePainter) DestroyQStylePainter() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQStylePainter() *QStylePainter {
	tmpValue := NewQStylePainterFromPointer(C.QStylePainter_NewQStylePainter())
	runtime.SetFinalizer(tmpValue, (*QStylePainter).DestroyQStylePainter)
	return tmpValue
}

func NewQStylePainter3(pd gui.QPaintDevice_ITF, widget QWidget_ITF) *QStylePainter {
	tmpValue := NewQStylePainterFromPointer(C.QStylePainter_NewQStylePainter3(gui.PointerFromQPaintDevice(pd), PointerFromQWidget(widget)))
	runtime.SetFinalizer(tmpValue, (*QStylePainter).DestroyQStylePainter)
	return tmpValue
}

func NewQStylePainter2(widget QWidget_ITF) *QStylePainter {
	tmpValue := NewQStylePainterFromPointer(C.QStylePainter_NewQStylePainter2(PointerFromQWidget(widget)))
	runtime.SetFinalizer(tmpValue, (*QStylePainter).DestroyQStylePainter)
	return tmpValue
}

func (ptr *QStylePainter) Begin2(pd gui.QPaintDevice_ITF, widget QWidget_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStylePainter_Begin2(ptr.Pointer(), gui.PointerFromQPaintDevice(pd), PointerFromQWidget(widget))) != 0
	}
	return false
}

func (ptr *QStylePainter) Begin(widget QWidget_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStylePainter_Begin(ptr.Pointer(), PointerFromQWidget(widget))) != 0
	}
	return false
}

func (ptr *QStylePainter) DrawComplexControl(cc QStyle__ComplexControl, option QStyleOptionComplex_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter_DrawComplexControl(ptr.Pointer(), C.longlong(cc), PointerFromQStyleOptionComplex(option))
	}
}

func (ptr *QStylePainter) DrawControl(ce QStyle__ControlElement, option QStyleOption_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter_DrawControl(ptr.Pointer(), C.longlong(ce), PointerFromQStyleOption(option))
	}
}

func (ptr *QStylePainter) DrawItemPixmap(rect core.QRect_ITF, flags int, pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter_DrawItemPixmap(ptr.Pointer(), core.PointerFromQRect(rect), C.int(int32(flags)), gui.PointerFromQPixmap(pixmap))
	}
}

func (ptr *QStylePainter) DrawItemText(rect core.QRect_ITF, flags int, pal gui.QPalette_ITF, enabled bool, text string, textRole gui.QPalette__ColorRole) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QStylePainter_DrawItemText(ptr.Pointer(), core.PointerFromQRect(rect), C.int(int32(flags)), gui.PointerFromQPalette(pal), C.char(int8(qt.GoBoolToInt(enabled))), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(textRole))
	}
}

func (ptr *QStylePainter) DrawPrimitive(pe QStyle__PrimitiveElement, option QStyleOption_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter_DrawPrimitive(ptr.Pointer(), C.longlong(pe), PointerFromQStyleOption(option))
	}
}

func (ptr *QStylePainter) Style() *QStyle {
	if ptr.Pointer() != nil {
		tmpValue := NewQStyleFromPointer(C.QStylePainter_Style(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStylePainter) __drawLines_lines_atList6(i int) *core.QLine {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQLineFromPointer(C.QStylePainter___drawLines_lines_atList6(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QLine).DestroyQLine)
		return tmpValue
	}
	return nil
}

func (ptr *QStylePainter) __drawLines_lines_setList6(i core.QLine_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter___drawLines_lines_setList6(ptr.Pointer(), core.PointerFromQLine(i))
	}
}

func (ptr *QStylePainter) __drawLines_lines_newList6() unsafe.Pointer {
	return C.QStylePainter___drawLines_lines_newList6(ptr.Pointer())
}

func (ptr *QStylePainter) __drawLines_lines_atList2(i int) *core.QLineF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQLineFFromPointer(C.QStylePainter___drawLines_lines_atList2(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QLineF).DestroyQLineF)
		return tmpValue
	}
	return nil
}

func (ptr *QStylePainter) __drawLines_lines_setList2(i core.QLineF_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter___drawLines_lines_setList2(ptr.Pointer(), core.PointerFromQLineF(i))
	}
}

func (ptr *QStylePainter) __drawLines_lines_newList2() unsafe.Pointer {
	return C.QStylePainter___drawLines_lines_newList2(ptr.Pointer())
}

func (ptr *QStylePainter) __drawLines_pointPairs_atList8(i int) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QStylePainter___drawLines_pointPairs_atList8(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QStylePainter) __drawLines_pointPairs_setList8(i core.QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter___drawLines_pointPairs_setList8(ptr.Pointer(), core.PointerFromQPoint(i))
	}
}

func (ptr *QStylePainter) __drawLines_pointPairs_newList8() unsafe.Pointer {
	return C.QStylePainter___drawLines_pointPairs_newList8(ptr.Pointer())
}

func (ptr *QStylePainter) __drawLines_pointPairs_atList4(i int) *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QStylePainter___drawLines_pointPairs_atList4(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

func (ptr *QStylePainter) __drawLines_pointPairs_setList4(i core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter___drawLines_pointPairs_setList4(ptr.Pointer(), core.PointerFromQPointF(i))
	}
}

func (ptr *QStylePainter) __drawLines_pointPairs_newList4() unsafe.Pointer {
	return C.QStylePainter___drawLines_pointPairs_newList4(ptr.Pointer())
}

func (ptr *QStylePainter) __drawRects_rectangles_atList4(i int) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QStylePainter___drawRects_rectangles_atList4(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QStylePainter) __drawRects_rectangles_setList4(i core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter___drawRects_rectangles_setList4(ptr.Pointer(), core.PointerFromQRect(i))
	}
}

func (ptr *QStylePainter) __drawRects_rectangles_newList4() unsafe.Pointer {
	return C.QStylePainter___drawRects_rectangles_newList4(ptr.Pointer())
}

func (ptr *QStylePainter) __drawRects_rectangles_atList2(i int) *core.QRectF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFFromPointer(C.QStylePainter___drawRects_rectangles_atList2(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
		return tmpValue
	}
	return nil
}

func (ptr *QStylePainter) __drawRects_rectangles_setList2(i core.QRectF_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePainter___drawRects_rectangles_setList2(ptr.Pointer(), core.PointerFromQRectF(i))
	}
}

func (ptr *QStylePainter) __drawRects_rectangles_newList2() unsafe.Pointer {
	return C.QStylePainter___drawRects_rectangles_newList2(ptr.Pointer())
}

type QStylePlugin struct {
	core.QObject
}

type QStylePlugin_ITF interface {
	core.QObject_ITF
	QStylePlugin_PTR() *QStylePlugin
}

func (ptr *QStylePlugin) QStylePlugin_PTR() *QStylePlugin {
	return ptr
}

func (ptr *QStylePlugin) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QStylePlugin) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQStylePlugin(ptr QStylePlugin_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStylePlugin_PTR().Pointer()
	}
	return nil
}

func NewQStylePluginFromPointer(ptr unsafe.Pointer) (n *QStylePlugin) {
	n = new(QStylePlugin)
	n.SetPointer(ptr)
	return
}
func QStylePlugin_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QStylePlugin_QStylePlugin_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QStylePlugin) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QStylePlugin_QStylePlugin_Tr(sC, cC, C.int(int32(n))))
}

//export callbackQStylePlugin_Create
func callbackQStylePlugin_Create(ptr unsafe.Pointer, key C.struct_QtWidgets_PackedString) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "create"); signal != nil {
		return PointerFromQStyle((*(*func(string) *QStyle)(signal))(cGoUnpackString(key)))
	}

	return PointerFromQStyle(NewQStyle())
}

func (ptr *QStylePlugin) ConnectCreate(f func(key string) *QStyle) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "create"); signal != nil {
			f := func(key string) *QStyle {
				(*(*func(string) *QStyle)(signal))(key)
				return f(key)
			}
			qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStylePlugin) DisconnectCreate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "create")
	}
}

func (ptr *QStylePlugin) Create(key string) *QStyle {
	if ptr.Pointer() != nil {
		var keyC *C.char
		if key != "" {
			keyC = C.CString(key)
			defer C.free(unsafe.Pointer(keyC))
		}
		tmpValue := NewQStyleFromPointer(C.QStylePlugin_Create(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: keyC, len: C.longlong(len(key))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQStylePlugin(parent core.QObject_ITF) *QStylePlugin {
	tmpValue := NewQStylePluginFromPointer(C.QStylePlugin_NewQStylePlugin(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQStylePlugin_DestroyQStylePlugin
func callbackQStylePlugin_DestroyQStylePlugin(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QStylePlugin"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStylePluginFromPointer(ptr).DestroyQStylePluginDefault()
	}
}

func (ptr *QStylePlugin) ConnectDestroyQStylePlugin(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QStylePlugin"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QStylePlugin", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QStylePlugin", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStylePlugin) DisconnectDestroyQStylePlugin() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QStylePlugin")
	}
}

func (ptr *QStylePlugin) DestroyQStylePlugin() {
	if ptr.Pointer() != nil {
		C.QStylePlugin_DestroyQStylePlugin(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStylePlugin) DestroyQStylePluginDefault() {
	if ptr.Pointer() != nil {
		C.QStylePlugin_DestroyQStylePluginDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQStylePlugin_MetaObject
func callbackQStylePlugin_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQStylePluginFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QStylePlugin) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QStylePlugin_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStylePlugin) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QStylePlugin___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QStylePlugin) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QStylePlugin) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QStylePlugin___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QStylePlugin) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QStylePlugin___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStylePlugin) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QStylePlugin) __findChildren_newList2() unsafe.Pointer {
	return C.QStylePlugin___findChildren_newList2(ptr.Pointer())
}

func (ptr *QStylePlugin) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QStylePlugin___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStylePlugin) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QStylePlugin) __findChildren_newList3() unsafe.Pointer {
	return C.QStylePlugin___findChildren_newList3(ptr.Pointer())
}

func (ptr *QStylePlugin) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QStylePlugin___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStylePlugin) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QStylePlugin) __findChildren_newList() unsafe.Pointer {
	return C.QStylePlugin___findChildren_newList(ptr.Pointer())
}

func (ptr *QStylePlugin) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QStylePlugin___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QStylePlugin) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QStylePlugin) __children_newList() unsafe.Pointer {
	return C.QStylePlugin___children_newList(ptr.Pointer())
}

//export callbackQStylePlugin_Event
func callbackQStylePlugin_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQStylePluginFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QStylePlugin) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStylePlugin_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQStylePlugin_EventFilter
func callbackQStylePlugin_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQStylePluginFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QStylePlugin) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QStylePlugin_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQStylePlugin_ChildEvent
func callbackQStylePlugin_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQStylePluginFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QStylePlugin) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQStylePlugin_ConnectNotify
func callbackQStylePlugin_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQStylePluginFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QStylePlugin) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQStylePlugin_CustomEvent
func callbackQStylePlugin_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQStylePluginFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QStylePlugin) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQStylePlugin_DeleteLater
func callbackQStylePlugin_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStylePluginFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QStylePlugin) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QStylePlugin_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQStylePlugin_Destroyed
func callbackQStylePlugin_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQStylePlugin_DisconnectNotify
func callbackQStylePlugin_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQStylePluginFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QStylePlugin) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQStylePlugin_ObjectNameChanged
func callbackQStylePlugin_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQStylePlugin_TimerEvent
func callbackQStylePlugin_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQStylePluginFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QStylePlugin) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QStylePlugin_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QStyledItemDelegate struct {
	QAbstractItemDelegate
}

type QStyledItemDelegate_ITF interface {
	QAbstractItemDelegate_ITF
	QStyledItemDelegate_PTR() *QStyledItemDelegate
}

func (ptr *QStyledItemDelegate) QStyledItemDelegate_PTR() *QStyledItemDelegate {
	return ptr
}

func (ptr *QStyledItemDelegate) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemDelegate_PTR().Pointer()
	}
	return nil
}

func (ptr *QStyledItemDelegate) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractItemDelegate_PTR().SetPointer(p)
	}
}

func PointerFromQStyledItemDelegate(ptr QStyledItemDelegate_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyledItemDelegate_PTR().Pointer()
	}
	return nil
}

func NewQStyledItemDelegateFromPointer(ptr unsafe.Pointer) (n *QStyledItemDelegate) {
	n = new(QStyledItemDelegate)
	n.SetPointer(ptr)
	return
}
func NewQStyledItemDelegate(parent core.QObject_ITF) *QStyledItemDelegate {
	tmpValue := NewQStyledItemDelegateFromPointer(C.QStyledItemDelegate_NewQStyledItemDelegate(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QStyledItemDelegate) SetItemEditorFactory(factory QItemEditorFactory_ITF) {
	if ptr.Pointer() != nil {
		C.QStyledItemDelegate_SetItemEditorFactory(ptr.Pointer(), PointerFromQItemEditorFactory(factory))
	}
}

//export callbackQStyledItemDelegate_DestroyQStyledItemDelegate
func callbackQStyledItemDelegate_DestroyQStyledItemDelegate(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QStyledItemDelegate"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQStyledItemDelegateFromPointer(ptr).DestroyQStyledItemDelegateDefault()
	}
}

func (ptr *QStyledItemDelegate) ConnectDestroyQStyledItemDelegate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QStyledItemDelegate"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QStyledItemDelegate", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QStyledItemDelegate", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyledItemDelegate) DisconnectDestroyQStyledItemDelegate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QStyledItemDelegate")
	}
}

func (ptr *QStyledItemDelegate) DestroyQStyledItemDelegate() {
	if ptr.Pointer() != nil {
		C.QStyledItemDelegate_DestroyQStyledItemDelegate(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStyledItemDelegate) DestroyQStyledItemDelegateDefault() {
	if ptr.Pointer() != nil {
		C.QStyledItemDelegate_DestroyQStyledItemDelegateDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QStyledItemDelegate) ItemEditorFactory() *QItemEditorFactory {
	if ptr.Pointer() != nil {
		return NewQItemEditorFactoryFromPointer(C.QStyledItemDelegate_ItemEditorFactory(ptr.Pointer()))
	}
	return nil
}

//export callbackQStyledItemDelegate_SizeHint
func callbackQStyledItemDelegate_SizeHint(ptr unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func(*QStyleOptionViewItem, *core.QModelIndex) *core.QSize)(signal))(NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQSize(NewQStyledItemDelegateFromPointer(ptr).SizeHintDefault(NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index)))
}

func (ptr *QStyledItemDelegate) ConnectSizeHint(f func(option *QStyleOptionViewItem, index *core.QModelIndex) *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func(option *QStyleOptionViewItem, index *core.QModelIndex) *core.QSize {
				(*(*func(*QStyleOptionViewItem, *core.QModelIndex) *core.QSize)(signal))(option, index)
				return f(option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyledItemDelegate) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QStyledItemDelegate) SizeHint(option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyledItemDelegate_SizeHint(ptr.Pointer(), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QStyledItemDelegate) SizeHintDefault(option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QStyledItemDelegate_SizeHintDefault(ptr.Pointer(), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQStyledItemDelegate_DisplayText
func callbackQStyledItemDelegate_DisplayText(ptr unsafe.Pointer, value unsafe.Pointer, locale unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "displayText"); signal != nil {
		tempVal := (*(*func(*core.QVariant, *core.QLocale) string)(signal))(core.NewQVariantFromPointer(value), core.NewQLocaleFromPointer(locale))
		return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
	}
	tempVal := NewQStyledItemDelegateFromPointer(ptr).DisplayTextDefault(core.NewQVariantFromPointer(value), core.NewQLocaleFromPointer(locale))
	return C.struct_QtWidgets_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
}

func (ptr *QStyledItemDelegate) ConnectDisplayText(f func(value *core.QVariant, locale *core.QLocale) string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "displayText"); signal != nil {
			f := func(value *core.QVariant, locale *core.QLocale) string {
				(*(*func(*core.QVariant, *core.QLocale) string)(signal))(value, locale)
				return f(value, locale)
			}
			qt.ConnectSignal(ptr.Pointer(), "displayText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "displayText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyledItemDelegate) DisconnectDisplayText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "displayText")
	}
}

func (ptr *QStyledItemDelegate) DisplayText(value core.QVariant_ITF, locale core.QLocale_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyledItemDelegate_DisplayText(ptr.Pointer(), core.PointerFromQVariant(value), core.PointerFromQLocale(locale)))
	}
	return ""
}

func (ptr *QStyledItemDelegate) DisplayTextDefault(value core.QVariant_ITF, locale core.QLocale_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QStyledItemDelegate_DisplayTextDefault(ptr.Pointer(), core.PointerFromQVariant(value), core.PointerFromQLocale(locale)))
	}
	return ""
}

//export callbackQStyledItemDelegate_InitStyleOption
func callbackQStyledItemDelegate_InitStyleOption(ptr unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "initStyleOption"); signal != nil {
		(*(*func(*QStyleOptionViewItem, *core.QModelIndex))(signal))(NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	} else {
		NewQStyledItemDelegateFromPointer(ptr).InitStyleOptionDefault(NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QStyledItemDelegate) ConnectInitStyleOption(f func(option *QStyleOptionViewItem, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "initStyleOption"); signal != nil {
			f := func(option *QStyleOptionViewItem, index *core.QModelIndex) {
				(*(*func(*QStyleOptionViewItem, *core.QModelIndex))(signal))(option, index)
				f(option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "initStyleOption", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "initStyleOption", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyledItemDelegate) DisconnectInitStyleOption() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "initStyleOption")
	}
}

func (ptr *QStyledItemDelegate) InitStyleOption(option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QStyledItemDelegate_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QStyledItemDelegate) InitStyleOptionDefault(option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QStyledItemDelegate_InitStyleOptionDefault(ptr.Pointer(), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

//export callbackQStyledItemDelegate_Paint
func callbackQStyledItemDelegate_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paint"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QModelIndex))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	} else {
		NewQStyledItemDelegateFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QStyledItemDelegate) ConnectPaint(f func(painter *gui.QPainter, option *QStyleOptionViewItem, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paint"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionViewItem, index *core.QModelIndex) {
				(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QModelIndex))(signal))(painter, option, index)
				f(painter, option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QStyledItemDelegate) DisconnectPaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paint")
	}
}

func (ptr *QStyledItemDelegate) Paint(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QStyledItemDelegate_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QStyledItemDelegate) PaintDefault(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QStyledItemDelegate_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

type QSwipeGesture struct {
	QGesture
}

type QSwipeGesture_ITF interface {
	QGesture_ITF
	QSwipeGesture_PTR() *QSwipeGesture
}

func (ptr *QSwipeGesture) QSwipeGesture_PTR() *QSwipeGesture {
	return ptr
}

func (ptr *QSwipeGesture) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGesture_PTR().Pointer()
	}
	return nil
}

func (ptr *QSwipeGesture) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGesture_PTR().SetPointer(p)
	}
}

func PointerFromQSwipeGesture(ptr QSwipeGesture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSwipeGesture_PTR().Pointer()
	}
	return nil
}

func NewQSwipeGestureFromPointer(ptr unsafe.Pointer) (n *QSwipeGesture) {
	n = new(QSwipeGesture)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QSwipeGesture__SwipeDirection
//QSwipeGesture::SwipeDirection
type QSwipeGesture__SwipeDirection int64

const (
	QSwipeGesture__NoDirection QSwipeGesture__SwipeDirection = QSwipeGesture__SwipeDirection(0)
	QSwipeGesture__Left        QSwipeGesture__SwipeDirection = QSwipeGesture__SwipeDirection(1)
	QSwipeGesture__Right       QSwipeGesture__SwipeDirection = QSwipeGesture__SwipeDirection(2)
	QSwipeGesture__Up          QSwipeGesture__SwipeDirection = QSwipeGesture__SwipeDirection(3)
	QSwipeGesture__Down        QSwipeGesture__SwipeDirection = QSwipeGesture__SwipeDirection(4)
)

func (ptr *QSwipeGesture) SetSwipeAngle(value float64) {
	if ptr.Pointer() != nil {
		C.QSwipeGesture_SetSwipeAngle(ptr.Pointer(), C.double(value))
	}
}

//export callbackQSwipeGesture_DestroyQSwipeGesture
func callbackQSwipeGesture_DestroyQSwipeGesture(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSwipeGesture"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSwipeGestureFromPointer(ptr).DestroyQSwipeGestureDefault()
	}
}

func (ptr *QSwipeGesture) ConnectDestroyQSwipeGesture(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSwipeGesture"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSwipeGesture", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSwipeGesture", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSwipeGesture) DisconnectDestroyQSwipeGesture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSwipeGesture")
	}
}

func (ptr *QSwipeGesture) DestroyQSwipeGesture() {
	if ptr.Pointer() != nil {
		C.QSwipeGesture_DestroyQSwipeGesture(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSwipeGesture) DestroyQSwipeGestureDefault() {
	if ptr.Pointer() != nil {
		C.QSwipeGesture_DestroyQSwipeGestureDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSwipeGesture) HorizontalDirection() QSwipeGesture__SwipeDirection {
	if ptr.Pointer() != nil {
		return QSwipeGesture__SwipeDirection(C.QSwipeGesture_HorizontalDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSwipeGesture) VerticalDirection() QSwipeGesture__SwipeDirection {
	if ptr.Pointer() != nil {
		return QSwipeGesture__SwipeDirection(C.QSwipeGesture_VerticalDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSwipeGesture) SwipeAngle() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QSwipeGesture_SwipeAngle(ptr.Pointer()))
	}
	return 0
}

type QSystemTrayIcon struct {
	core.QObject
}

type QSystemTrayIcon_ITF interface {
	core.QObject_ITF
	QSystemTrayIcon_PTR() *QSystemTrayIcon
}

func (ptr *QSystemTrayIcon) QSystemTrayIcon_PTR() *QSystemTrayIcon {
	return ptr
}

func (ptr *QSystemTrayIcon) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QSystemTrayIcon) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQSystemTrayIcon(ptr QSystemTrayIcon_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSystemTrayIcon_PTR().Pointer()
	}
	return nil
}

func NewQSystemTrayIconFromPointer(ptr unsafe.Pointer) (n *QSystemTrayIcon) {
	n = new(QSystemTrayIcon)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QSystemTrayIcon__ActivationReason
//QSystemTrayIcon::ActivationReason
type QSystemTrayIcon__ActivationReason int64

const (
	QSystemTrayIcon__Unknown     QSystemTrayIcon__ActivationReason = QSystemTrayIcon__ActivationReason(0)
	QSystemTrayIcon__Context     QSystemTrayIcon__ActivationReason = QSystemTrayIcon__ActivationReason(1)
	QSystemTrayIcon__DoubleClick QSystemTrayIcon__ActivationReason = QSystemTrayIcon__ActivationReason(2)
	QSystemTrayIcon__Trigger     QSystemTrayIcon__ActivationReason = QSystemTrayIcon__ActivationReason(3)
	QSystemTrayIcon__MiddleClick QSystemTrayIcon__ActivationReason = QSystemTrayIcon__ActivationReason(4)
)

//go:generate stringer -type=QSystemTrayIcon__MessageIcon
//QSystemTrayIcon::MessageIcon
type QSystemTrayIcon__MessageIcon int64

const (
	QSystemTrayIcon__NoIcon      QSystemTrayIcon__MessageIcon = QSystemTrayIcon__MessageIcon(0)
	QSystemTrayIcon__Information QSystemTrayIcon__MessageIcon = QSystemTrayIcon__MessageIcon(1)
	QSystemTrayIcon__Warning     QSystemTrayIcon__MessageIcon = QSystemTrayIcon__MessageIcon(2)
	QSystemTrayIcon__Critical    QSystemTrayIcon__MessageIcon = QSystemTrayIcon__MessageIcon(3)
)

func QSystemTrayIcon_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QSystemTrayIcon_QSystemTrayIcon_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QSystemTrayIcon) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QSystemTrayIcon_QSystemTrayIcon_Tr(sC, cC, C.int(int32(n))))
}

func NewQSystemTrayIcon(parent core.QObject_ITF) *QSystemTrayIcon {
	tmpValue := NewQSystemTrayIconFromPointer(C.QSystemTrayIcon_NewQSystemTrayIcon(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQSystemTrayIcon2(icon gui.QIcon_ITF, parent core.QObject_ITF) *QSystemTrayIcon {
	tmpValue := NewQSystemTrayIconFromPointer(C.QSystemTrayIcon_NewQSystemTrayIcon2(gui.PointerFromQIcon(icon), core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQSystemTrayIcon_Event
func callbackQSystemTrayIcon_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSystemTrayIconFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QSystemTrayIcon) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSystemTrayIcon_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

func QSystemTrayIcon_IsSystemTrayAvailable() bool {
	return int8(C.QSystemTrayIcon_QSystemTrayIcon_IsSystemTrayAvailable()) != 0
}

func (ptr *QSystemTrayIcon) IsSystemTrayAvailable() bool {
	return int8(C.QSystemTrayIcon_QSystemTrayIcon_IsSystemTrayAvailable()) != 0
}

func QSystemTrayIcon_SupportsMessages() bool {
	return int8(C.QSystemTrayIcon_QSystemTrayIcon_SupportsMessages()) != 0
}

func (ptr *QSystemTrayIcon) SupportsMessages() bool {
	return int8(C.QSystemTrayIcon_QSystemTrayIcon_SupportsMessages()) != 0
}

//export callbackQSystemTrayIcon_Activated
func callbackQSystemTrayIcon_Activated(ptr unsafe.Pointer, reason C.longlong) {
	if signal := qt.GetSignal(ptr, "activated"); signal != nil {
		(*(*func(QSystemTrayIcon__ActivationReason))(signal))(QSystemTrayIcon__ActivationReason(reason))
	}

}

func (ptr *QSystemTrayIcon) ConnectActivated(f func(reason QSystemTrayIcon__ActivationReason)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activated") {
			C.QSystemTrayIcon_ConnectActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "activated"); signal != nil {
			f := func(reason QSystemTrayIcon__ActivationReason) {
				(*(*func(QSystemTrayIcon__ActivationReason))(signal))(reason)
				f(reason)
			}
			qt.ConnectSignal(ptr.Pointer(), "activated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "activated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSystemTrayIcon) DisconnectActivated() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_DisconnectActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activated")
	}
}

func (ptr *QSystemTrayIcon) Activated(reason QSystemTrayIcon__ActivationReason) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_Activated(ptr.Pointer(), C.longlong(reason))
	}
}

//export callbackQSystemTrayIcon_Hide
func callbackQSystemTrayIcon_Hide(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hide"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSystemTrayIconFromPointer(ptr).HideDefault()
	}
}

func (ptr *QSystemTrayIcon) ConnectHide(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hide"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "hide", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hide", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSystemTrayIcon) DisconnectHide() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hide")
	}
}

func (ptr *QSystemTrayIcon) Hide() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_Hide(ptr.Pointer())
	}
}

func (ptr *QSystemTrayIcon) HideDefault() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_HideDefault(ptr.Pointer())
	}
}

//export callbackQSystemTrayIcon_MessageClicked
func callbackQSystemTrayIcon_MessageClicked(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "messageClicked"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QSystemTrayIcon) ConnectMessageClicked(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "messageClicked") {
			C.QSystemTrayIcon_ConnectMessageClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "messageClicked"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "messageClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "messageClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSystemTrayIcon) DisconnectMessageClicked() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_DisconnectMessageClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "messageClicked")
	}
}

func (ptr *QSystemTrayIcon) MessageClicked() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_MessageClicked(ptr.Pointer())
	}
}

func (ptr *QSystemTrayIcon) SetContextMenu(menu QMenu_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_SetContextMenu(ptr.Pointer(), PointerFromQMenu(menu))
	}
}

func (ptr *QSystemTrayIcon) SetIcon(icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QSystemTrayIcon) SetToolTip(tip string) {
	if ptr.Pointer() != nil {
		var tipC *C.char
		if tip != "" {
			tipC = C.CString(tip)
			defer C.free(unsafe.Pointer(tipC))
		}
		C.QSystemTrayIcon_SetToolTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: tipC, len: C.longlong(len(tip))})
	}
}

//export callbackQSystemTrayIcon_SetVisible
func callbackQSystemTrayIcon_SetVisible(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(ptr, "setVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(visible) != 0)
	} else {
		NewQSystemTrayIconFromPointer(ptr).SetVisibleDefault(int8(visible) != 0)
	}
}

func (ptr *QSystemTrayIcon) ConnectSetVisible(f func(visible bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setVisible"); signal != nil {
			f := func(visible bool) {
				(*(*func(bool))(signal))(visible)
				f(visible)
			}
			qt.ConnectSignal(ptr.Pointer(), "setVisible", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setVisible", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSystemTrayIcon) DisconnectSetVisible() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setVisible")
	}
}

func (ptr *QSystemTrayIcon) SetVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_SetVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QSystemTrayIcon) SetVisibleDefault(visible bool) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQSystemTrayIcon_Show
func callbackQSystemTrayIcon_Show(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "show"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSystemTrayIconFromPointer(ptr).ShowDefault()
	}
}

func (ptr *QSystemTrayIcon) ConnectShow(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "show"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "show", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "show", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSystemTrayIcon) DisconnectShow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "show")
	}
}

func (ptr *QSystemTrayIcon) Show() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_Show(ptr.Pointer())
	}
}

func (ptr *QSystemTrayIcon) ShowDefault() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_ShowDefault(ptr.Pointer())
	}
}

//export callbackQSystemTrayIcon_ShowMessage
func callbackQSystemTrayIcon_ShowMessage(ptr unsafe.Pointer, title C.struct_QtWidgets_PackedString, message C.struct_QtWidgets_PackedString, icon C.longlong, millisecondsTimeoutHint C.int) {
	if signal := qt.GetSignal(ptr, "showMessage"); signal != nil {
		(*(*func(string, string, QSystemTrayIcon__MessageIcon, int))(signal))(cGoUnpackString(title), cGoUnpackString(message), QSystemTrayIcon__MessageIcon(icon), int(int32(millisecondsTimeoutHint)))
	} else {
		NewQSystemTrayIconFromPointer(ptr).ShowMessageDefault(cGoUnpackString(title), cGoUnpackString(message), QSystemTrayIcon__MessageIcon(icon), int(int32(millisecondsTimeoutHint)))
	}
}

func (ptr *QSystemTrayIcon) ConnectShowMessage(f func(title string, message string, icon QSystemTrayIcon__MessageIcon, millisecondsTimeoutHint int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMessage"); signal != nil {
			f := func(title string, message string, icon QSystemTrayIcon__MessageIcon, millisecondsTimeoutHint int) {
				(*(*func(string, string, QSystemTrayIcon__MessageIcon, int))(signal))(title, message, icon, millisecondsTimeoutHint)
				f(title, message, icon, millisecondsTimeoutHint)
			}
			qt.ConnectSignal(ptr.Pointer(), "showMessage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMessage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSystemTrayIcon) DisconnectShowMessage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMessage")
	}
}

func (ptr *QSystemTrayIcon) ShowMessage(title string, message string, icon QSystemTrayIcon__MessageIcon, millisecondsTimeoutHint int) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QSystemTrayIcon_ShowMessage(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, C.longlong(icon), C.int(int32(millisecondsTimeoutHint)))
	}
}

func (ptr *QSystemTrayIcon) ShowMessageDefault(title string, message string, icon QSystemTrayIcon__MessageIcon, millisecondsTimeoutHint int) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QSystemTrayIcon_ShowMessageDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, C.longlong(icon), C.int(int32(millisecondsTimeoutHint)))
	}
}

//export callbackQSystemTrayIcon_ShowMessage2
func callbackQSystemTrayIcon_ShowMessage2(ptr unsafe.Pointer, title C.struct_QtWidgets_PackedString, message C.struct_QtWidgets_PackedString, icon unsafe.Pointer, millisecondsTimeoutHint C.int) {
	if signal := qt.GetSignal(ptr, "showMessage2"); signal != nil {
		(*(*func(string, string, *gui.QIcon, int))(signal))(cGoUnpackString(title), cGoUnpackString(message), gui.NewQIconFromPointer(icon), int(int32(millisecondsTimeoutHint)))
	} else {
		NewQSystemTrayIconFromPointer(ptr).ShowMessage2Default(cGoUnpackString(title), cGoUnpackString(message), gui.NewQIconFromPointer(icon), int(int32(millisecondsTimeoutHint)))
	}
}

func (ptr *QSystemTrayIcon) ConnectShowMessage2(f func(title string, message string, icon *gui.QIcon, millisecondsTimeoutHint int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMessage2"); signal != nil {
			f := func(title string, message string, icon *gui.QIcon, millisecondsTimeoutHint int) {
				(*(*func(string, string, *gui.QIcon, int))(signal))(title, message, icon, millisecondsTimeoutHint)
				f(title, message, icon, millisecondsTimeoutHint)
			}
			qt.ConnectSignal(ptr.Pointer(), "showMessage2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMessage2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSystemTrayIcon) DisconnectShowMessage2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMessage2")
	}
}

func (ptr *QSystemTrayIcon) ShowMessage2(title string, message string, icon gui.QIcon_ITF, millisecondsTimeoutHint int) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QSystemTrayIcon_ShowMessage2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, gui.PointerFromQIcon(icon), C.int(int32(millisecondsTimeoutHint)))
	}
}

func (ptr *QSystemTrayIcon) ShowMessage2Default(title string, message string, icon gui.QIcon_ITF, millisecondsTimeoutHint int) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		var messageC *C.char
		if message != "" {
			messageC = C.CString(message)
			defer C.free(unsafe.Pointer(messageC))
		}
		C.QSystemTrayIcon_ShowMessage2Default(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, C.struct_QtWidgets_PackedString{data: messageC, len: C.longlong(len(message))}, gui.PointerFromQIcon(icon), C.int(int32(millisecondsTimeoutHint)))
	}
}

//export callbackQSystemTrayIcon_DestroyQSystemTrayIcon
func callbackQSystemTrayIcon_DestroyQSystemTrayIcon(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QSystemTrayIcon"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSystemTrayIconFromPointer(ptr).DestroyQSystemTrayIconDefault()
	}
}

func (ptr *QSystemTrayIcon) ConnectDestroyQSystemTrayIcon(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QSystemTrayIcon"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QSystemTrayIcon", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QSystemTrayIcon", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QSystemTrayIcon) DisconnectDestroyQSystemTrayIcon() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QSystemTrayIcon")
	}
}

func (ptr *QSystemTrayIcon) DestroyQSystemTrayIcon() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_DestroyQSystemTrayIcon(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSystemTrayIcon) DestroyQSystemTrayIconDefault() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_DestroyQSystemTrayIconDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QSystemTrayIcon) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QSystemTrayIcon_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QSystemTrayIcon) ContextMenu() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QSystemTrayIcon_ContextMenu(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSystemTrayIcon) Geometry() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QSystemTrayIcon_Geometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QSystemTrayIcon) ToolTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QSystemTrayIcon_ToolTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSystemTrayIcon) IsVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QSystemTrayIcon_IsVisible(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQSystemTrayIcon_MetaObject
func callbackQSystemTrayIcon_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQSystemTrayIconFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QSystemTrayIcon) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QSystemTrayIcon_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSystemTrayIcon) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QSystemTrayIcon___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QSystemTrayIcon) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QSystemTrayIcon) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QSystemTrayIcon___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QSystemTrayIcon) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QSystemTrayIcon___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSystemTrayIcon) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSystemTrayIcon) __findChildren_newList2() unsafe.Pointer {
	return C.QSystemTrayIcon___findChildren_newList2(ptr.Pointer())
}

func (ptr *QSystemTrayIcon) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QSystemTrayIcon___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSystemTrayIcon) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSystemTrayIcon) __findChildren_newList3() unsafe.Pointer {
	return C.QSystemTrayIcon___findChildren_newList3(ptr.Pointer())
}

func (ptr *QSystemTrayIcon) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QSystemTrayIcon___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSystemTrayIcon) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSystemTrayIcon) __findChildren_newList() unsafe.Pointer {
	return C.QSystemTrayIcon___findChildren_newList(ptr.Pointer())
}

func (ptr *QSystemTrayIcon) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QSystemTrayIcon___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QSystemTrayIcon) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QSystemTrayIcon) __children_newList() unsafe.Pointer {
	return C.QSystemTrayIcon___children_newList(ptr.Pointer())
}

//export callbackQSystemTrayIcon_EventFilter
func callbackQSystemTrayIcon_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQSystemTrayIconFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QSystemTrayIcon) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QSystemTrayIcon_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQSystemTrayIcon_ChildEvent
func callbackQSystemTrayIcon_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQSystemTrayIconFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QSystemTrayIcon) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQSystemTrayIcon_ConnectNotify
func callbackQSystemTrayIcon_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSystemTrayIconFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSystemTrayIcon) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSystemTrayIcon_CustomEvent
func callbackQSystemTrayIcon_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQSystemTrayIconFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QSystemTrayIcon) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQSystemTrayIcon_DeleteLater
func callbackQSystemTrayIcon_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQSystemTrayIconFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QSystemTrayIcon) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQSystemTrayIcon_Destroyed
func callbackQSystemTrayIcon_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQSystemTrayIcon_DisconnectNotify
func callbackQSystemTrayIcon_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQSystemTrayIconFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QSystemTrayIcon) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQSystemTrayIcon_ObjectNameChanged
func callbackQSystemTrayIcon_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQSystemTrayIcon_TimerEvent
func callbackQSystemTrayIcon_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQSystemTrayIconFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSystemTrayIcon) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QSystemTrayIcon_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QTabBar struct {
	QWidget
}

type QTabBar_ITF interface {
	QWidget_ITF
	QTabBar_PTR() *QTabBar
}

func (ptr *QTabBar) QTabBar_PTR() *QTabBar {
	return ptr
}

func (ptr *QTabBar) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QTabBar) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQTabBar(ptr QTabBar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTabBar_PTR().Pointer()
	}
	return nil
}

func NewQTabBarFromPointer(ptr unsafe.Pointer) (n *QTabBar) {
	n = new(QTabBar)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTabBar__ButtonPosition
//QTabBar::ButtonPosition
type QTabBar__ButtonPosition int64

const (
	QTabBar__LeftSide  QTabBar__ButtonPosition = QTabBar__ButtonPosition(0)
	QTabBar__RightSide QTabBar__ButtonPosition = QTabBar__ButtonPosition(1)
)

//go:generate stringer -type=QTabBar__SelectionBehavior
//QTabBar::SelectionBehavior
type QTabBar__SelectionBehavior int64

const (
	QTabBar__SelectLeftTab     QTabBar__SelectionBehavior = QTabBar__SelectionBehavior(0)
	QTabBar__SelectRightTab    QTabBar__SelectionBehavior = QTabBar__SelectionBehavior(1)
	QTabBar__SelectPreviousTab QTabBar__SelectionBehavior = QTabBar__SelectionBehavior(2)
)

//go:generate stringer -type=QTabBar__Shape
//QTabBar::Shape
type QTabBar__Shape int64

const (
	QTabBar__RoundedNorth    QTabBar__Shape = QTabBar__Shape(0)
	QTabBar__RoundedSouth    QTabBar__Shape = QTabBar__Shape(1)
	QTabBar__RoundedWest     QTabBar__Shape = QTabBar__Shape(2)
	QTabBar__RoundedEast     QTabBar__Shape = QTabBar__Shape(3)
	QTabBar__TriangularNorth QTabBar__Shape = QTabBar__Shape(4)
	QTabBar__TriangularSouth QTabBar__Shape = QTabBar__Shape(5)
	QTabBar__TriangularWest  QTabBar__Shape = QTabBar__Shape(6)
	QTabBar__TriangularEast  QTabBar__Shape = QTabBar__Shape(7)
)

func NewQTabBar(parent QWidget_ITF) *QTabBar {
	tmpValue := NewQTabBarFromPointer(C.QTabBar_NewQTabBar(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTabBar) AddTab2(icon gui.QIcon_ITF, text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QTabBar_AddTab2(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

func (ptr *QTabBar) AddTab(text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QTabBar_AddTab(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

func (ptr *QTabBar) InsertTab2(index int, icon gui.QIcon_ITF, text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QTabBar_InsertTab2(ptr.Pointer(), C.int(int32(index)), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

func (ptr *QTabBar) InsertTab(index int, text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QTabBar_InsertTab(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

//export callbackQTabBar_CurrentChanged
func callbackQTabBar_CurrentChanged(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QTabBar) ConnectCurrentChanged(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentChanged") {
			C.QTabBar_ConnectCurrentChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {
		C.QTabBar_DisconnectCurrentChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QTabBar) CurrentChanged(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_CurrentChanged(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabBar) MoveTab(from int, to int) {
	if ptr.Pointer() != nil {
		C.QTabBar_MoveTab(ptr.Pointer(), C.int(int32(from)), C.int(int32(to)))
	}
}

func (ptr *QTabBar) RemoveTab(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_RemoveTab(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabBar) SetAccessibleTabName(index int, name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QTabBar_SetAccessibleTabName(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

func (ptr *QTabBar) SetAutoHide(hide bool) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetAutoHide(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

func (ptr *QTabBar) SetChangeCurrentOnDrag(change bool) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetChangeCurrentOnDrag(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(change))))
	}
}

//export callbackQTabBar_SetCurrentIndex
func callbackQTabBar_SetCurrentIndex(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQTabBarFromPointer(ptr).SetCurrentIndexDefault(int(int32(index)))
	}
}

func (ptr *QTabBar) ConnectSetCurrentIndex(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentIndex"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectSetCurrentIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentIndex")
	}
}

func (ptr *QTabBar) SetCurrentIndex(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetCurrentIndex(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabBar) SetCurrentIndexDefault(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetCurrentIndexDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabBar) SetDocumentMode(set bool) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetDocumentMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(set))))
	}
}

func (ptr *QTabBar) SetDrawBase(drawTheBase bool) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetDrawBase(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(drawTheBase))))
	}
}

func (ptr *QTabBar) SetElideMode(vqt core.Qt__TextElideMode) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetElideMode(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QTabBar) SetExpanding(enabled bool) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetExpanding(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QTabBar) SetIconSize(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetIconSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QTabBar) SetMovable(movable bool) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetMovable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(movable))))
	}
}

func (ptr *QTabBar) SetSelectionBehaviorOnRemove(behavior QTabBar__SelectionBehavior) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetSelectionBehaviorOnRemove(ptr.Pointer(), C.longlong(behavior))
	}
}

func (ptr *QTabBar) SetShape(shape QTabBar__Shape) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetShape(ptr.Pointer(), C.longlong(shape))
	}
}

func (ptr *QTabBar) SetTabButton(index int, position QTabBar__ButtonPosition, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetTabButton(ptr.Pointer(), C.int(int32(index)), C.longlong(position), PointerFromQWidget(widget))
	}
}

func (ptr *QTabBar) SetTabData(index int, data core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetTabData(ptr.Pointer(), C.int(int32(index)), core.PointerFromQVariant(data))
	}
}

func (ptr *QTabBar) SetTabEnabled(index int, enabled bool) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetTabEnabled(ptr.Pointer(), C.int(int32(index)), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QTabBar) SetTabIcon(index int, icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetTabIcon(ptr.Pointer(), C.int(int32(index)), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QTabBar) SetTabText(index int, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTabBar_SetTabText(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTabBar) SetTabTextColor(index int, color gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetTabTextColor(ptr.Pointer(), C.int(int32(index)), gui.PointerFromQColor(color))
	}
}

func (ptr *QTabBar) SetTabToolTip(index int, tip string) {
	if ptr.Pointer() != nil {
		var tipC *C.char
		if tip != "" {
			tipC = C.CString(tip)
			defer C.free(unsafe.Pointer(tipC))
		}
		C.QTabBar_SetTabToolTip(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: tipC, len: C.longlong(len(tip))})
	}
}

func (ptr *QTabBar) SetTabWhatsThis(index int, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTabBar_SetTabWhatsThis(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTabBar) SetTabsClosable(closable bool) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetTabsClosable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(closable))))
	}
}

func (ptr *QTabBar) SetUsesScrollButtons(useButtons bool) {
	if ptr.Pointer() != nil {
		C.QTabBar_SetUsesScrollButtons(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(useButtons))))
	}
}

//export callbackQTabBar_TabBarClicked
func callbackQTabBar_TabBarClicked(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabBarClicked"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QTabBar) ConnectTabBarClicked(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "tabBarClicked") {
			C.QTabBar_ConnectTabBarClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "tabBarClicked"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabBarClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabBarClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectTabBarClicked() {
	if ptr.Pointer() != nil {
		C.QTabBar_DisconnectTabBarClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "tabBarClicked")
	}
}

func (ptr *QTabBar) TabBarClicked(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_TabBarClicked(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabBar_TabBarDoubleClicked
func callbackQTabBar_TabBarDoubleClicked(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabBarDoubleClicked"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QTabBar) ConnectTabBarDoubleClicked(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "tabBarDoubleClicked") {
			C.QTabBar_ConnectTabBarDoubleClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "tabBarDoubleClicked"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabBarDoubleClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabBarDoubleClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectTabBarDoubleClicked() {
	if ptr.Pointer() != nil {
		C.QTabBar_DisconnectTabBarDoubleClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "tabBarDoubleClicked")
	}
}

func (ptr *QTabBar) TabBarDoubleClicked(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_TabBarDoubleClicked(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabBar_TabCloseRequested
func callbackQTabBar_TabCloseRequested(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabCloseRequested"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QTabBar) ConnectTabCloseRequested(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "tabCloseRequested") {
			C.QTabBar_ConnectTabCloseRequested(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "tabCloseRequested"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabCloseRequested", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabCloseRequested", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectTabCloseRequested() {
	if ptr.Pointer() != nil {
		C.QTabBar_DisconnectTabCloseRequested(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "tabCloseRequested")
	}
}

func (ptr *QTabBar) TabCloseRequested(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_TabCloseRequested(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabBar_TabInserted
func callbackQTabBar_TabInserted(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabInserted"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQTabBarFromPointer(ptr).TabInsertedDefault(int(int32(index)))
	}
}

func (ptr *QTabBar) ConnectTabInserted(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "tabInserted"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectTabInserted() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "tabInserted")
	}
}

func (ptr *QTabBar) TabInserted(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_TabInserted(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabBar) TabInsertedDefault(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_TabInsertedDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabBar_TabLayoutChange
func callbackQTabBar_TabLayoutChange(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "tabLayoutChange"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTabBarFromPointer(ptr).TabLayoutChangeDefault()
	}
}

func (ptr *QTabBar) ConnectTabLayoutChange(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "tabLayoutChange"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "tabLayoutChange", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabLayoutChange", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectTabLayoutChange() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "tabLayoutChange")
	}
}

func (ptr *QTabBar) TabLayoutChange() {
	if ptr.Pointer() != nil {
		C.QTabBar_TabLayoutChange(ptr.Pointer())
	}
}

func (ptr *QTabBar) TabLayoutChangeDefault() {
	if ptr.Pointer() != nil {
		C.QTabBar_TabLayoutChangeDefault(ptr.Pointer())
	}
}

//export callbackQTabBar_TabMoved
func callbackQTabBar_TabMoved(ptr unsafe.Pointer, from C.int, to C.int) {
	if signal := qt.GetSignal(ptr, "tabMoved"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(from)), int(int32(to)))
	}

}

func (ptr *QTabBar) ConnectTabMoved(f func(from int, to int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "tabMoved") {
			C.QTabBar_ConnectTabMoved(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "tabMoved"); signal != nil {
			f := func(from int, to int) {
				(*(*func(int, int))(signal))(from, to)
				f(from, to)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectTabMoved() {
	if ptr.Pointer() != nil {
		C.QTabBar_DisconnectTabMoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "tabMoved")
	}
}

func (ptr *QTabBar) TabMoved(from int, to int) {
	if ptr.Pointer() != nil {
		C.QTabBar_TabMoved(ptr.Pointer(), C.int(int32(from)), C.int(int32(to)))
	}
}

//export callbackQTabBar_TabRemoved
func callbackQTabBar_TabRemoved(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabRemoved"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQTabBarFromPointer(ptr).TabRemovedDefault(int(int32(index)))
	}
}

func (ptr *QTabBar) ConnectTabRemoved(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "tabRemoved"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectTabRemoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "tabRemoved")
	}
}

func (ptr *QTabBar) TabRemoved(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_TabRemoved(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabBar) TabRemovedDefault(index int) {
	if ptr.Pointer() != nil {
		C.QTabBar_TabRemovedDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabBar_DestroyQTabBar
func callbackQTabBar_DestroyQTabBar(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTabBar"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTabBarFromPointer(ptr).DestroyQTabBarDefault()
	}
}

func (ptr *QTabBar) ConnectDestroyQTabBar(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTabBar"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTabBar", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTabBar", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectDestroyQTabBar() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTabBar")
	}
}

func (ptr *QTabBar) DestroyQTabBar() {
	if ptr.Pointer() != nil {
		C.QTabBar_DestroyQTabBar(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTabBar) DestroyQTabBarDefault() {
	if ptr.Pointer() != nil {
		C.QTabBar_DestroyQTabBarDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTabBar) TabTextColor(index int) *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QTabBar_TabTextColor(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QTabBar) TabIcon(index int) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QTabBar_TabIcon(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QTabBar) TabRect(index int) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QTabBar_TabRect(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QTabBar) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QTabBar_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQTabBar_MinimumTabSizeHint
func callbackQTabBar_MinimumTabSizeHint(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "minimumTabSizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func(int) *core.QSize)(signal))(int(int32(index))))
	}

	return core.PointerFromQSize(NewQTabBarFromPointer(ptr).MinimumTabSizeHintDefault(int(int32(index))))
}

func (ptr *QTabBar) ConnectMinimumTabSizeHint(f func(index int) *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "minimumTabSizeHint"); signal != nil {
			f := func(index int) *core.QSize {
				(*(*func(int) *core.QSize)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "minimumTabSizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "minimumTabSizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectMinimumTabSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "minimumTabSizeHint")
	}
}

func (ptr *QTabBar) MinimumTabSizeHint(index int) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QTabBar_MinimumTabSizeHint(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QTabBar) MinimumTabSizeHintDefault(index int) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QTabBar_MinimumTabSizeHintDefault(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQTabBar_TabSizeHint
func callbackQTabBar_TabSizeHint(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "tabSizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func(int) *core.QSize)(signal))(int(int32(index))))
	}

	return core.PointerFromQSize(NewQTabBarFromPointer(ptr).TabSizeHintDefault(int(int32(index))))
}

func (ptr *QTabBar) ConnectTabSizeHint(f func(index int) *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "tabSizeHint"); signal != nil {
			f := func(index int) *core.QSize {
				(*(*func(int) *core.QSize)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabSizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabSizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabBar) DisconnectTabSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "tabSizeHint")
	}
}

func (ptr *QTabBar) TabSizeHint(index int) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QTabBar_TabSizeHint(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QTabBar) TabSizeHintDefault(index int) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QTabBar_TabSizeHintDefault(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QTabBar) AccessibleTabName(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTabBar_AccessibleTabName(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QTabBar) TabText(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTabBar_TabText(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QTabBar) TabToolTip(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTabBar_TabToolTip(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QTabBar) TabWhatsThis(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTabBar_TabWhatsThis(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QTabBar) SelectionBehaviorOnRemove() QTabBar__SelectionBehavior {
	if ptr.Pointer() != nil {
		return QTabBar__SelectionBehavior(C.QTabBar_SelectionBehaviorOnRemove(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabBar) Shape() QTabBar__Shape {
	if ptr.Pointer() != nil {
		return QTabBar__Shape(C.QTabBar_Shape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabBar) TabData(index int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QTabBar_TabData(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QTabBar) TabButton(index int, position QTabBar__ButtonPosition) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QTabBar_TabButton(ptr.Pointer(), C.int(int32(index)), C.longlong(position)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTabBar) ElideMode() core.Qt__TextElideMode {
	if ptr.Pointer() != nil {
		return core.Qt__TextElideMode(C.QTabBar_ElideMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabBar) AutoHide() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabBar_AutoHide(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabBar) ChangeCurrentOnDrag() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabBar_ChangeCurrentOnDrag(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabBar) DocumentMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabBar_DocumentMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabBar) DrawBase() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabBar_DrawBase(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabBar) Expanding() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabBar_Expanding(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabBar) IsMovable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabBar_IsMovable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabBar) IsTabEnabled(index int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabBar_IsTabEnabled(ptr.Pointer(), C.int(int32(index)))) != 0
	}
	return false
}

func (ptr *QTabBar) TabsClosable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabBar_TabsClosable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabBar) UsesScrollButtons() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabBar_UsesScrollButtons(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabBar) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTabBar_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTabBar) CurrentIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTabBar_CurrentIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTabBar) TabAt(position core.QPoint_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTabBar_TabAt(ptr.Pointer(), core.PointerFromQPoint(position))))
	}
	return 0
}

func (ptr *QTabBar) InitStyleOption(option QStyleOptionTab_ITF, tabIndex int) {
	if ptr.Pointer() != nil {
		C.QTabBar_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionTab(option), C.int(int32(tabIndex)))
	}
}

type QTabWidget struct {
	QWidget
}

type QTabWidget_ITF interface {
	QWidget_ITF
	QTabWidget_PTR() *QTabWidget
}

func (ptr *QTabWidget) QTabWidget_PTR() *QTabWidget {
	return ptr
}

func (ptr *QTabWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QTabWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQTabWidget(ptr QTabWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTabWidget_PTR().Pointer()
	}
	return nil
}

func NewQTabWidgetFromPointer(ptr unsafe.Pointer) (n *QTabWidget) {
	n = new(QTabWidget)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTabWidget__TabPosition
//QTabWidget::TabPosition
type QTabWidget__TabPosition int64

const (
	QTabWidget__North QTabWidget__TabPosition = QTabWidget__TabPosition(0)
	QTabWidget__South QTabWidget__TabPosition = QTabWidget__TabPosition(1)
	QTabWidget__West  QTabWidget__TabPosition = QTabWidget__TabPosition(2)
	QTabWidget__East  QTabWidget__TabPosition = QTabWidget__TabPosition(3)
)

//go:generate stringer -type=QTabWidget__TabShape
//QTabWidget::TabShape
type QTabWidget__TabShape int64

const (
	QTabWidget__Rounded    QTabWidget__TabShape = QTabWidget__TabShape(0)
	QTabWidget__Triangular QTabWidget__TabShape = QTabWidget__TabShape(1)
)

func NewQTabWidget(parent QWidget_ITF) *QTabWidget {
	tmpValue := NewQTabWidgetFromPointer(C.QTabWidget_NewQTabWidget(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTabWidget) AddTab2(page QWidget_ITF, icon gui.QIcon_ITF, label string) int {
	if ptr.Pointer() != nil {
		var labelC *C.char
		if label != "" {
			labelC = C.CString(label)
			defer C.free(unsafe.Pointer(labelC))
		}
		return int(int32(C.QTabWidget_AddTab2(ptr.Pointer(), PointerFromQWidget(page), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))})))
	}
	return 0
}

func (ptr *QTabWidget) AddTab(page QWidget_ITF, label string) int {
	if ptr.Pointer() != nil {
		var labelC *C.char
		if label != "" {
			labelC = C.CString(label)
			defer C.free(unsafe.Pointer(labelC))
		}
		return int(int32(C.QTabWidget_AddTab(ptr.Pointer(), PointerFromQWidget(page), C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))})))
	}
	return 0
}

func (ptr *QTabWidget) InsertTab2(index int, page QWidget_ITF, icon gui.QIcon_ITF, label string) int {
	if ptr.Pointer() != nil {
		var labelC *C.char
		if label != "" {
			labelC = C.CString(label)
			defer C.free(unsafe.Pointer(labelC))
		}
		return int(int32(C.QTabWidget_InsertTab2(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(page), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))})))
	}
	return 0
}

func (ptr *QTabWidget) InsertTab(index int, page QWidget_ITF, label string) int {
	if ptr.Pointer() != nil {
		var labelC *C.char
		if label != "" {
			labelC = C.CString(label)
			defer C.free(unsafe.Pointer(labelC))
		}
		return int(int32(C.QTabWidget_InsertTab(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(page), C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))})))
	}
	return 0
}

func (ptr *QTabWidget) Clear() {
	if ptr.Pointer() != nil {
		C.QTabWidget_Clear(ptr.Pointer())
	}
}

//export callbackQTabWidget_CurrentChanged
func callbackQTabWidget_CurrentChanged(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QTabWidget) ConnectCurrentChanged(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentChanged") {
			C.QTabWidget_ConnectCurrentChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabWidget) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {
		C.QTabWidget_DisconnectCurrentChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QTabWidget) CurrentChanged(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_CurrentChanged(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabWidget) RemoveTab(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_RemoveTab(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabWidget) SetCornerWidget(widget QWidget_ITF, corner core.Qt__Corner) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetCornerWidget(ptr.Pointer(), PointerFromQWidget(widget), C.longlong(corner))
	}
}

//export callbackQTabWidget_SetCurrentIndex
func callbackQTabWidget_SetCurrentIndex(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQTabWidgetFromPointer(ptr).SetCurrentIndexDefault(int(int32(index)))
	}
}

func (ptr *QTabWidget) ConnectSetCurrentIndex(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentIndex"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabWidget) DisconnectSetCurrentIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentIndex")
	}
}

func (ptr *QTabWidget) SetCurrentIndex(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetCurrentIndex(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabWidget) SetCurrentIndexDefault(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetCurrentIndexDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabWidget_SetCurrentWidget
func callbackQTabWidget_SetCurrentWidget(ptr unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setCurrentWidget"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(widget))
	} else {
		NewQTabWidgetFromPointer(ptr).SetCurrentWidgetDefault(NewQWidgetFromPointer(widget))
	}
}

func (ptr *QTabWidget) ConnectSetCurrentWidget(f func(widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentWidget"); signal != nil {
			f := func(widget *QWidget) {
				(*(*func(*QWidget))(signal))(widget)
				f(widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabWidget) DisconnectSetCurrentWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentWidget")
	}
}

func (ptr *QTabWidget) SetCurrentWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetCurrentWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QTabWidget) SetCurrentWidgetDefault(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetCurrentWidgetDefault(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QTabWidget) SetDocumentMode(set bool) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetDocumentMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(set))))
	}
}

func (ptr *QTabWidget) SetElideMode(vqt core.Qt__TextElideMode) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetElideMode(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QTabWidget) SetIconSize(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetIconSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QTabWidget) SetMovable(movable bool) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetMovable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(movable))))
	}
}

func (ptr *QTabWidget) SetTabBar(tb QTabBar_ITF) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetTabBar(ptr.Pointer(), PointerFromQTabBar(tb))
	}
}

func (ptr *QTabWidget) SetTabBarAutoHide(enabled bool) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetTabBarAutoHide(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QTabWidget) SetTabEnabled(index int, enable bool) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetTabEnabled(ptr.Pointer(), C.int(int32(index)), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QTabWidget) SetTabIcon(index int, icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetTabIcon(ptr.Pointer(), C.int(int32(index)), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QTabWidget) SetTabPosition(vqt QTabWidget__TabPosition) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetTabPosition(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QTabWidget) SetTabShape(s QTabWidget__TabShape) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetTabShape(ptr.Pointer(), C.longlong(s))
	}
}

func (ptr *QTabWidget) SetTabText(index int, label string) {
	if ptr.Pointer() != nil {
		var labelC *C.char
		if label != "" {
			labelC = C.CString(label)
			defer C.free(unsafe.Pointer(labelC))
		}
		C.QTabWidget_SetTabText(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))})
	}
}

func (ptr *QTabWidget) SetTabToolTip(index int, tip string) {
	if ptr.Pointer() != nil {
		var tipC *C.char
		if tip != "" {
			tipC = C.CString(tip)
			defer C.free(unsafe.Pointer(tipC))
		}
		C.QTabWidget_SetTabToolTip(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: tipC, len: C.longlong(len(tip))})
	}
}

func (ptr *QTabWidget) SetTabWhatsThis(index int, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTabWidget_SetTabWhatsThis(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTabWidget) SetTabsClosable(closeable bool) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetTabsClosable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(closeable))))
	}
}

func (ptr *QTabWidget) SetUsesScrollButtons(useButtons bool) {
	if ptr.Pointer() != nil {
		C.QTabWidget_SetUsesScrollButtons(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(useButtons))))
	}
}

//export callbackQTabWidget_TabBarClicked
func callbackQTabWidget_TabBarClicked(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabBarClicked"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QTabWidget) ConnectTabBarClicked(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "tabBarClicked") {
			C.QTabWidget_ConnectTabBarClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "tabBarClicked"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabBarClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabBarClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabWidget) DisconnectTabBarClicked() {
	if ptr.Pointer() != nil {
		C.QTabWidget_DisconnectTabBarClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "tabBarClicked")
	}
}

func (ptr *QTabWidget) TabBarClicked(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_TabBarClicked(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabWidget_TabBarDoubleClicked
func callbackQTabWidget_TabBarDoubleClicked(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabBarDoubleClicked"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QTabWidget) ConnectTabBarDoubleClicked(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "tabBarDoubleClicked") {
			C.QTabWidget_ConnectTabBarDoubleClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "tabBarDoubleClicked"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabBarDoubleClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabBarDoubleClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabWidget) DisconnectTabBarDoubleClicked() {
	if ptr.Pointer() != nil {
		C.QTabWidget_DisconnectTabBarDoubleClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "tabBarDoubleClicked")
	}
}

func (ptr *QTabWidget) TabBarDoubleClicked(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_TabBarDoubleClicked(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabWidget_TabCloseRequested
func callbackQTabWidget_TabCloseRequested(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabCloseRequested"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QTabWidget) ConnectTabCloseRequested(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "tabCloseRequested") {
			C.QTabWidget_ConnectTabCloseRequested(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "tabCloseRequested"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabCloseRequested", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabCloseRequested", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabWidget) DisconnectTabCloseRequested() {
	if ptr.Pointer() != nil {
		C.QTabWidget_DisconnectTabCloseRequested(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "tabCloseRequested")
	}
}

func (ptr *QTabWidget) TabCloseRequested(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_TabCloseRequested(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabWidget_TabInserted
func callbackQTabWidget_TabInserted(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabInserted"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQTabWidgetFromPointer(ptr).TabInsertedDefault(int(int32(index)))
	}
}

func (ptr *QTabWidget) ConnectTabInserted(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "tabInserted"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabWidget) DisconnectTabInserted() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "tabInserted")
	}
}

func (ptr *QTabWidget) TabInserted(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_TabInserted(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabWidget) TabInsertedDefault(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_TabInsertedDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabWidget_TabRemoved
func callbackQTabWidget_TabRemoved(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "tabRemoved"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQTabWidgetFromPointer(ptr).TabRemovedDefault(int(int32(index)))
	}
}

func (ptr *QTabWidget) ConnectTabRemoved(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "tabRemoved"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabWidget) DisconnectTabRemoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "tabRemoved")
	}
}

func (ptr *QTabWidget) TabRemoved(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_TabRemoved(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTabWidget) TabRemovedDefault(index int) {
	if ptr.Pointer() != nil {
		C.QTabWidget_TabRemovedDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQTabWidget_DestroyQTabWidget
func callbackQTabWidget_DestroyQTabWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTabWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTabWidgetFromPointer(ptr).DestroyQTabWidgetDefault()
	}
}

func (ptr *QTabWidget) ConnectDestroyQTabWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTabWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTabWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTabWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTabWidget) DisconnectDestroyQTabWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTabWidget")
	}
}

func (ptr *QTabWidget) DestroyQTabWidget() {
	if ptr.Pointer() != nil {
		C.QTabWidget_DestroyQTabWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTabWidget) DestroyQTabWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QTabWidget_DestroyQTabWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTabWidget) TabIcon(index int) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QTabWidget_TabIcon(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QTabWidget) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QTabWidget_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QTabWidget) TabText(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTabWidget_TabText(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QTabWidget) TabToolTip(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTabWidget_TabToolTip(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QTabWidget) TabWhatsThis(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTabWidget_TabWhatsThis(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QTabWidget) TabBar() *QTabBar {
	if ptr.Pointer() != nil {
		tmpValue := NewQTabBarFromPointer(C.QTabWidget_TabBar(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTabWidget) TabPosition() QTabWidget__TabPosition {
	if ptr.Pointer() != nil {
		return QTabWidget__TabPosition(C.QTabWidget_TabPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabWidget) TabShape() QTabWidget__TabShape {
	if ptr.Pointer() != nil {
		return QTabWidget__TabShape(C.QTabWidget_TabShape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabWidget) CornerWidget(corner core.Qt__Corner) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QTabWidget_CornerWidget(ptr.Pointer(), C.longlong(corner)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTabWidget) CurrentWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QTabWidget_CurrentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTabWidget) Widget(index int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QTabWidget_Widget(ptr.Pointer(), C.int(int32(index))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTabWidget) ElideMode() core.Qt__TextElideMode {
	if ptr.Pointer() != nil {
		return core.Qt__TextElideMode(C.QTabWidget_ElideMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabWidget) DocumentMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabWidget_DocumentMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabWidget) IsMovable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabWidget_IsMovable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabWidget) IsTabEnabled(index int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabWidget_IsTabEnabled(ptr.Pointer(), C.int(int32(index)))) != 0
	}
	return false
}

func (ptr *QTabWidget) TabBarAutoHide() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabWidget_TabBarAutoHide(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabWidget) TabsClosable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabWidget_TabsClosable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabWidget) UsesScrollButtons() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTabWidget_UsesScrollButtons(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTabWidget) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTabWidget_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTabWidget) CurrentIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTabWidget_CurrentIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTabWidget) IndexOf(w QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTabWidget_IndexOf(ptr.Pointer(), PointerFromQWidget(w))))
	}
	return 0
}

func (ptr *QTabWidget) InitStyleOption(option QStyleOptionTabWidgetFrame_ITF) {
	if ptr.Pointer() != nil {
		C.QTabWidget_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionTabWidgetFrame(option))
	}
}

type QTableView struct {
	QAbstractItemView
}

type QTableView_ITF interface {
	QAbstractItemView_ITF
	QTableView_PTR() *QTableView
}

func (ptr *QTableView) QTableView_PTR() *QTableView {
	return ptr
}

func (ptr *QTableView) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemView_PTR().Pointer()
	}
	return nil
}

func (ptr *QTableView) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractItemView_PTR().SetPointer(p)
	}
}

func PointerFromQTableView(ptr QTableView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTableView_PTR().Pointer()
	}
	return nil
}

func NewQTableViewFromPointer(ptr unsafe.Pointer) (n *QTableView) {
	n = new(QTableView)
	n.SetPointer(ptr)
	return
}

//export callbackQTableView_MoveCursor
func callbackQTableView_MoveCursor(ptr unsafe.Pointer, cursorAction C.longlong, modifiers C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "moveCursor"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
	}

	return core.PointerFromQModelIndex(NewQTableViewFromPointer(ptr).MoveCursorDefault(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
}

func (ptr *QTableView) ConnectMoveCursor(f func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "moveCursor"); signal != nil {
			f := func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
				(*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(cursorAction, modifiers)
				return f(cursorAction, modifiers)
			}
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectMoveCursor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "moveCursor")
	}
}

func (ptr *QTableView) MoveCursor(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTableView_MoveCursor(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTableView) MoveCursorDefault(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTableView_MoveCursorDefault(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func NewQTableView(parent QWidget_ITF) *QTableView {
	tmpValue := NewQTableViewFromPointer(C.QTableView_NewQTableView(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTableView) ClearSpans() {
	if ptr.Pointer() != nil {
		C.QTableView_ClearSpans(ptr.Pointer())
	}
}

//export callbackQTableView_ColumnCountChanged
func callbackQTableView_ColumnCountChanged(ptr unsafe.Pointer, oldCount C.int, newCount C.int) {
	if signal := qt.GetSignal(ptr, "columnCountChanged"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(oldCount)), int(int32(newCount)))
	} else {
		NewQTableViewFromPointer(ptr).ColumnCountChangedDefault(int(int32(oldCount)), int(int32(newCount)))
	}
}

func (ptr *QTableView) ConnectColumnCountChanged(f func(oldCount int, newCount int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnCountChanged"); signal != nil {
			f := func(oldCount int, newCount int) {
				(*(*func(int, int))(signal))(oldCount, newCount)
				f(oldCount, newCount)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnCountChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnCountChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectColumnCountChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnCountChanged")
	}
}

func (ptr *QTableView) ColumnCountChanged(oldCount int, newCount int) {
	if ptr.Pointer() != nil {
		C.QTableView_ColumnCountChanged(ptr.Pointer(), C.int(int32(oldCount)), C.int(int32(newCount)))
	}
}

func (ptr *QTableView) ColumnCountChangedDefault(oldCount int, newCount int) {
	if ptr.Pointer() != nil {
		C.QTableView_ColumnCountChangedDefault(ptr.Pointer(), C.int(int32(oldCount)), C.int(int32(newCount)))
	}
}

//export callbackQTableView_ColumnMoved
func callbackQTableView_ColumnMoved(ptr unsafe.Pointer, column C.int, oldIndex C.int, newIndex C.int) {
	if signal := qt.GetSignal(ptr, "columnMoved"); signal != nil {
		(*(*func(int, int, int))(signal))(int(int32(column)), int(int32(oldIndex)), int(int32(newIndex)))
	} else {
		NewQTableViewFromPointer(ptr).ColumnMovedDefault(int(int32(column)), int(int32(oldIndex)), int(int32(newIndex)))
	}
}

func (ptr *QTableView) ConnectColumnMoved(f func(column int, oldIndex int, newIndex int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnMoved"); signal != nil {
			f := func(column int, oldIndex int, newIndex int) {
				(*(*func(int, int, int))(signal))(column, oldIndex, newIndex)
				f(column, oldIndex, newIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectColumnMoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnMoved")
	}
}

func (ptr *QTableView) ColumnMoved(column int, oldIndex int, newIndex int) {
	if ptr.Pointer() != nil {
		C.QTableView_ColumnMoved(ptr.Pointer(), C.int(int32(column)), C.int(int32(oldIndex)), C.int(int32(newIndex)))
	}
}

func (ptr *QTableView) ColumnMovedDefault(column int, oldIndex int, newIndex int) {
	if ptr.Pointer() != nil {
		C.QTableView_ColumnMovedDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(oldIndex)), C.int(int32(newIndex)))
	}
}

//export callbackQTableView_ColumnResized
func callbackQTableView_ColumnResized(ptr unsafe.Pointer, column C.int, oldWidth C.int, newWidth C.int) {
	if signal := qt.GetSignal(ptr, "columnResized"); signal != nil {
		(*(*func(int, int, int))(signal))(int(int32(column)), int(int32(oldWidth)), int(int32(newWidth)))
	} else {
		NewQTableViewFromPointer(ptr).ColumnResizedDefault(int(int32(column)), int(int32(oldWidth)), int(int32(newWidth)))
	}
}

func (ptr *QTableView) ConnectColumnResized(f func(column int, oldWidth int, newWidth int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnResized"); signal != nil {
			f := func(column int, oldWidth int, newWidth int) {
				(*(*func(int, int, int))(signal))(column, oldWidth, newWidth)
				f(column, oldWidth, newWidth)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnResized", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnResized", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectColumnResized() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnResized")
	}
}

func (ptr *QTableView) ColumnResized(column int, oldWidth int, newWidth int) {
	if ptr.Pointer() != nil {
		C.QTableView_ColumnResized(ptr.Pointer(), C.int(int32(column)), C.int(int32(oldWidth)), C.int(int32(newWidth)))
	}
}

func (ptr *QTableView) ColumnResizedDefault(column int, oldWidth int, newWidth int) {
	if ptr.Pointer() != nil {
		C.QTableView_ColumnResizedDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(oldWidth)), C.int(int32(newWidth)))
	}
}

//export callbackQTableView_CurrentChanged
func callbackQTableView_CurrentChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	} else {
		NewQTableViewFromPointer(ptr).CurrentChangedDefault(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	}
}

func (ptr *QTableView) ConnectCurrentChanged(f func(current *core.QModelIndex, previous *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(current *core.QModelIndex, previous *core.QModelIndex) {
				(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(current, previous)
				f(current, previous)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QTableView) CurrentChanged(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTableView_CurrentChanged(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

func (ptr *QTableView) CurrentChangedDefault(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTableView_CurrentChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

//export callbackQTableView_HideColumn
func callbackQTableView_HideColumn(ptr unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "hideColumn"); signal != nil {
		(*(*func(int))(signal))(int(int32(column)))
	} else {
		NewQTableViewFromPointer(ptr).HideColumnDefault(int(int32(column)))
	}
}

func (ptr *QTableView) ConnectHideColumn(f func(column int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hideColumn"); signal != nil {
			f := func(column int) {
				(*(*func(int))(signal))(column)
				f(column)
			}
			qt.ConnectSignal(ptr.Pointer(), "hideColumn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hideColumn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectHideColumn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hideColumn")
	}
}

func (ptr *QTableView) HideColumn(column int) {
	if ptr.Pointer() != nil {
		C.QTableView_HideColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTableView) HideColumnDefault(column int) {
	if ptr.Pointer() != nil {
		C.QTableView_HideColumnDefault(ptr.Pointer(), C.int(int32(column)))
	}
}

//export callbackQTableView_HideRow
func callbackQTableView_HideRow(ptr unsafe.Pointer, row C.int) {
	if signal := qt.GetSignal(ptr, "hideRow"); signal != nil {
		(*(*func(int))(signal))(int(int32(row)))
	} else {
		NewQTableViewFromPointer(ptr).HideRowDefault(int(int32(row)))
	}
}

func (ptr *QTableView) ConnectHideRow(f func(row int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hideRow"); signal != nil {
			f := func(row int) {
				(*(*func(int))(signal))(row)
				f(row)
			}
			qt.ConnectSignal(ptr.Pointer(), "hideRow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hideRow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectHideRow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hideRow")
	}
}

func (ptr *QTableView) HideRow(row int) {
	if ptr.Pointer() != nil {
		C.QTableView_HideRow(ptr.Pointer(), C.int(int32(row)))
	}
}

func (ptr *QTableView) HideRowDefault(row int) {
	if ptr.Pointer() != nil {
		C.QTableView_HideRowDefault(ptr.Pointer(), C.int(int32(row)))
	}
}

//export callbackQTableView_ResizeColumnToContents
func callbackQTableView_ResizeColumnToContents(ptr unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "resizeColumnToContents"); signal != nil {
		(*(*func(int))(signal))(int(int32(column)))
	} else {
		NewQTableViewFromPointer(ptr).ResizeColumnToContentsDefault(int(int32(column)))
	}
}

func (ptr *QTableView) ConnectResizeColumnToContents(f func(column int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resizeColumnToContents"); signal != nil {
			f := func(column int) {
				(*(*func(int))(signal))(column)
				f(column)
			}
			qt.ConnectSignal(ptr.Pointer(), "resizeColumnToContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resizeColumnToContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectResizeColumnToContents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resizeColumnToContents")
	}
}

func (ptr *QTableView) ResizeColumnToContents(column int) {
	if ptr.Pointer() != nil {
		C.QTableView_ResizeColumnToContents(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTableView) ResizeColumnToContentsDefault(column int) {
	if ptr.Pointer() != nil {
		C.QTableView_ResizeColumnToContentsDefault(ptr.Pointer(), C.int(int32(column)))
	}
}

//export callbackQTableView_ResizeColumnsToContents
func callbackQTableView_ResizeColumnsToContents(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resizeColumnsToContents"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTableViewFromPointer(ptr).ResizeColumnsToContentsDefault()
	}
}

func (ptr *QTableView) ConnectResizeColumnsToContents(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resizeColumnsToContents"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "resizeColumnsToContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resizeColumnsToContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectResizeColumnsToContents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resizeColumnsToContents")
	}
}

func (ptr *QTableView) ResizeColumnsToContents() {
	if ptr.Pointer() != nil {
		C.QTableView_ResizeColumnsToContents(ptr.Pointer())
	}
}

func (ptr *QTableView) ResizeColumnsToContentsDefault() {
	if ptr.Pointer() != nil {
		C.QTableView_ResizeColumnsToContentsDefault(ptr.Pointer())
	}
}

//export callbackQTableView_ResizeRowToContents
func callbackQTableView_ResizeRowToContents(ptr unsafe.Pointer, row C.int) {
	if signal := qt.GetSignal(ptr, "resizeRowToContents"); signal != nil {
		(*(*func(int))(signal))(int(int32(row)))
	} else {
		NewQTableViewFromPointer(ptr).ResizeRowToContentsDefault(int(int32(row)))
	}
}

func (ptr *QTableView) ConnectResizeRowToContents(f func(row int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resizeRowToContents"); signal != nil {
			f := func(row int) {
				(*(*func(int))(signal))(row)
				f(row)
			}
			qt.ConnectSignal(ptr.Pointer(), "resizeRowToContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resizeRowToContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectResizeRowToContents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resizeRowToContents")
	}
}

func (ptr *QTableView) ResizeRowToContents(row int) {
	if ptr.Pointer() != nil {
		C.QTableView_ResizeRowToContents(ptr.Pointer(), C.int(int32(row)))
	}
}

func (ptr *QTableView) ResizeRowToContentsDefault(row int) {
	if ptr.Pointer() != nil {
		C.QTableView_ResizeRowToContentsDefault(ptr.Pointer(), C.int(int32(row)))
	}
}

//export callbackQTableView_ResizeRowsToContents
func callbackQTableView_ResizeRowsToContents(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resizeRowsToContents"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTableViewFromPointer(ptr).ResizeRowsToContentsDefault()
	}
}

func (ptr *QTableView) ConnectResizeRowsToContents(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resizeRowsToContents"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "resizeRowsToContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resizeRowsToContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectResizeRowsToContents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resizeRowsToContents")
	}
}

func (ptr *QTableView) ResizeRowsToContents() {
	if ptr.Pointer() != nil {
		C.QTableView_ResizeRowsToContents(ptr.Pointer())
	}
}

func (ptr *QTableView) ResizeRowsToContentsDefault() {
	if ptr.Pointer() != nil {
		C.QTableView_ResizeRowsToContentsDefault(ptr.Pointer())
	}
}

//export callbackQTableView_RowCountChanged
func callbackQTableView_RowCountChanged(ptr unsafe.Pointer, oldCount C.int, newCount C.int) {
	if signal := qt.GetSignal(ptr, "rowCountChanged"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(oldCount)), int(int32(newCount)))
	} else {
		NewQTableViewFromPointer(ptr).RowCountChangedDefault(int(int32(oldCount)), int(int32(newCount)))
	}
}

func (ptr *QTableView) ConnectRowCountChanged(f func(oldCount int, newCount int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowCountChanged"); signal != nil {
			f := func(oldCount int, newCount int) {
				(*(*func(int, int))(signal))(oldCount, newCount)
				f(oldCount, newCount)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowCountChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowCountChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectRowCountChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowCountChanged")
	}
}

func (ptr *QTableView) RowCountChanged(oldCount int, newCount int) {
	if ptr.Pointer() != nil {
		C.QTableView_RowCountChanged(ptr.Pointer(), C.int(int32(oldCount)), C.int(int32(newCount)))
	}
}

func (ptr *QTableView) RowCountChangedDefault(oldCount int, newCount int) {
	if ptr.Pointer() != nil {
		C.QTableView_RowCountChangedDefault(ptr.Pointer(), C.int(int32(oldCount)), C.int(int32(newCount)))
	}
}

//export callbackQTableView_RowMoved
func callbackQTableView_RowMoved(ptr unsafe.Pointer, row C.int, oldIndex C.int, newIndex C.int) {
	if signal := qt.GetSignal(ptr, "rowMoved"); signal != nil {
		(*(*func(int, int, int))(signal))(int(int32(row)), int(int32(oldIndex)), int(int32(newIndex)))
	} else {
		NewQTableViewFromPointer(ptr).RowMovedDefault(int(int32(row)), int(int32(oldIndex)), int(int32(newIndex)))
	}
}

func (ptr *QTableView) ConnectRowMoved(f func(row int, oldIndex int, newIndex int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowMoved"); signal != nil {
			f := func(row int, oldIndex int, newIndex int) {
				(*(*func(int, int, int))(signal))(row, oldIndex, newIndex)
				f(row, oldIndex, newIndex)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectRowMoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowMoved")
	}
}

func (ptr *QTableView) RowMoved(row int, oldIndex int, newIndex int) {
	if ptr.Pointer() != nil {
		C.QTableView_RowMoved(ptr.Pointer(), C.int(int32(row)), C.int(int32(oldIndex)), C.int(int32(newIndex)))
	}
}

func (ptr *QTableView) RowMovedDefault(row int, oldIndex int, newIndex int) {
	if ptr.Pointer() != nil {
		C.QTableView_RowMovedDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(oldIndex)), C.int(int32(newIndex)))
	}
}

//export callbackQTableView_RowResized
func callbackQTableView_RowResized(ptr unsafe.Pointer, row C.int, oldHeight C.int, newHeight C.int) {
	if signal := qt.GetSignal(ptr, "rowResized"); signal != nil {
		(*(*func(int, int, int))(signal))(int(int32(row)), int(int32(oldHeight)), int(int32(newHeight)))
	} else {
		NewQTableViewFromPointer(ptr).RowResizedDefault(int(int32(row)), int(int32(oldHeight)), int(int32(newHeight)))
	}
}

func (ptr *QTableView) ConnectRowResized(f func(row int, oldHeight int, newHeight int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowResized"); signal != nil {
			f := func(row int, oldHeight int, newHeight int) {
				(*(*func(int, int, int))(signal))(row, oldHeight, newHeight)
				f(row, oldHeight, newHeight)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowResized", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowResized", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectRowResized() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowResized")
	}
}

func (ptr *QTableView) RowResized(row int, oldHeight int, newHeight int) {
	if ptr.Pointer() != nil {
		C.QTableView_RowResized(ptr.Pointer(), C.int(int32(row)), C.int(int32(oldHeight)), C.int(int32(newHeight)))
	}
}

func (ptr *QTableView) RowResizedDefault(row int, oldHeight int, newHeight int) {
	if ptr.Pointer() != nil {
		C.QTableView_RowResizedDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(oldHeight)), C.int(int32(newHeight)))
	}
}

//export callbackQTableView_SelectColumn
func callbackQTableView_SelectColumn(ptr unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "selectColumn"); signal != nil {
		(*(*func(int))(signal))(int(int32(column)))
	} else {
		NewQTableViewFromPointer(ptr).SelectColumnDefault(int(int32(column)))
	}
}

func (ptr *QTableView) ConnectSelectColumn(f func(column int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "selectColumn"); signal != nil {
			f := func(column int) {
				(*(*func(int))(signal))(column)
				f(column)
			}
			qt.ConnectSignal(ptr.Pointer(), "selectColumn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectColumn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectSelectColumn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "selectColumn")
	}
}

func (ptr *QTableView) SelectColumn(column int) {
	if ptr.Pointer() != nil {
		C.QTableView_SelectColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTableView) SelectColumnDefault(column int) {
	if ptr.Pointer() != nil {
		C.QTableView_SelectColumnDefault(ptr.Pointer(), C.int(int32(column)))
	}
}

//export callbackQTableView_SelectRow
func callbackQTableView_SelectRow(ptr unsafe.Pointer, row C.int) {
	if signal := qt.GetSignal(ptr, "selectRow"); signal != nil {
		(*(*func(int))(signal))(int(int32(row)))
	} else {
		NewQTableViewFromPointer(ptr).SelectRowDefault(int(int32(row)))
	}
}

func (ptr *QTableView) ConnectSelectRow(f func(row int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "selectRow"); signal != nil {
			f := func(row int) {
				(*(*func(int))(signal))(row)
				f(row)
			}
			qt.ConnectSignal(ptr.Pointer(), "selectRow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectRow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectSelectRow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "selectRow")
	}
}

func (ptr *QTableView) SelectRow(row int) {
	if ptr.Pointer() != nil {
		C.QTableView_SelectRow(ptr.Pointer(), C.int(int32(row)))
	}
}

func (ptr *QTableView) SelectRowDefault(row int) {
	if ptr.Pointer() != nil {
		C.QTableView_SelectRowDefault(ptr.Pointer(), C.int(int32(row)))
	}
}

//export callbackQTableView_SelectionChanged
func callbackQTableView_SelectionChanged(ptr unsafe.Pointer, selected unsafe.Pointer, deselected unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
		(*(*func(*core.QItemSelection, *core.QItemSelection))(signal))(core.NewQItemSelectionFromPointer(selected), core.NewQItemSelectionFromPointer(deselected))
	} else {
		NewQTableViewFromPointer(ptr).SelectionChangedDefault(core.NewQItemSelectionFromPointer(selected), core.NewQItemSelectionFromPointer(deselected))
	}
}

func (ptr *QTableView) ConnectSelectionChanged(f func(selected *core.QItemSelection, deselected *core.QItemSelection)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "selectionChanged"); signal != nil {
			f := func(selected *core.QItemSelection, deselected *core.QItemSelection) {
				(*(*func(*core.QItemSelection, *core.QItemSelection))(signal))(selected, deselected)
				f(selected, deselected)
			}
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "selectionChanged")
	}
}

func (ptr *QTableView) SelectionChanged(selected core.QItemSelection_ITF, deselected core.QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QTableView_SelectionChanged(ptr.Pointer(), core.PointerFromQItemSelection(selected), core.PointerFromQItemSelection(deselected))
	}
}

func (ptr *QTableView) SelectionChangedDefault(selected core.QItemSelection_ITF, deselected core.QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QTableView_SelectionChangedDefault(ptr.Pointer(), core.PointerFromQItemSelection(selected), core.PointerFromQItemSelection(deselected))
	}
}

func (ptr *QTableView) SetColumnHidden(column int, hide bool) {
	if ptr.Pointer() != nil {
		C.QTableView_SetColumnHidden(ptr.Pointer(), C.int(int32(column)), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

func (ptr *QTableView) SetColumnWidth(column int, width int) {
	if ptr.Pointer() != nil {
		C.QTableView_SetColumnWidth(ptr.Pointer(), C.int(int32(column)), C.int(int32(width)))
	}
}

func (ptr *QTableView) SetCornerButtonEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QTableView_SetCornerButtonEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QTableView) SetGridStyle(style core.Qt__PenStyle) {
	if ptr.Pointer() != nil {
		C.QTableView_SetGridStyle(ptr.Pointer(), C.longlong(style))
	}
}

func (ptr *QTableView) SetHorizontalHeader(header QHeaderView_ITF) {
	if ptr.Pointer() != nil {
		C.QTableView_SetHorizontalHeader(ptr.Pointer(), PointerFromQHeaderView(header))
	}
}

//export callbackQTableView_SetRootIndex
func callbackQTableView_SetRootIndex(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setRootIndex"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQTableViewFromPointer(ptr).SetRootIndexDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QTableView) ConnectSetRootIndex(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setRootIndex"); signal != nil {
			f := func(index *core.QModelIndex) {
				(*(*func(*core.QModelIndex))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "setRootIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setRootIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectSetRootIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setRootIndex")
	}
}

func (ptr *QTableView) SetRootIndex(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTableView_SetRootIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QTableView) SetRootIndexDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTableView_SetRootIndexDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QTableView) SetRowHeight(row int, height int) {
	if ptr.Pointer() != nil {
		C.QTableView_SetRowHeight(ptr.Pointer(), C.int(int32(row)), C.int(int32(height)))
	}
}

func (ptr *QTableView) SetRowHidden(row int, hide bool) {
	if ptr.Pointer() != nil {
		C.QTableView_SetRowHidden(ptr.Pointer(), C.int(int32(row)), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

//export callbackQTableView_SetSelection
func callbackQTableView_SetSelection(ptr unsafe.Pointer, rect unsafe.Pointer, flags C.longlong) {
	if signal := qt.GetSignal(ptr, "setSelection"); signal != nil {
		(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(flags))
	} else {
		NewQTableViewFromPointer(ptr).SetSelectionDefault(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(flags))
	}
}

func (ptr *QTableView) ConnectSetSelection(f func(rect *core.QRect, flags core.QItemSelectionModel__SelectionFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setSelection"); signal != nil {
			f := func(rect *core.QRect, flags core.QItemSelectionModel__SelectionFlag) {
				(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(rect, flags)
				f(rect, flags)
			}
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectSetSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setSelection")
	}
}

func (ptr *QTableView) SetSelection(rect core.QRect_ITF, flags core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QTableView_SetSelection(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(flags))
	}
}

func (ptr *QTableView) SetSelectionDefault(rect core.QRect_ITF, flags core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QTableView_SetSelectionDefault(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(flags))
	}
}

//export callbackQTableView_SetShowGrid
func callbackQTableView_SetShowGrid(ptr unsafe.Pointer, show C.char) {
	if signal := qt.GetSignal(ptr, "setShowGrid"); signal != nil {
		(*(*func(bool))(signal))(int8(show) != 0)
	} else {
		NewQTableViewFromPointer(ptr).SetShowGridDefault(int8(show) != 0)
	}
}

func (ptr *QTableView) ConnectSetShowGrid(f func(show bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setShowGrid"); signal != nil {
			f := func(show bool) {
				(*(*func(bool))(signal))(show)
				f(show)
			}
			qt.ConnectSignal(ptr.Pointer(), "setShowGrid", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setShowGrid", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectSetShowGrid() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setShowGrid")
	}
}

func (ptr *QTableView) SetShowGrid(show bool) {
	if ptr.Pointer() != nil {
		C.QTableView_SetShowGrid(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(show))))
	}
}

func (ptr *QTableView) SetShowGridDefault(show bool) {
	if ptr.Pointer() != nil {
		C.QTableView_SetShowGridDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(show))))
	}
}

func (ptr *QTableView) SetSortingEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QTableView_SetSortingEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QTableView) SetSpan(row int, column int, rowSpanCount int, columnSpanCount int) {
	if ptr.Pointer() != nil {
		C.QTableView_SetSpan(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), C.int(int32(rowSpanCount)), C.int(int32(columnSpanCount)))
	}
}

func (ptr *QTableView) SetVerticalHeader(header QHeaderView_ITF) {
	if ptr.Pointer() != nil {
		C.QTableView_SetVerticalHeader(ptr.Pointer(), PointerFromQHeaderView(header))
	}
}

func (ptr *QTableView) SetWordWrap(on bool) {
	if ptr.Pointer() != nil {
		C.QTableView_SetWordWrap(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

//export callbackQTableView_ShowColumn
func callbackQTableView_ShowColumn(ptr unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "showColumn"); signal != nil {
		(*(*func(int))(signal))(int(int32(column)))
	} else {
		NewQTableViewFromPointer(ptr).ShowColumnDefault(int(int32(column)))
	}
}

func (ptr *QTableView) ConnectShowColumn(f func(column int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showColumn"); signal != nil {
			f := func(column int) {
				(*(*func(int))(signal))(column)
				f(column)
			}
			qt.ConnectSignal(ptr.Pointer(), "showColumn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showColumn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectShowColumn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showColumn")
	}
}

func (ptr *QTableView) ShowColumn(column int) {
	if ptr.Pointer() != nil {
		C.QTableView_ShowColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTableView) ShowColumnDefault(column int) {
	if ptr.Pointer() != nil {
		C.QTableView_ShowColumnDefault(ptr.Pointer(), C.int(int32(column)))
	}
}

//export callbackQTableView_ShowRow
func callbackQTableView_ShowRow(ptr unsafe.Pointer, row C.int) {
	if signal := qt.GetSignal(ptr, "showRow"); signal != nil {
		(*(*func(int))(signal))(int(int32(row)))
	} else {
		NewQTableViewFromPointer(ptr).ShowRowDefault(int(int32(row)))
	}
}

func (ptr *QTableView) ConnectShowRow(f func(row int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showRow"); signal != nil {
			f := func(row int) {
				(*(*func(int))(signal))(row)
				f(row)
			}
			qt.ConnectSignal(ptr.Pointer(), "showRow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showRow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectShowRow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showRow")
	}
}

func (ptr *QTableView) ShowRow(row int) {
	if ptr.Pointer() != nil {
		C.QTableView_ShowRow(ptr.Pointer(), C.int(int32(row)))
	}
}

func (ptr *QTableView) ShowRowDefault(row int) {
	if ptr.Pointer() != nil {
		C.QTableView_ShowRowDefault(ptr.Pointer(), C.int(int32(row)))
	}
}

func (ptr *QTableView) SortByColumn(column int, order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QTableView_SortByColumn(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
	}
}

//export callbackQTableView_UpdateGeometries
func callbackQTableView_UpdateGeometries(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateGeometries"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTableViewFromPointer(ptr).UpdateGeometriesDefault()
	}
}

func (ptr *QTableView) ConnectUpdateGeometries(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateGeometries"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "updateGeometries", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateGeometries", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectUpdateGeometries() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateGeometries")
	}
}

func (ptr *QTableView) UpdateGeometries() {
	if ptr.Pointer() != nil {
		C.QTableView_UpdateGeometries(ptr.Pointer())
	}
}

func (ptr *QTableView) UpdateGeometriesDefault() {
	if ptr.Pointer() != nil {
		C.QTableView_UpdateGeometriesDefault(ptr.Pointer())
	}
}

//export callbackQTableView_DestroyQTableView
func callbackQTableView_DestroyQTableView(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTableView"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTableViewFromPointer(ptr).DestroyQTableViewDefault()
	}
}

func (ptr *QTableView) ConnectDestroyQTableView(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTableView"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTableView", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTableView", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectDestroyQTableView() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTableView")
	}
}

func (ptr *QTableView) DestroyQTableView() {
	if ptr.Pointer() != nil {
		C.QTableView_DestroyQTableView(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTableView) DestroyQTableViewDefault() {
	if ptr.Pointer() != nil {
		C.QTableView_DestroyQTableViewDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTableView) HorizontalHeader() *QHeaderView {
	if ptr.Pointer() != nil {
		tmpValue := NewQHeaderViewFromPointer(C.QTableView_HorizontalHeader(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTableView) VerticalHeader() *QHeaderView {
	if ptr.Pointer() != nil {
		tmpValue := NewQHeaderViewFromPointer(C.QTableView_VerticalHeader(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQTableView_IndexAt
func callbackQTableView_IndexAt(ptr unsafe.Pointer, pos unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "indexAt"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QPoint) *core.QModelIndex)(signal))(core.NewQPointFromPointer(pos)))
	}

	return core.PointerFromQModelIndex(NewQTableViewFromPointer(ptr).IndexAtDefault(core.NewQPointFromPointer(pos)))
}

func (ptr *QTableView) ConnectIndexAt(f func(pos *core.QPoint) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "indexAt"); signal != nil {
			f := func(pos *core.QPoint) *core.QModelIndex {
				(*(*func(*core.QPoint) *core.QModelIndex)(signal))(pos)
				return f(pos)
			}
			qt.ConnectSignal(ptr.Pointer(), "indexAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "indexAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectIndexAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "indexAt")
	}
}

func (ptr *QTableView) IndexAt(pos core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTableView_IndexAt(ptr.Pointer(), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTableView) IndexAtDefault(pos core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTableView_IndexAtDefault(ptr.Pointer(), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTableView) GridStyle() core.Qt__PenStyle {
	if ptr.Pointer() != nil {
		return core.Qt__PenStyle(C.QTableView_GridStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTableView) IsColumnHidden(column int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableView_IsColumnHidden(ptr.Pointer(), C.int(int32(column)))) != 0
	}
	return false
}

func (ptr *QTableView) IsCornerButtonEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableView_IsCornerButtonEnabled(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQTableView_IsIndexHidden
func callbackQTableView_IsIndexHidden(ptr unsafe.Pointer, index unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isIndexHidden"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex) bool)(signal))(core.NewQModelIndexFromPointer(index)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQTableViewFromPointer(ptr).IsIndexHiddenDefault(core.NewQModelIndexFromPointer(index)))))
}

func (ptr *QTableView) ConnectIsIndexHidden(f func(index *core.QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isIndexHidden"); signal != nil {
			f := func(index *core.QModelIndex) bool {
				(*(*func(*core.QModelIndex) bool)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "isIndexHidden", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isIndexHidden", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectIsIndexHidden() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isIndexHidden")
	}
}

func (ptr *QTableView) IsIndexHidden(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableView_IsIndexHidden(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QTableView) IsIndexHiddenDefault(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableView_IsIndexHiddenDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QTableView) IsRowHidden(row int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableView_IsRowHidden(ptr.Pointer(), C.int(int32(row)))) != 0
	}
	return false
}

func (ptr *QTableView) IsSortingEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableView_IsSortingEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTableView) ShowGrid() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableView_ShowGrid(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTableView) WordWrap() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableView_WordWrap(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTableView) ColumnAt(x int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_ColumnAt(ptr.Pointer(), C.int(int32(x)))))
	}
	return 0
}

func (ptr *QTableView) ColumnSpan(row int, column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_ColumnSpan(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))))
	}
	return 0
}

func (ptr *QTableView) ColumnViewportPosition(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_ColumnViewportPosition(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

func (ptr *QTableView) ColumnWidth(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_ColumnWidth(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

//export callbackQTableView_HorizontalOffset
func callbackQTableView_HorizontalOffset(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "horizontalOffset"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQTableViewFromPointer(ptr).HorizontalOffsetDefault()))
}

func (ptr *QTableView) ConnectHorizontalOffset(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "horizontalOffset"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "horizontalOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "horizontalOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectHorizontalOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "horizontalOffset")
	}
}

func (ptr *QTableView) HorizontalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_HorizontalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableView) HorizontalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_HorizontalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableView) RowAt(y int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_RowAt(ptr.Pointer(), C.int(int32(y)))))
	}
	return 0
}

func (ptr *QTableView) RowHeight(row int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_RowHeight(ptr.Pointer(), C.int(int32(row)))))
	}
	return 0
}

func (ptr *QTableView) RowSpan(row int, column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_RowSpan(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))))
	}
	return 0
}

func (ptr *QTableView) RowViewportPosition(row int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_RowViewportPosition(ptr.Pointer(), C.int(int32(row)))))
	}
	return 0
}

//export callbackQTableView_VerticalOffset
func callbackQTableView_VerticalOffset(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "verticalOffset"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQTableViewFromPointer(ptr).VerticalOffsetDefault()))
}

func (ptr *QTableView) ConnectVerticalOffset(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "verticalOffset"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "verticalOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "verticalOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableView) DisconnectVerticalOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "verticalOffset")
	}
}

func (ptr *QTableView) VerticalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_VerticalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableView) VerticalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableView_VerticalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

//export callbackQTableView_ScrollTo
func callbackQTableView_ScrollTo(ptr unsafe.Pointer, index unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "scrollTo"); signal != nil {
		(*(*func(*core.QModelIndex, QAbstractItemView__ScrollHint))(signal))(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	} else {
		NewQTableViewFromPointer(ptr).ScrollToDefault(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	}
}

func (ptr *QTableView) ScrollTo(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QTableView_ScrollTo(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

func (ptr *QTableView) ScrollToDefault(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QTableView_ScrollToDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

//export callbackQTableView_VisualRect
func callbackQTableView_VisualRect(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRect"); signal != nil {
		return core.PointerFromQRect((*(*func(*core.QModelIndex) *core.QRect)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQRect(NewQTableViewFromPointer(ptr).VisualRectDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QTableView) VisualRect(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QTableView_VisualRect(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QTableView) VisualRectDefault(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QTableView_VisualRectDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQTableView_VisualRegionForSelection
func callbackQTableView_VisualRegionForSelection(ptr unsafe.Pointer, selection unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRegionForSelection"); signal != nil {
		return gui.PointerFromQRegion((*(*func(*core.QItemSelection) *gui.QRegion)(signal))(core.NewQItemSelectionFromPointer(selection)))
	}

	return gui.PointerFromQRegion(NewQTableViewFromPointer(ptr).VisualRegionForSelectionDefault(core.NewQItemSelectionFromPointer(selection)))
}

func (ptr *QTableView) VisualRegionForSelection(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QTableView_VisualRegionForSelection(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QTableView) VisualRegionForSelectionDefault(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QTableView_VisualRegionForSelectionDefault(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

type QTableWidget struct {
	QTableView
}

type QTableWidget_ITF interface {
	QTableView_ITF
	QTableWidget_PTR() *QTableWidget
}

func (ptr *QTableWidget) QTableWidget_PTR() *QTableWidget {
	return ptr
}

func (ptr *QTableWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QTableView_PTR().Pointer()
	}
	return nil
}

func (ptr *QTableWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QTableView_PTR().SetPointer(p)
	}
}

func PointerFromQTableWidget(ptr QTableWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTableWidget_PTR().Pointer()
	}
	return nil
}

func NewQTableWidgetFromPointer(ptr unsafe.Pointer) (n *QTableWidget) {
	n = new(QTableWidget)
	n.SetPointer(ptr)
	return
}
func NewQTableWidget(parent QWidget_ITF) *QTableWidget {
	tmpValue := NewQTableWidgetFromPointer(C.QTableWidget_NewQTableWidget(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQTableWidget2(rows int, columns int, parent QWidget_ITF) *QTableWidget {
	tmpValue := NewQTableWidgetFromPointer(C.QTableWidget_NewQTableWidget2(C.int(int32(rows)), C.int(int32(columns)), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTableWidget) TakeHorizontalHeaderItem(column int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_TakeHorizontalHeaderItem(ptr.Pointer(), C.int(int32(column))))
	}
	return nil
}

func (ptr *QTableWidget) TakeItem(row int, column int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_TakeItem(ptr.Pointer(), C.int(int32(row)), C.int(int32(column))))
	}
	return nil
}

func (ptr *QTableWidget) TakeVerticalHeaderItem(row int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_TakeVerticalHeaderItem(ptr.Pointer(), C.int(int32(row))))
	}
	return nil
}

//export callbackQTableWidget_DropMimeData
func callbackQTableWidget_DropMimeData(ptr unsafe.Pointer, row C.int, column C.int, data unsafe.Pointer, action C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "dropMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(int, int, *core.QMimeData, core.Qt__DropAction) bool)(signal))(int(int32(row)), int(int32(column)), core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQTableWidgetFromPointer(ptr).DropMimeDataDefault(int(int32(row)), int(int32(column)), core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action)))))
}

func (ptr *QTableWidget) ConnectDropMimeData(f func(row int, column int, data *core.QMimeData, action core.Qt__DropAction) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dropMimeData"); signal != nil {
			f := func(row int, column int, data *core.QMimeData, action core.Qt__DropAction) bool {
				(*(*func(int, int, *core.QMimeData, core.Qt__DropAction) bool)(signal))(row, column, data, action)
				return f(row, column, data, action)
			}
			qt.ConnectSignal(ptr.Pointer(), "dropMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dropMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectDropMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dropMimeData")
	}
}

func (ptr *QTableWidget) DropMimeData(row int, column int, data core.QMimeData_ITF, action core.Qt__DropAction) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableWidget_DropMimeData(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), core.PointerFromQMimeData(data), C.longlong(action))) != 0
	}
	return false
}

func (ptr *QTableWidget) DropMimeDataDefault(row int, column int, data core.QMimeData_ITF, action core.Qt__DropAction) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableWidget_DropMimeDataDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), core.PointerFromQMimeData(data), C.longlong(action))) != 0
	}
	return false
}

//export callbackQTableWidget_CellActivated
func callbackQTableWidget_CellActivated(ptr unsafe.Pointer, row C.int, column C.int) {
	if signal := qt.GetSignal(ptr, "cellActivated"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(row)), int(int32(column)))
	}

}

func (ptr *QTableWidget) ConnectCellActivated(f func(row int, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cellActivated") {
			C.QTableWidget_ConnectCellActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cellActivated"); signal != nil {
			f := func(row int, column int) {
				(*(*func(int, int))(signal))(row, column)
				f(row, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "cellActivated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cellActivated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectCellActivated() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectCellActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cellActivated")
	}
}

func (ptr *QTableWidget) CellActivated(row int, column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_CellActivated(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))
	}
}

//export callbackQTableWidget_CellChanged
func callbackQTableWidget_CellChanged(ptr unsafe.Pointer, row C.int, column C.int) {
	if signal := qt.GetSignal(ptr, "cellChanged"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(row)), int(int32(column)))
	}

}

func (ptr *QTableWidget) ConnectCellChanged(f func(row int, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cellChanged") {
			C.QTableWidget_ConnectCellChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cellChanged"); signal != nil {
			f := func(row int, column int) {
				(*(*func(int, int))(signal))(row, column)
				f(row, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "cellChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cellChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectCellChanged() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectCellChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cellChanged")
	}
}

func (ptr *QTableWidget) CellChanged(row int, column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_CellChanged(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))
	}
}

//export callbackQTableWidget_CellClicked
func callbackQTableWidget_CellClicked(ptr unsafe.Pointer, row C.int, column C.int) {
	if signal := qt.GetSignal(ptr, "cellClicked"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(row)), int(int32(column)))
	}

}

func (ptr *QTableWidget) ConnectCellClicked(f func(row int, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cellClicked") {
			C.QTableWidget_ConnectCellClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cellClicked"); signal != nil {
			f := func(row int, column int) {
				(*(*func(int, int))(signal))(row, column)
				f(row, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "cellClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cellClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectCellClicked() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectCellClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cellClicked")
	}
}

func (ptr *QTableWidget) CellClicked(row int, column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_CellClicked(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))
	}
}

//export callbackQTableWidget_CellDoubleClicked
func callbackQTableWidget_CellDoubleClicked(ptr unsafe.Pointer, row C.int, column C.int) {
	if signal := qt.GetSignal(ptr, "cellDoubleClicked"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(row)), int(int32(column)))
	}

}

func (ptr *QTableWidget) ConnectCellDoubleClicked(f func(row int, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cellDoubleClicked") {
			C.QTableWidget_ConnectCellDoubleClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cellDoubleClicked"); signal != nil {
			f := func(row int, column int) {
				(*(*func(int, int))(signal))(row, column)
				f(row, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "cellDoubleClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cellDoubleClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectCellDoubleClicked() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectCellDoubleClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cellDoubleClicked")
	}
}

func (ptr *QTableWidget) CellDoubleClicked(row int, column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_CellDoubleClicked(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))
	}
}

//export callbackQTableWidget_CellEntered
func callbackQTableWidget_CellEntered(ptr unsafe.Pointer, row C.int, column C.int) {
	if signal := qt.GetSignal(ptr, "cellEntered"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(row)), int(int32(column)))
	}

}

func (ptr *QTableWidget) ConnectCellEntered(f func(row int, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cellEntered") {
			C.QTableWidget_ConnectCellEntered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cellEntered"); signal != nil {
			f := func(row int, column int) {
				(*(*func(int, int))(signal))(row, column)
				f(row, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "cellEntered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cellEntered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectCellEntered() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectCellEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cellEntered")
	}
}

func (ptr *QTableWidget) CellEntered(row int, column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_CellEntered(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))
	}
}

//export callbackQTableWidget_CellPressed
func callbackQTableWidget_CellPressed(ptr unsafe.Pointer, row C.int, column C.int) {
	if signal := qt.GetSignal(ptr, "cellPressed"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(row)), int(int32(column)))
	}

}

func (ptr *QTableWidget) ConnectCellPressed(f func(row int, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cellPressed") {
			C.QTableWidget_ConnectCellPressed(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cellPressed"); signal != nil {
			f := func(row int, column int) {
				(*(*func(int, int))(signal))(row, column)
				f(row, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "cellPressed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cellPressed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectCellPressed() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectCellPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cellPressed")
	}
}

func (ptr *QTableWidget) CellPressed(row int, column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_CellPressed(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))
	}
}

//export callbackQTableWidget_Clear
func callbackQTableWidget_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTableWidgetFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QTableWidget) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QTableWidget) Clear() {
	if ptr.Pointer() != nil {
		C.QTableWidget_Clear(ptr.Pointer())
	}
}

func (ptr *QTableWidget) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QTableWidget_ClearDefault(ptr.Pointer())
	}
}

//export callbackQTableWidget_ClearContents
func callbackQTableWidget_ClearContents(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clearContents"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTableWidgetFromPointer(ptr).ClearContentsDefault()
	}
}

func (ptr *QTableWidget) ConnectClearContents(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clearContents"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clearContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clearContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectClearContents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clearContents")
	}
}

func (ptr *QTableWidget) ClearContents() {
	if ptr.Pointer() != nil {
		C.QTableWidget_ClearContents(ptr.Pointer())
	}
}

func (ptr *QTableWidget) ClearContentsDefault() {
	if ptr.Pointer() != nil {
		C.QTableWidget_ClearContentsDefault(ptr.Pointer())
	}
}

func (ptr *QTableWidget) ClosePersistentEditor(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_ClosePersistentEditor(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

//export callbackQTableWidget_CurrentCellChanged
func callbackQTableWidget_CurrentCellChanged(ptr unsafe.Pointer, currentRow C.int, currentColumn C.int, previousRow C.int, previousColumn C.int) {
	if signal := qt.GetSignal(ptr, "currentCellChanged"); signal != nil {
		(*(*func(int, int, int, int))(signal))(int(int32(currentRow)), int(int32(currentColumn)), int(int32(previousRow)), int(int32(previousColumn)))
	}

}

func (ptr *QTableWidget) ConnectCurrentCellChanged(f func(currentRow int, currentColumn int, previousRow int, previousColumn int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentCellChanged") {
			C.QTableWidget_ConnectCurrentCellChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentCellChanged"); signal != nil {
			f := func(currentRow int, currentColumn int, previousRow int, previousColumn int) {
				(*(*func(int, int, int, int))(signal))(currentRow, currentColumn, previousRow, previousColumn)
				f(currentRow, currentColumn, previousRow, previousColumn)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentCellChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentCellChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectCurrentCellChanged() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectCurrentCellChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentCellChanged")
	}
}

func (ptr *QTableWidget) CurrentCellChanged(currentRow int, currentColumn int, previousRow int, previousColumn int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_CurrentCellChanged(ptr.Pointer(), C.int(int32(currentRow)), C.int(int32(currentColumn)), C.int(int32(previousRow)), C.int(int32(previousColumn)))
	}
}

//export callbackQTableWidget_CurrentItemChanged
func callbackQTableWidget_CurrentItemChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentItemChanged"); signal != nil {
		(*(*func(*QTableWidgetItem, *QTableWidgetItem))(signal))(NewQTableWidgetItemFromPointer(current), NewQTableWidgetItemFromPointer(previous))
	}

}

func (ptr *QTableWidget) ConnectCurrentItemChanged(f func(current *QTableWidgetItem, previous *QTableWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentItemChanged") {
			C.QTableWidget_ConnectCurrentItemChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentItemChanged"); signal != nil {
			f := func(current *QTableWidgetItem, previous *QTableWidgetItem) {
				(*(*func(*QTableWidgetItem, *QTableWidgetItem))(signal))(current, previous)
				f(current, previous)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentItemChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentItemChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectCurrentItemChanged() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectCurrentItemChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentItemChanged")
	}
}

func (ptr *QTableWidget) CurrentItemChanged(current QTableWidgetItem_ITF, previous QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_CurrentItemChanged(ptr.Pointer(), PointerFromQTableWidgetItem(current), PointerFromQTableWidgetItem(previous))
	}
}

func (ptr *QTableWidget) EditItem(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_EditItem(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

//export callbackQTableWidget_InsertColumn
func callbackQTableWidget_InsertColumn(ptr unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "insertColumn"); signal != nil {
		(*(*func(int))(signal))(int(int32(column)))
	} else {
		NewQTableWidgetFromPointer(ptr).InsertColumnDefault(int(int32(column)))
	}
}

func (ptr *QTableWidget) ConnectInsertColumn(f func(column int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "insertColumn"); signal != nil {
			f := func(column int) {
				(*(*func(int))(signal))(column)
				f(column)
			}
			qt.ConnectSignal(ptr.Pointer(), "insertColumn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "insertColumn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectInsertColumn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "insertColumn")
	}
}

func (ptr *QTableWidget) InsertColumn(column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_InsertColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTableWidget) InsertColumnDefault(column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_InsertColumnDefault(ptr.Pointer(), C.int(int32(column)))
	}
}

//export callbackQTableWidget_InsertRow
func callbackQTableWidget_InsertRow(ptr unsafe.Pointer, row C.int) {
	if signal := qt.GetSignal(ptr, "insertRow"); signal != nil {
		(*(*func(int))(signal))(int(int32(row)))
	} else {
		NewQTableWidgetFromPointer(ptr).InsertRowDefault(int(int32(row)))
	}
}

func (ptr *QTableWidget) ConnectInsertRow(f func(row int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "insertRow"); signal != nil {
			f := func(row int) {
				(*(*func(int))(signal))(row)
				f(row)
			}
			qt.ConnectSignal(ptr.Pointer(), "insertRow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "insertRow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectInsertRow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "insertRow")
	}
}

func (ptr *QTableWidget) InsertRow(row int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_InsertRow(ptr.Pointer(), C.int(int32(row)))
	}
}

func (ptr *QTableWidget) InsertRowDefault(row int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_InsertRowDefault(ptr.Pointer(), C.int(int32(row)))
	}
}

//export callbackQTableWidget_ItemActivated
func callbackQTableWidget_ItemActivated(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemActivated"); signal != nil {
		(*(*func(*QTableWidgetItem))(signal))(NewQTableWidgetItemFromPointer(item))
	}

}

func (ptr *QTableWidget) ConnectItemActivated(f func(item *QTableWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemActivated") {
			C.QTableWidget_ConnectItemActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemActivated"); signal != nil {
			f := func(item *QTableWidgetItem) {
				(*(*func(*QTableWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemActivated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemActivated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectItemActivated() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectItemActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemActivated")
	}
}

func (ptr *QTableWidget) ItemActivated(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_ItemActivated(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

//export callbackQTableWidget_ItemChanged
func callbackQTableWidget_ItemChanged(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemChanged"); signal != nil {
		(*(*func(*QTableWidgetItem))(signal))(NewQTableWidgetItemFromPointer(item))
	}

}

func (ptr *QTableWidget) ConnectItemChanged(f func(item *QTableWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemChanged") {
			C.QTableWidget_ConnectItemChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemChanged"); signal != nil {
			f := func(item *QTableWidgetItem) {
				(*(*func(*QTableWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectItemChanged() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectItemChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemChanged")
	}
}

func (ptr *QTableWidget) ItemChanged(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_ItemChanged(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

//export callbackQTableWidget_ItemClicked
func callbackQTableWidget_ItemClicked(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemClicked"); signal != nil {
		(*(*func(*QTableWidgetItem))(signal))(NewQTableWidgetItemFromPointer(item))
	}

}

func (ptr *QTableWidget) ConnectItemClicked(f func(item *QTableWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemClicked") {
			C.QTableWidget_ConnectItemClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemClicked"); signal != nil {
			f := func(item *QTableWidgetItem) {
				(*(*func(*QTableWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectItemClicked() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectItemClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemClicked")
	}
}

func (ptr *QTableWidget) ItemClicked(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_ItemClicked(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

//export callbackQTableWidget_ItemDoubleClicked
func callbackQTableWidget_ItemDoubleClicked(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemDoubleClicked"); signal != nil {
		(*(*func(*QTableWidgetItem))(signal))(NewQTableWidgetItemFromPointer(item))
	}

}

func (ptr *QTableWidget) ConnectItemDoubleClicked(f func(item *QTableWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemDoubleClicked") {
			C.QTableWidget_ConnectItemDoubleClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemDoubleClicked"); signal != nil {
			f := func(item *QTableWidgetItem) {
				(*(*func(*QTableWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemDoubleClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemDoubleClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectItemDoubleClicked() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectItemDoubleClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemDoubleClicked")
	}
}

func (ptr *QTableWidget) ItemDoubleClicked(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_ItemDoubleClicked(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

//export callbackQTableWidget_ItemEntered
func callbackQTableWidget_ItemEntered(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemEntered"); signal != nil {
		(*(*func(*QTableWidgetItem))(signal))(NewQTableWidgetItemFromPointer(item))
	}

}

func (ptr *QTableWidget) ConnectItemEntered(f func(item *QTableWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemEntered") {
			C.QTableWidget_ConnectItemEntered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemEntered"); signal != nil {
			f := func(item *QTableWidgetItem) {
				(*(*func(*QTableWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemEntered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemEntered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectItemEntered() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectItemEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemEntered")
	}
}

func (ptr *QTableWidget) ItemEntered(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_ItemEntered(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

//export callbackQTableWidget_ItemPressed
func callbackQTableWidget_ItemPressed(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemPressed"); signal != nil {
		(*(*func(*QTableWidgetItem))(signal))(NewQTableWidgetItemFromPointer(item))
	}

}

func (ptr *QTableWidget) ConnectItemPressed(f func(item *QTableWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemPressed") {
			C.QTableWidget_ConnectItemPressed(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemPressed"); signal != nil {
			f := func(item *QTableWidgetItem) {
				(*(*func(*QTableWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemPressed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemPressed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectItemPressed() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectItemPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemPressed")
	}
}

func (ptr *QTableWidget) ItemPressed(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_ItemPressed(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

//export callbackQTableWidget_ItemSelectionChanged
func callbackQTableWidget_ItemSelectionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemSelectionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QTableWidget) ConnectItemSelectionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemSelectionChanged") {
			C.QTableWidget_ConnectItemSelectionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemSelectionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "itemSelectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemSelectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectItemSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DisconnectItemSelectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemSelectionChanged")
	}
}

func (ptr *QTableWidget) ItemSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QTableWidget_ItemSelectionChanged(ptr.Pointer())
	}
}

func (ptr *QTableWidget) OpenPersistentEditor(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_OpenPersistentEditor(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

func (ptr *QTableWidget) RemoveCellWidget(row int, column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_RemoveCellWidget(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))
	}
}

//export callbackQTableWidget_RemoveColumn
func callbackQTableWidget_RemoveColumn(ptr unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "removeColumn"); signal != nil {
		(*(*func(int))(signal))(int(int32(column)))
	} else {
		NewQTableWidgetFromPointer(ptr).RemoveColumnDefault(int(int32(column)))
	}
}

func (ptr *QTableWidget) ConnectRemoveColumn(f func(column int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "removeColumn"); signal != nil {
			f := func(column int) {
				(*(*func(int))(signal))(column)
				f(column)
			}
			qt.ConnectSignal(ptr.Pointer(), "removeColumn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "removeColumn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectRemoveColumn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "removeColumn")
	}
}

func (ptr *QTableWidget) RemoveColumn(column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_RemoveColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTableWidget) RemoveColumnDefault(column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_RemoveColumnDefault(ptr.Pointer(), C.int(int32(column)))
	}
}

//export callbackQTableWidget_RemoveRow
func callbackQTableWidget_RemoveRow(ptr unsafe.Pointer, row C.int) {
	if signal := qt.GetSignal(ptr, "removeRow"); signal != nil {
		(*(*func(int))(signal))(int(int32(row)))
	} else {
		NewQTableWidgetFromPointer(ptr).RemoveRowDefault(int(int32(row)))
	}
}

func (ptr *QTableWidget) ConnectRemoveRow(f func(row int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "removeRow"); signal != nil {
			f := func(row int) {
				(*(*func(int))(signal))(row)
				f(row)
			}
			qt.ConnectSignal(ptr.Pointer(), "removeRow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "removeRow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectRemoveRow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "removeRow")
	}
}

func (ptr *QTableWidget) RemoveRow(row int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_RemoveRow(ptr.Pointer(), C.int(int32(row)))
	}
}

func (ptr *QTableWidget) RemoveRowDefault(row int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_RemoveRowDefault(ptr.Pointer(), C.int(int32(row)))
	}
}

//export callbackQTableWidget_ScrollToItem
func callbackQTableWidget_ScrollToItem(ptr unsafe.Pointer, item unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "scrollToItem"); signal != nil {
		(*(*func(*QTableWidgetItem, QAbstractItemView__ScrollHint))(signal))(NewQTableWidgetItemFromPointer(item), QAbstractItemView__ScrollHint(hint))
	} else {
		NewQTableWidgetFromPointer(ptr).ScrollToItemDefault(NewQTableWidgetItemFromPointer(item), QAbstractItemView__ScrollHint(hint))
	}
}

func (ptr *QTableWidget) ConnectScrollToItem(f func(item *QTableWidgetItem, hint QAbstractItemView__ScrollHint)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "scrollToItem"); signal != nil {
			f := func(item *QTableWidgetItem, hint QAbstractItemView__ScrollHint) {
				(*(*func(*QTableWidgetItem, QAbstractItemView__ScrollHint))(signal))(item, hint)
				f(item, hint)
			}
			qt.ConnectSignal(ptr.Pointer(), "scrollToItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scrollToItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectScrollToItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "scrollToItem")
	}
}

func (ptr *QTableWidget) ScrollToItem(item QTableWidgetItem_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QTableWidget_ScrollToItem(ptr.Pointer(), PointerFromQTableWidgetItem(item), C.longlong(hint))
	}
}

func (ptr *QTableWidget) ScrollToItemDefault(item QTableWidgetItem_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QTableWidget_ScrollToItemDefault(ptr.Pointer(), PointerFromQTableWidgetItem(item), C.longlong(hint))
	}
}

func (ptr *QTableWidget) SetCellWidget(row int, column int, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetCellWidget(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQWidget(widget))
	}
}

func (ptr *QTableWidget) SetColumnCount(columns int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetColumnCount(ptr.Pointer(), C.int(int32(columns)))
	}
}

func (ptr *QTableWidget) SetCurrentCell(row int, column int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetCurrentCell(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)))
	}
}

func (ptr *QTableWidget) SetCurrentCell2(row int, column int, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetCurrentCell2(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), C.longlong(command))
	}
}

func (ptr *QTableWidget) SetCurrentItem(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetCurrentItem(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

func (ptr *QTableWidget) SetCurrentItem2(item QTableWidgetItem_ITF, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetCurrentItem2(ptr.Pointer(), PointerFromQTableWidgetItem(item), C.longlong(command))
	}
}

func (ptr *QTableWidget) SetHorizontalHeaderItem(column int, item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetHorizontalHeaderItem(ptr.Pointer(), C.int(int32(column)), PointerFromQTableWidgetItem(item))
	}
}

func (ptr *QTableWidget) SetHorizontalHeaderLabels(labels []string) {
	if ptr.Pointer() != nil {
		labelsC := C.CString(strings.Join(labels, "|"))
		defer C.free(unsafe.Pointer(labelsC))
		C.QTableWidget_SetHorizontalHeaderLabels(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: labelsC, len: C.longlong(len(strings.Join(labels, "|")))})
	}
}

func (ptr *QTableWidget) SetItem(row int, column int, item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetItem(ptr.Pointer(), C.int(int32(row)), C.int(int32(column)), PointerFromQTableWidgetItem(item))
	}
}

func (ptr *QTableWidget) SetItemPrototype(item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetItemPrototype(ptr.Pointer(), PointerFromQTableWidgetItem(item))
	}
}

func (ptr *QTableWidget) SetRangeSelected(ran QTableWidgetSelectionRange_ITF, sele bool) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetRangeSelected(ptr.Pointer(), PointerFromQTableWidgetSelectionRange(ran), C.char(int8(qt.GoBoolToInt(sele))))
	}
}

func (ptr *QTableWidget) SetRowCount(rows int) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetRowCount(ptr.Pointer(), C.int(int32(rows)))
	}
}

func (ptr *QTableWidget) SetVerticalHeaderItem(row int, item QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SetVerticalHeaderItem(ptr.Pointer(), C.int(int32(row)), PointerFromQTableWidgetItem(item))
	}
}

func (ptr *QTableWidget) SetVerticalHeaderLabels(labels []string) {
	if ptr.Pointer() != nil {
		labelsC := C.CString(strings.Join(labels, "|"))
		defer C.free(unsafe.Pointer(labelsC))
		C.QTableWidget_SetVerticalHeaderLabels(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: labelsC, len: C.longlong(len(strings.Join(labels, "|")))})
	}
}

func (ptr *QTableWidget) SortItems(column int, order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QTableWidget_SortItems(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
	}
}

//export callbackQTableWidget_DestroyQTableWidget
func callbackQTableWidget_DestroyQTableWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTableWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTableWidgetFromPointer(ptr).DestroyQTableWidgetDefault()
	}
}

func (ptr *QTableWidget) ConnectDestroyQTableWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTableWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTableWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTableWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectDestroyQTableWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTableWidget")
	}
}

func (ptr *QTableWidget) DestroyQTableWidget() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DestroyQTableWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTableWidget) DestroyQTableWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QTableWidget_DestroyQTableWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTableWidget) FindItems(text string, flags core.Qt__MatchFlag) []*QTableWidgetItem {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return func(l C.struct_QtWidgets_PackedList) []*QTableWidgetItem {
			out := make([]*QTableWidgetItem, int(l.len))
			tmpList := NewQTableWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__findItems_atList(i)
			}
			return out
		}(C.QTableWidget_FindItems(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(flags)))
	}
	return make([]*QTableWidgetItem, 0)
}

func (ptr *QTableWidget) Items(data core.QMimeData_ITF) []*QTableWidgetItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QTableWidgetItem {
			out := make([]*QTableWidgetItem, int(l.len))
			tmpList := NewQTableWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__items_atList(i)
			}
			return out
		}(C.QTableWidget_Items(ptr.Pointer(), core.PointerFromQMimeData(data)))
	}
	return make([]*QTableWidgetItem, 0)
}

func (ptr *QTableWidget) SelectedItems() []*QTableWidgetItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QTableWidgetItem {
			out := make([]*QTableWidgetItem, int(l.len))
			tmpList := NewQTableWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedItems_atList(i)
			}
			return out
		}(C.QTableWidget_SelectedItems(ptr.Pointer()))
	}
	return make([]*QTableWidgetItem, 0)
}

func (ptr *QTableWidget) SelectedRanges() []*QTableWidgetSelectionRange {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QTableWidgetSelectionRange {
			out := make([]*QTableWidgetSelectionRange, int(l.len))
			tmpList := NewQTableWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedRanges_atList(i)
			}
			return out
		}(C.QTableWidget_SelectedRanges(ptr.Pointer()))
	}
	return make([]*QTableWidgetSelectionRange, 0)
}

//export callbackQTableWidget_MimeData
func callbackQTableWidget_MimeData(ptr unsafe.Pointer, items C.struct_QtWidgets_PackedList) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mimeData"); signal != nil {
		return core.PointerFromQMimeData((*(*func([]*QTableWidgetItem) *core.QMimeData)(signal))(func(l C.struct_QtWidgets_PackedList) []*QTableWidgetItem {
			out := make([]*QTableWidgetItem, int(l.len))
			tmpList := NewQTableWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__mimeData_items_atList(i)
			}
			return out
		}(items)))
	}

	return core.PointerFromQMimeData(NewQTableWidgetFromPointer(ptr).MimeDataDefault(func(l C.struct_QtWidgets_PackedList) []*QTableWidgetItem {
		out := make([]*QTableWidgetItem, int(l.len))
		tmpList := NewQTableWidgetFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__mimeData_items_atList(i)
		}
		return out
	}(items)))
}

func (ptr *QTableWidget) ConnectMimeData(f func(items []*QTableWidgetItem) *core.QMimeData) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mimeData"); signal != nil {
			f := func(items []*QTableWidgetItem) *core.QMimeData {
				(*(*func([]*QTableWidgetItem) *core.QMimeData)(signal))(items)
				return f(items)
			}
			qt.ConnectSignal(ptr.Pointer(), "mimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mimeData")
	}
}

func (ptr *QTableWidget) MimeData(items []*QTableWidgetItem) *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QTableWidget_MimeData(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQTableWidgetFromPointer(NewQTableWidgetFromPointer(nil).__mimeData_items_newList())
			for _, v := range items {
				tmpList.__mimeData_items_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidget) MimeDataDefault(items []*QTableWidgetItem) *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QTableWidget_MimeDataDefault(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQTableWidgetFromPointer(NewQTableWidgetFromPointer(nil).__mimeData_items_newList())
			for _, v := range items {
				tmpList.__mimeData_items_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidget) IndexFromItem(item QTableWidgetItem_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTableWidget_IndexFromItem(ptr.Pointer(), PointerFromQTableWidgetItem(item)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidget) VisualItemRect(item QTableWidgetItem_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QTableWidget_VisualItemRect(ptr.Pointer(), PointerFromQTableWidgetItem(item)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQTableWidget_MimeTypes
func callbackQTableWidget_MimeTypes(ptr unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "mimeTypes"); signal != nil {
		tempVal := (*(*func() []string)(signal))()
		return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
	}
	tempVal := NewQTableWidgetFromPointer(ptr).MimeTypesDefault()
	return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
}

func (ptr *QTableWidget) ConnectMimeTypes(f func() []string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mimeTypes"); signal != nil {
			f := func() []string {
				(*(*func() []string)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "mimeTypes", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mimeTypes", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectMimeTypes() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mimeTypes")
	}
}

func (ptr *QTableWidget) MimeTypes() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QTableWidget_MimeTypes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QTableWidget) MimeTypesDefault() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QTableWidget_MimeTypesDefault(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QTableWidget) CurrentItem() *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_CurrentItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTableWidget) HorizontalHeaderItem(column int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_HorizontalHeaderItem(ptr.Pointer(), C.int(int32(column))))
	}
	return nil
}

func (ptr *QTableWidget) Item(row int, column int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_Item(ptr.Pointer(), C.int(int32(row)), C.int(int32(column))))
	}
	return nil
}

func (ptr *QTableWidget) ItemAt(point core.QPoint_ITF) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_ItemAt(ptr.Pointer(), core.PointerFromQPoint(point)))
	}
	return nil
}

func (ptr *QTableWidget) ItemAt2(ax int, ay int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_ItemAt2(ptr.Pointer(), C.int(int32(ax)), C.int(int32(ay))))
	}
	return nil
}

func (ptr *QTableWidget) ItemFromIndex(index core.QModelIndex_ITF) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_ItemFromIndex(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return nil
}

func (ptr *QTableWidget) VerticalHeaderItem(row int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_VerticalHeaderItem(ptr.Pointer(), C.int(int32(row))))
	}
	return nil
}

func (ptr *QTableWidget) CellWidget(row int, column int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QTableWidget_CellWidget(ptr.Pointer(), C.int(int32(row)), C.int(int32(column))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQTableWidget_SupportedDropActions
func callbackQTableWidget_SupportedDropActions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "supportedDropActions"); signal != nil {
		return C.longlong((*(*func() core.Qt__DropAction)(signal))())
	}

	return C.longlong(NewQTableWidgetFromPointer(ptr).SupportedDropActionsDefault())
}

func (ptr *QTableWidget) ConnectSupportedDropActions(f func() core.Qt__DropAction) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "supportedDropActions"); signal != nil {
			f := func() core.Qt__DropAction {
				(*(*func() core.Qt__DropAction)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "supportedDropActions", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "supportedDropActions", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidget) DisconnectSupportedDropActions() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "supportedDropActions")
	}
}

func (ptr *QTableWidget) SupportedDropActions() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QTableWidget_SupportedDropActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTableWidget) SupportedDropActionsDefault() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QTableWidget_SupportedDropActionsDefault(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTableWidget) IsPersistentEditorOpen(item QTableWidgetItem_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableWidget_IsPersistentEditorOpen(ptr.Pointer(), PointerFromQTableWidgetItem(item))) != 0
	}
	return false
}

func (ptr *QTableWidget) ItemPrototype() *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget_ItemPrototype(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTableWidget) Column(item QTableWidgetItem_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidget_Column(ptr.Pointer(), PointerFromQTableWidgetItem(item))))
	}
	return 0
}

func (ptr *QTableWidget) ColumnCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidget_ColumnCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidget) CurrentColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidget_CurrentColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidget) CurrentRow() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidget_CurrentRow(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidget) Row(item QTableWidgetItem_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidget_Row(ptr.Pointer(), PointerFromQTableWidgetItem(item))))
	}
	return 0
}

func (ptr *QTableWidget) RowCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidget_RowCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidget) VisualColumn(logicalColumn int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidget_VisualColumn(ptr.Pointer(), C.int(int32(logicalColumn)))))
	}
	return 0
}

func (ptr *QTableWidget) VisualRow(logicalRow int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidget_VisualRow(ptr.Pointer(), C.int(int32(logicalRow)))))
	}
	return 0
}

func (ptr *QTableWidget) __findItems_atList(i int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget___findItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTableWidget) __findItems_setList(i QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget___findItems_setList(ptr.Pointer(), PointerFromQTableWidgetItem(i))
	}
}

func (ptr *QTableWidget) __findItems_newList() unsafe.Pointer {
	return C.QTableWidget___findItems_newList(ptr.Pointer())
}

func (ptr *QTableWidget) __items_atList(i int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget___items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTableWidget) __items_setList(i QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget___items_setList(ptr.Pointer(), PointerFromQTableWidgetItem(i))
	}
}

func (ptr *QTableWidget) __items_newList() unsafe.Pointer {
	return C.QTableWidget___items_newList(ptr.Pointer())
}

func (ptr *QTableWidget) __selectedItems_atList(i int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget___selectedItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTableWidget) __selectedItems_setList(i QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget___selectedItems_setList(ptr.Pointer(), PointerFromQTableWidgetItem(i))
	}
}

func (ptr *QTableWidget) __selectedItems_newList() unsafe.Pointer {
	return C.QTableWidget___selectedItems_newList(ptr.Pointer())
}

func (ptr *QTableWidget) __selectedRanges_atList(i int) *QTableWidgetSelectionRange {
	if ptr.Pointer() != nil {
		tmpValue := NewQTableWidgetSelectionRangeFromPointer(C.QTableWidget___selectedRanges_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*QTableWidgetSelectionRange).DestroyQTableWidgetSelectionRange)
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidget) __selectedRanges_setList(i QTableWidgetSelectionRange_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget___selectedRanges_setList(ptr.Pointer(), PointerFromQTableWidgetSelectionRange(i))
	}
}

func (ptr *QTableWidget) __selectedRanges_newList() unsafe.Pointer {
	return C.QTableWidget___selectedRanges_newList(ptr.Pointer())
}

func (ptr *QTableWidget) __mimeData_items_atList(i int) *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidget___mimeData_items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTableWidget) __mimeData_items_setList(i QTableWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidget___mimeData_items_setList(ptr.Pointer(), PointerFromQTableWidgetItem(i))
	}
}

func (ptr *QTableWidget) __mimeData_items_newList() unsafe.Pointer {
	return C.QTableWidget___mimeData_items_newList(ptr.Pointer())
}

type QTableWidgetItem struct {
	ptr unsafe.Pointer
}

type QTableWidgetItem_ITF interface {
	QTableWidgetItem_PTR() *QTableWidgetItem
}

func (ptr *QTableWidgetItem) QTableWidgetItem_PTR() *QTableWidgetItem {
	return ptr
}

func (ptr *QTableWidgetItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QTableWidgetItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQTableWidgetItem(ptr QTableWidgetItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTableWidgetItem_PTR().Pointer()
	}
	return nil
}

func NewQTableWidgetItemFromPointer(ptr unsafe.Pointer) (n *QTableWidgetItem) {
	n = new(QTableWidgetItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTableWidgetItem__ItemType
//QTableWidgetItem::ItemType
type QTableWidgetItem__ItemType int64

const (
	QTableWidgetItem__Type     QTableWidgetItem__ItemType = QTableWidgetItem__ItemType(0)
	QTableWidgetItem__UserType QTableWidgetItem__ItemType = QTableWidgetItem__ItemType(1000)
)

func NewQTableWidgetItem3(icon gui.QIcon_ITF, text string, ty int) *QTableWidgetItem {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return NewQTableWidgetItemFromPointer(C.QTableWidgetItem_NewQTableWidgetItem3(gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.int(int32(ty))))
}

func NewQTableWidgetItem2(text string, ty int) *QTableWidgetItem {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return NewQTableWidgetItemFromPointer(C.QTableWidgetItem_NewQTableWidgetItem2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.int(int32(ty))))
}

func NewQTableWidgetItem4(other QTableWidgetItem_ITF) *QTableWidgetItem {
	return NewQTableWidgetItemFromPointer(C.QTableWidgetItem_NewQTableWidgetItem4(PointerFromQTableWidgetItem(other)))
}

func NewQTableWidgetItem(ty int) *QTableWidgetItem {
	return NewQTableWidgetItemFromPointer(C.QTableWidgetItem_NewQTableWidgetItem(C.int(int32(ty))))
}

//export callbackQTableWidgetItem_Read
func callbackQTableWidgetItem_Read(ptr unsafe.Pointer, in unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "read"); signal != nil {
		(*(*func(*core.QDataStream))(signal))(core.NewQDataStreamFromPointer(in))
	} else {
		NewQTableWidgetItemFromPointer(ptr).ReadDefault(core.NewQDataStreamFromPointer(in))
	}
}

func (ptr *QTableWidgetItem) ConnectRead(f func(in *core.QDataStream)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "read"); signal != nil {
			f := func(in *core.QDataStream) {
				(*(*func(*core.QDataStream))(signal))(in)
				f(in)
			}
			qt.ConnectSignal(ptr.Pointer(), "read", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "read", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidgetItem) DisconnectRead() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "read")
	}
}

func (ptr *QTableWidgetItem) Read(in core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_Read(ptr.Pointer(), core.PointerFromQDataStream(in))
	}
}

func (ptr *QTableWidgetItem) ReadDefault(in core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_ReadDefault(ptr.Pointer(), core.PointerFromQDataStream(in))
	}
}

func (ptr *QTableWidgetItem) SetBackground(brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetBackground(ptr.Pointer(), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QTableWidgetItem) SetCheckState(state core.Qt__CheckState) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetCheckState(ptr.Pointer(), C.longlong(state))
	}
}

//export callbackQTableWidgetItem_SetData
func callbackQTableWidgetItem_SetData(ptr unsafe.Pointer, role C.int, value unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setData"); signal != nil {
		(*(*func(int, *core.QVariant))(signal))(int(int32(role)), core.NewQVariantFromPointer(value))
	} else {
		NewQTableWidgetItemFromPointer(ptr).SetDataDefault(int(int32(role)), core.NewQVariantFromPointer(value))
	}
}

func (ptr *QTableWidgetItem) ConnectSetData(f func(role int, value *core.QVariant)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setData"); signal != nil {
			f := func(role int, value *core.QVariant) {
				(*(*func(int, *core.QVariant))(signal))(role, value)
				f(role, value)
			}
			qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidgetItem) DisconnectSetData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setData")
	}
}

func (ptr *QTableWidgetItem) SetData(role int, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetData(ptr.Pointer(), C.int(int32(role)), core.PointerFromQVariant(value))
	}
}

func (ptr *QTableWidgetItem) SetDataDefault(role int, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetDataDefault(ptr.Pointer(), C.int(int32(role)), core.PointerFromQVariant(value))
	}
}

func (ptr *QTableWidgetItem) SetFlags(flags core.Qt__ItemFlag) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QTableWidgetItem) SetFont(font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetFont(ptr.Pointer(), gui.PointerFromQFont(font))
	}
}

func (ptr *QTableWidgetItem) SetForeground(brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetForeground(ptr.Pointer(), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QTableWidgetItem) SetIcon(icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetIcon(ptr.Pointer(), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QTableWidgetItem) SetSelected(sele bool) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetSelected(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(sele))))
	}
}

func (ptr *QTableWidgetItem) SetSizeHint(size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetSizeHint(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QTableWidgetItem) SetStatusTip(statusTip string) {
	if ptr.Pointer() != nil {
		var statusTipC *C.char
		if statusTip != "" {
			statusTipC = C.CString(statusTip)
			defer C.free(unsafe.Pointer(statusTipC))
		}
		C.QTableWidgetItem_SetStatusTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: statusTipC, len: C.longlong(len(statusTip))})
	}
}

func (ptr *QTableWidgetItem) SetText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTableWidgetItem_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTableWidgetItem) SetTextAlignment(alignment int) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_SetTextAlignment(ptr.Pointer(), C.int(int32(alignment)))
	}
}

func (ptr *QTableWidgetItem) SetToolTip(toolTip string) {
	if ptr.Pointer() != nil {
		var toolTipC *C.char
		if toolTip != "" {
			toolTipC = C.CString(toolTip)
			defer C.free(unsafe.Pointer(toolTipC))
		}
		C.QTableWidgetItem_SetToolTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: toolTipC, len: C.longlong(len(toolTip))})
	}
}

func (ptr *QTableWidgetItem) SetWhatsThis(whatsThis string) {
	if ptr.Pointer() != nil {
		var whatsThisC *C.char
		if whatsThis != "" {
			whatsThisC = C.CString(whatsThis)
			defer C.free(unsafe.Pointer(whatsThisC))
		}
		C.QTableWidgetItem_SetWhatsThis(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: whatsThisC, len: C.longlong(len(whatsThis))})
	}
}

//export callbackQTableWidgetItem_DestroyQTableWidgetItem
func callbackQTableWidgetItem_DestroyQTableWidgetItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTableWidgetItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTableWidgetItemFromPointer(ptr).DestroyQTableWidgetItemDefault()
	}
}

func (ptr *QTableWidgetItem) ConnectDestroyQTableWidgetItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTableWidgetItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTableWidgetItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTableWidgetItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidgetItem) DisconnectDestroyQTableWidgetItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTableWidgetItem")
	}
}

func (ptr *QTableWidgetItem) DestroyQTableWidgetItem() {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_DestroyQTableWidgetItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTableWidgetItem) DestroyQTableWidgetItemDefault() {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_DestroyQTableWidgetItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTableWidgetItem) Background() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QTableWidgetItem_Background(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidgetItem) Foreground() *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QTableWidgetItem_Foreground(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidgetItem) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QTableWidgetItem_Font(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidgetItem) Icon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QTableWidgetItem_Icon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidgetItem) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QTableWidgetItem_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidgetItem) StatusTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTableWidgetItem_StatusTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTableWidgetItem) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTableWidgetItem_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTableWidgetItem) ToolTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTableWidgetItem_ToolTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTableWidgetItem) WhatsThis() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTableWidgetItem_WhatsThis(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTableWidgetItem) TableWidget() *QTableWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQTableWidgetFromPointer(C.QTableWidgetItem_TableWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQTableWidgetItem_Clone
func callbackQTableWidgetItem_Clone(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "clone"); signal != nil {
		return PointerFromQTableWidgetItem((*(*func() *QTableWidgetItem)(signal))())
	}

	return PointerFromQTableWidgetItem(NewQTableWidgetItemFromPointer(ptr).CloneDefault())
}

func (ptr *QTableWidgetItem) ConnectClone(f func() *QTableWidgetItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clone"); signal != nil {
			f := func() *QTableWidgetItem {
				(*(*func() *QTableWidgetItem)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clone", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clone", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidgetItem) DisconnectClone() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clone")
	}
}

func (ptr *QTableWidgetItem) Clone() *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidgetItem_Clone(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTableWidgetItem) CloneDefault() *QTableWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTableWidgetItemFromPointer(C.QTableWidgetItem_CloneDefault(ptr.Pointer()))
	}
	return nil
}

//export callbackQTableWidgetItem_Data
func callbackQTableWidgetItem_Data(ptr unsafe.Pointer, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return core.PointerFromQVariant((*(*func(int) *core.QVariant)(signal))(int(int32(role))))
	}

	return core.PointerFromQVariant(NewQTableWidgetItemFromPointer(ptr).DataDefault(int(int32(role))))
}

func (ptr *QTableWidgetItem) ConnectData(f func(role int) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "data"); signal != nil {
			f := func(role int) *core.QVariant {
				(*(*func(int) *core.QVariant)(signal))(role)
				return f(role)
			}
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidgetItem) DisconnectData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "data")
	}
}

func (ptr *QTableWidgetItem) Data(role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QTableWidgetItem_Data(ptr.Pointer(), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidgetItem) DataDefault(role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QTableWidgetItem_DataDefault(ptr.Pointer(), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QTableWidgetItem) CheckState() core.Qt__CheckState {
	if ptr.Pointer() != nil {
		return core.Qt__CheckState(C.QTableWidgetItem_CheckState(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTableWidgetItem) Flags() core.Qt__ItemFlag {
	if ptr.Pointer() != nil {
		return core.Qt__ItemFlag(C.QTableWidgetItem_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTableWidgetItem) IsSelected() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTableWidgetItem_IsSelected(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTableWidgetItem) Column() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetItem_Column(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidgetItem) Row() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetItem_Row(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidgetItem) TextAlignment() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetItem_TextAlignment(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidgetItem) Type() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetItem_Type(ptr.Pointer())))
	}
	return 0
}

//export callbackQTableWidgetItem_Write
func callbackQTableWidgetItem_Write(ptr unsafe.Pointer, out unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "write"); signal != nil {
		(*(*func(*core.QDataStream))(signal))(core.NewQDataStreamFromPointer(out))
	} else {
		NewQTableWidgetItemFromPointer(ptr).WriteDefault(core.NewQDataStreamFromPointer(out))
	}
}

func (ptr *QTableWidgetItem) ConnectWrite(f func(out *core.QDataStream)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "write"); signal != nil {
			f := func(out *core.QDataStream) {
				(*(*func(*core.QDataStream))(signal))(out)
				f(out)
			}
			qt.ConnectSignal(ptr.Pointer(), "write", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "write", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTableWidgetItem) DisconnectWrite() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "write")
	}
}

func (ptr *QTableWidgetItem) Write(out core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_Write(ptr.Pointer(), core.PointerFromQDataStream(out))
	}
}

func (ptr *QTableWidgetItem) WriteDefault(out core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QTableWidgetItem_WriteDefault(ptr.Pointer(), core.PointerFromQDataStream(out))
	}
}

func (ptr *QTableWidgetItem) __values_newList() unsafe.Pointer {
	return C.QTableWidgetItem___values_newList(ptr.Pointer())
}

func (ptr *QTableWidgetItem) __setValues__newList() unsafe.Pointer {
	return C.QTableWidgetItem___setValues__newList(ptr.Pointer())
}

type QTableWidgetSelectionRange struct {
	ptr unsafe.Pointer
}

type QTableWidgetSelectionRange_ITF interface {
	QTableWidgetSelectionRange_PTR() *QTableWidgetSelectionRange
}

func (ptr *QTableWidgetSelectionRange) QTableWidgetSelectionRange_PTR() *QTableWidgetSelectionRange {
	return ptr
}

func (ptr *QTableWidgetSelectionRange) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QTableWidgetSelectionRange) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQTableWidgetSelectionRange(ptr QTableWidgetSelectionRange_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTableWidgetSelectionRange_PTR().Pointer()
	}
	return nil
}

func NewQTableWidgetSelectionRangeFromPointer(ptr unsafe.Pointer) (n *QTableWidgetSelectionRange) {
	n = new(QTableWidgetSelectionRange)
	n.SetPointer(ptr)
	return
}
func NewQTableWidgetSelectionRange() *QTableWidgetSelectionRange {
	tmpValue := NewQTableWidgetSelectionRangeFromPointer(C.QTableWidgetSelectionRange_NewQTableWidgetSelectionRange())
	runtime.SetFinalizer(tmpValue, (*QTableWidgetSelectionRange).DestroyQTableWidgetSelectionRange)
	return tmpValue
}

func NewQTableWidgetSelectionRange3(other QTableWidgetSelectionRange_ITF) *QTableWidgetSelectionRange {
	tmpValue := NewQTableWidgetSelectionRangeFromPointer(C.QTableWidgetSelectionRange_NewQTableWidgetSelectionRange3(PointerFromQTableWidgetSelectionRange(other)))
	runtime.SetFinalizer(tmpValue, (*QTableWidgetSelectionRange).DestroyQTableWidgetSelectionRange)
	return tmpValue
}

func NewQTableWidgetSelectionRange2(top int, left int, bottom int, right int) *QTableWidgetSelectionRange {
	tmpValue := NewQTableWidgetSelectionRangeFromPointer(C.QTableWidgetSelectionRange_NewQTableWidgetSelectionRange2(C.int(int32(top)), C.int(int32(left)), C.int(int32(bottom)), C.int(int32(right))))
	runtime.SetFinalizer(tmpValue, (*QTableWidgetSelectionRange).DestroyQTableWidgetSelectionRange)
	return tmpValue
}

func (ptr *QTableWidgetSelectionRange) DestroyQTableWidgetSelectionRange() {
	if ptr.Pointer() != nil {
		C.QTableWidgetSelectionRange_DestroyQTableWidgetSelectionRange(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTableWidgetSelectionRange) BottomRow() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetSelectionRange_BottomRow(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidgetSelectionRange) ColumnCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetSelectionRange_ColumnCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidgetSelectionRange) LeftColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetSelectionRange_LeftColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidgetSelectionRange) RightColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetSelectionRange_RightColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidgetSelectionRange) RowCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetSelectionRange_RowCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTableWidgetSelectionRange) TopRow() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTableWidgetSelectionRange_TopRow(ptr.Pointer())))
	}
	return 0
}

type QTapAndHoldGesture struct {
	QGesture
}

type QTapAndHoldGesture_ITF interface {
	QGesture_ITF
	QTapAndHoldGesture_PTR() *QTapAndHoldGesture
}

func (ptr *QTapAndHoldGesture) QTapAndHoldGesture_PTR() *QTapAndHoldGesture {
	return ptr
}

func (ptr *QTapAndHoldGesture) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGesture_PTR().Pointer()
	}
	return nil
}

func (ptr *QTapAndHoldGesture) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGesture_PTR().SetPointer(p)
	}
}

func PointerFromQTapAndHoldGesture(ptr QTapAndHoldGesture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTapAndHoldGesture_PTR().Pointer()
	}
	return nil
}

func NewQTapAndHoldGestureFromPointer(ptr unsafe.Pointer) (n *QTapAndHoldGesture) {
	n = new(QTapAndHoldGesture)
	n.SetPointer(ptr)
	return
}
func QTapAndHoldGesture_Timeout() int {
	return int(int32(C.QTapAndHoldGesture_QTapAndHoldGesture_Timeout()))
}

func (ptr *QTapAndHoldGesture) Timeout() int {
	return int(int32(C.QTapAndHoldGesture_QTapAndHoldGesture_Timeout()))
}

func (ptr *QTapAndHoldGesture) SetPosition(pos core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QTapAndHoldGesture_SetPosition(ptr.Pointer(), core.PointerFromQPointF(pos))
	}
}

func QTapAndHoldGesture_SetTimeout(msecs int) {
	C.QTapAndHoldGesture_QTapAndHoldGesture_SetTimeout(C.int(int32(msecs)))
}

func (ptr *QTapAndHoldGesture) SetTimeout(msecs int) {
	C.QTapAndHoldGesture_QTapAndHoldGesture_SetTimeout(C.int(int32(msecs)))
}

//export callbackQTapAndHoldGesture_DestroyQTapAndHoldGesture
func callbackQTapAndHoldGesture_DestroyQTapAndHoldGesture(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTapAndHoldGesture"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTapAndHoldGestureFromPointer(ptr).DestroyQTapAndHoldGestureDefault()
	}
}

func (ptr *QTapAndHoldGesture) ConnectDestroyQTapAndHoldGesture(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTapAndHoldGesture"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTapAndHoldGesture", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTapAndHoldGesture", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTapAndHoldGesture) DisconnectDestroyQTapAndHoldGesture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTapAndHoldGesture")
	}
}

func (ptr *QTapAndHoldGesture) DestroyQTapAndHoldGesture() {
	if ptr.Pointer() != nil {
		C.QTapAndHoldGesture_DestroyQTapAndHoldGesture(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTapAndHoldGesture) DestroyQTapAndHoldGestureDefault() {
	if ptr.Pointer() != nil {
		C.QTapAndHoldGesture_DestroyQTapAndHoldGestureDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTapAndHoldGesture) Position() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QTapAndHoldGesture_Position(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

type QTapGesture struct {
	QGesture
}

type QTapGesture_ITF interface {
	QGesture_ITF
	QTapGesture_PTR() *QTapGesture
}

func (ptr *QTapGesture) QTapGesture_PTR() *QTapGesture {
	return ptr
}

func (ptr *QTapGesture) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QGesture_PTR().Pointer()
	}
	return nil
}

func (ptr *QTapGesture) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QGesture_PTR().SetPointer(p)
	}
}

func PointerFromQTapGesture(ptr QTapGesture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTapGesture_PTR().Pointer()
	}
	return nil
}

func NewQTapGestureFromPointer(ptr unsafe.Pointer) (n *QTapGesture) {
	n = new(QTapGesture)
	n.SetPointer(ptr)
	return
}
func (ptr *QTapGesture) SetPosition(pos core.QPointF_ITF) {
	if ptr.Pointer() != nil {
		C.QTapGesture_SetPosition(ptr.Pointer(), core.PointerFromQPointF(pos))
	}
}

//export callbackQTapGesture_DestroyQTapGesture
func callbackQTapGesture_DestroyQTapGesture(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTapGesture"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTapGestureFromPointer(ptr).DestroyQTapGestureDefault()
	}
}

func (ptr *QTapGesture) ConnectDestroyQTapGesture(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTapGesture"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTapGesture", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTapGesture", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTapGesture) DisconnectDestroyQTapGesture() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTapGesture")
	}
}

func (ptr *QTapGesture) DestroyQTapGesture() {
	if ptr.Pointer() != nil {
		C.QTapGesture_DestroyQTapGesture(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTapGesture) DestroyQTapGestureDefault() {
	if ptr.Pointer() != nil {
		C.QTapGesture_DestroyQTapGestureDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTapGesture) Position() *core.QPointF {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFFromPointer(C.QTapGesture_Position(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
		return tmpValue
	}
	return nil
}

type QTextBrowser struct {
	QTextEdit
}

type QTextBrowser_ITF interface {
	QTextEdit_ITF
	QTextBrowser_PTR() *QTextBrowser
}

func (ptr *QTextBrowser) QTextBrowser_PTR() *QTextBrowser {
	return ptr
}

func (ptr *QTextBrowser) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextEdit_PTR().Pointer()
	}
	return nil
}

func (ptr *QTextBrowser) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QTextEdit_PTR().SetPointer(p)
	}
}

func PointerFromQTextBrowser(ptr QTextBrowser_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextBrowser_PTR().Pointer()
	}
	return nil
}

func NewQTextBrowserFromPointer(ptr unsafe.Pointer) (n *QTextBrowser) {
	n = new(QTextBrowser)
	n.SetPointer(ptr)
	return
}
func NewQTextBrowser(parent QWidget_ITF) *QTextBrowser {
	tmpValue := NewQTextBrowserFromPointer(C.QTextBrowser_NewQTextBrowser(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQTextBrowser_AnchorClicked
func callbackQTextBrowser_AnchorClicked(ptr unsafe.Pointer, link unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "anchorClicked"); signal != nil {
		(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(link))
	}

}

func (ptr *QTextBrowser) ConnectAnchorClicked(f func(link *core.QUrl)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "anchorClicked") {
			C.QTextBrowser_ConnectAnchorClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "anchorClicked"); signal != nil {
			f := func(link *core.QUrl) {
				(*(*func(*core.QUrl))(signal))(link)
				f(link)
			}
			qt.ConnectSignal(ptr.Pointer(), "anchorClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "anchorClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectAnchorClicked() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_DisconnectAnchorClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "anchorClicked")
	}
}

func (ptr *QTextBrowser) AnchorClicked(link core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_AnchorClicked(ptr.Pointer(), core.PointerFromQUrl(link))
	}
}

//export callbackQTextBrowser_Backward
func callbackQTextBrowser_Backward(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "backward"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextBrowserFromPointer(ptr).BackwardDefault()
	}
}

func (ptr *QTextBrowser) ConnectBackward(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "backward"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "backward", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "backward", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectBackward() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "backward")
	}
}

func (ptr *QTextBrowser) Backward() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_Backward(ptr.Pointer())
	}
}

func (ptr *QTextBrowser) BackwardDefault() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_BackwardDefault(ptr.Pointer())
	}
}

//export callbackQTextBrowser_BackwardAvailable
func callbackQTextBrowser_BackwardAvailable(ptr unsafe.Pointer, available C.char) {
	if signal := qt.GetSignal(ptr, "backwardAvailable"); signal != nil {
		(*(*func(bool))(signal))(int8(available) != 0)
	}

}

func (ptr *QTextBrowser) ConnectBackwardAvailable(f func(available bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "backwardAvailable") {
			C.QTextBrowser_ConnectBackwardAvailable(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "backwardAvailable"); signal != nil {
			f := func(available bool) {
				(*(*func(bool))(signal))(available)
				f(available)
			}
			qt.ConnectSignal(ptr.Pointer(), "backwardAvailable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "backwardAvailable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectBackwardAvailable() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_DisconnectBackwardAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "backwardAvailable")
	}
}

func (ptr *QTextBrowser) BackwardAvailable(available bool) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_BackwardAvailable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
	}
}

func (ptr *QTextBrowser) ClearHistory() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_ClearHistory(ptr.Pointer())
	}
}

//export callbackQTextBrowser_Forward
func callbackQTextBrowser_Forward(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "forward"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextBrowserFromPointer(ptr).ForwardDefault()
	}
}

func (ptr *QTextBrowser) ConnectForward(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "forward"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "forward", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "forward", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectForward() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "forward")
	}
}

func (ptr *QTextBrowser) Forward() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_Forward(ptr.Pointer())
	}
}

func (ptr *QTextBrowser) ForwardDefault() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_ForwardDefault(ptr.Pointer())
	}
}

//export callbackQTextBrowser_ForwardAvailable
func callbackQTextBrowser_ForwardAvailable(ptr unsafe.Pointer, available C.char) {
	if signal := qt.GetSignal(ptr, "forwardAvailable"); signal != nil {
		(*(*func(bool))(signal))(int8(available) != 0)
	}

}

func (ptr *QTextBrowser) ConnectForwardAvailable(f func(available bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "forwardAvailable") {
			C.QTextBrowser_ConnectForwardAvailable(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "forwardAvailable"); signal != nil {
			f := func(available bool) {
				(*(*func(bool))(signal))(available)
				f(available)
			}
			qt.ConnectSignal(ptr.Pointer(), "forwardAvailable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "forwardAvailable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectForwardAvailable() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_DisconnectForwardAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "forwardAvailable")
	}
}

func (ptr *QTextBrowser) ForwardAvailable(available bool) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_ForwardAvailable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
	}
}

//export callbackQTextBrowser_Highlighted2
func callbackQTextBrowser_Highlighted2(ptr unsafe.Pointer, link C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "highlighted2"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(link))
	}

}

func (ptr *QTextBrowser) ConnectHighlighted2(f func(link string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "highlighted2") {
			C.QTextBrowser_ConnectHighlighted2(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "highlighted2"); signal != nil {
			f := func(link string) {
				(*(*func(string))(signal))(link)
				f(link)
			}
			qt.ConnectSignal(ptr.Pointer(), "highlighted2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "highlighted2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectHighlighted2() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_DisconnectHighlighted2(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "highlighted2")
	}
}

func (ptr *QTextBrowser) Highlighted2(link string) {
	if ptr.Pointer() != nil {
		var linkC *C.char
		if link != "" {
			linkC = C.CString(link)
			defer C.free(unsafe.Pointer(linkC))
		}
		C.QTextBrowser_Highlighted2(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: linkC, len: C.longlong(len(link))})
	}
}

//export callbackQTextBrowser_Highlighted
func callbackQTextBrowser_Highlighted(ptr unsafe.Pointer, link unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "highlighted"); signal != nil {
		(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(link))
	}

}

func (ptr *QTextBrowser) ConnectHighlighted(f func(link *core.QUrl)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "highlighted") {
			C.QTextBrowser_ConnectHighlighted(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "highlighted"); signal != nil {
			f := func(link *core.QUrl) {
				(*(*func(*core.QUrl))(signal))(link)
				f(link)
			}
			qt.ConnectSignal(ptr.Pointer(), "highlighted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "highlighted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectHighlighted() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_DisconnectHighlighted(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "highlighted")
	}
}

func (ptr *QTextBrowser) Highlighted(link core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_Highlighted(ptr.Pointer(), core.PointerFromQUrl(link))
	}
}

//export callbackQTextBrowser_HistoryChanged
func callbackQTextBrowser_HistoryChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "historyChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QTextBrowser) ConnectHistoryChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "historyChanged") {
			C.QTextBrowser_ConnectHistoryChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "historyChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "historyChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "historyChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectHistoryChanged() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_DisconnectHistoryChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "historyChanged")
	}
}

func (ptr *QTextBrowser) HistoryChanged() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_HistoryChanged(ptr.Pointer())
	}
}

//export callbackQTextBrowser_Home
func callbackQTextBrowser_Home(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "home"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextBrowserFromPointer(ptr).HomeDefault()
	}
}

func (ptr *QTextBrowser) ConnectHome(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "home"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "home", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "home", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectHome() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "home")
	}
}

func (ptr *QTextBrowser) Home() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_Home(ptr.Pointer())
	}
}

func (ptr *QTextBrowser) HomeDefault() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_HomeDefault(ptr.Pointer())
	}
}

//export callbackQTextBrowser_Reload
func callbackQTextBrowser_Reload(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "reload"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextBrowserFromPointer(ptr).ReloadDefault()
	}
}

func (ptr *QTextBrowser) ConnectReload(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "reload"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "reload", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "reload", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectReload() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "reload")
	}
}

func (ptr *QTextBrowser) Reload() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_Reload(ptr.Pointer())
	}
}

func (ptr *QTextBrowser) ReloadDefault() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_ReloadDefault(ptr.Pointer())
	}
}

func (ptr *QTextBrowser) SetOpenExternalLinks(open bool) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_SetOpenExternalLinks(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(open))))
	}
}

func (ptr *QTextBrowser) SetOpenLinks(open bool) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_SetOpenLinks(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(open))))
	}
}

func (ptr *QTextBrowser) SetSearchPaths(paths []string) {
	if ptr.Pointer() != nil {
		pathsC := C.CString(strings.Join(paths, "|"))
		defer C.free(unsafe.Pointer(pathsC))
		C.QTextBrowser_SetSearchPaths(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "|")))})
	}
}

//export callbackQTextBrowser_SetSource
func callbackQTextBrowser_SetSource(ptr unsafe.Pointer, name unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setSource"); signal != nil {
		(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(name))
	} else {
		NewQTextBrowserFromPointer(ptr).SetSourceDefault(core.NewQUrlFromPointer(name))
	}
}

func (ptr *QTextBrowser) ConnectSetSource(f func(name *core.QUrl)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setSource"); signal != nil {
			f := func(name *core.QUrl) {
				(*(*func(*core.QUrl))(signal))(name)
				f(name)
			}
			qt.ConnectSignal(ptr.Pointer(), "setSource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setSource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectSetSource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setSource")
	}
}

func (ptr *QTextBrowser) SetSource(name core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_SetSource(ptr.Pointer(), core.PointerFromQUrl(name))
	}
}

func (ptr *QTextBrowser) SetSourceDefault(name core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_SetSourceDefault(ptr.Pointer(), core.PointerFromQUrl(name))
	}
}

//export callbackQTextBrowser_SourceChanged
func callbackQTextBrowser_SourceChanged(ptr unsafe.Pointer, src unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "sourceChanged"); signal != nil {
		(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(src))
	}

}

func (ptr *QTextBrowser) ConnectSourceChanged(f func(src *core.QUrl)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "sourceChanged") {
			C.QTextBrowser_ConnectSourceChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "sourceChanged"); signal != nil {
			f := func(src *core.QUrl) {
				(*(*func(*core.QUrl))(signal))(src)
				f(src)
			}
			qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextBrowser) DisconnectSourceChanged() {
	if ptr.Pointer() != nil {
		C.QTextBrowser_DisconnectSourceChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "sourceChanged")
	}
}

func (ptr *QTextBrowser) SourceChanged(src core.QUrl_ITF) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_SourceChanged(ptr.Pointer(), core.PointerFromQUrl(src))
	}
}

func (ptr *QTextBrowser) HistoryTitle(i int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextBrowser_HistoryTitle(ptr.Pointer(), C.int(int32(i))))
	}
	return ""
}

func (ptr *QTextBrowser) SearchPaths() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QTextBrowser_SearchPaths(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QTextBrowser) HistoryUrl(i int) *core.QUrl {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQUrlFromPointer(C.QTextBrowser_HistoryUrl(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QTextBrowser) Source() *core.QUrl {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQUrlFromPointer(C.QTextBrowser_Source(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
		return tmpValue
	}
	return nil
}

func (ptr *QTextBrowser) IsBackwardAvailable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextBrowser_IsBackwardAvailable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextBrowser) IsForwardAvailable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextBrowser_IsForwardAvailable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextBrowser) OpenExternalLinks() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextBrowser_OpenExternalLinks(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextBrowser) OpenLinks() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextBrowser_OpenLinks(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextBrowser) BackwardHistoryCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextBrowser_BackwardHistoryCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextBrowser) ForwardHistoryCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextBrowser_ForwardHistoryCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextBrowser) IsReadOnly() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextBrowser_IsReadOnly(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextBrowser) SetReadOnly(readOnly bool) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_SetReadOnly(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(readOnly))))
	}
}

func (ptr *QTextBrowser) IsUndoRedoEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextBrowser_IsUndoRedoEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextBrowser) SetUndoRedoEnabled(undoRedoEnabled bool) {
	if ptr.Pointer() != nil {
		C.QTextBrowser_SetUndoRedoEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(undoRedoEnabled))))
	}
}

type QTextEdit struct {
	QAbstractScrollArea
}

type QTextEdit_ITF interface {
	QAbstractScrollArea_ITF
	QTextEdit_PTR() *QTextEdit
}

func (ptr *QTextEdit) QTextEdit_PTR() *QTextEdit {
	return ptr
}

func (ptr *QTextEdit) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractScrollArea_PTR().Pointer()
	}
	return nil
}

func (ptr *QTextEdit) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractScrollArea_PTR().SetPointer(p)
	}
}

func PointerFromQTextEdit(ptr QTextEdit_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextEdit_PTR().Pointer()
	}
	return nil
}

func NewQTextEditFromPointer(ptr unsafe.Pointer) (n *QTextEdit) {
	n = new(QTextEdit)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTextEdit__AutoFormattingFlag
//QTextEdit::AutoFormattingFlag
type QTextEdit__AutoFormattingFlag int64

const (
	QTextEdit__AutoNone       QTextEdit__AutoFormattingFlag = QTextEdit__AutoFormattingFlag(0)
	QTextEdit__AutoBulletList QTextEdit__AutoFormattingFlag = QTextEdit__AutoFormattingFlag(0x00000001)
	QTextEdit__AutoAll        QTextEdit__AutoFormattingFlag = QTextEdit__AutoFormattingFlag(0xffffffff)
)

//go:generate stringer -type=QTextEdit__LineWrapMode
//QTextEdit::LineWrapMode
type QTextEdit__LineWrapMode int64

const (
	QTextEdit__NoWrap           QTextEdit__LineWrapMode = QTextEdit__LineWrapMode(0)
	QTextEdit__WidgetWidth      QTextEdit__LineWrapMode = QTextEdit__LineWrapMode(1)
	QTextEdit__FixedPixelWidth  QTextEdit__LineWrapMode = QTextEdit__LineWrapMode(2)
	QTextEdit__FixedColumnWidth QTextEdit__LineWrapMode = QTextEdit__LineWrapMode(3)
)

func (ptr *QTextEdit) CreateStandardContextMenu() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QTextEdit_CreateStandardContextMenu(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) CreateStandardContextMenu2(position core.QPoint_ITF) *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QTextEdit_CreateStandardContextMenu2(ptr.Pointer(), core.PointerFromQPoint(position)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQTextEdit(parent QWidget_ITF) *QTextEdit {
	tmpValue := NewQTextEditFromPointer(C.QTextEdit_NewQTextEdit(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQTextEdit2(text string, parent QWidget_ITF) *QTextEdit {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	tmpValue := NewQTextEditFromPointer(C.QTextEdit_NewQTextEdit2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQTextEdit_LoadResource
func callbackQTextEdit_LoadResource(ptr unsafe.Pointer, ty C.int, name unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "loadResource"); signal != nil {
		return core.PointerFromQVariant((*(*func(int, *core.QUrl) *core.QVariant)(signal))(int(int32(ty)), core.NewQUrlFromPointer(name)))
	}

	return core.PointerFromQVariant(NewQTextEditFromPointer(ptr).LoadResourceDefault(int(int32(ty)), core.NewQUrlFromPointer(name)))
}

func (ptr *QTextEdit) ConnectLoadResource(f func(ty int, name *core.QUrl) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "loadResource"); signal != nil {
			f := func(ty int, name *core.QUrl) *core.QVariant {
				(*(*func(int, *core.QUrl) *core.QVariant)(signal))(ty, name)
				return f(ty, name)
			}
			qt.ConnectSignal(ptr.Pointer(), "loadResource", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "loadResource", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectLoadResource() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "loadResource")
	}
}

func (ptr *QTextEdit) LoadResource(ty int, name core.QUrl_ITF) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QTextEdit_LoadResource(ptr.Pointer(), C.int(int32(ty)), core.PointerFromQUrl(name)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) LoadResourceDefault(ty int, name core.QUrl_ITF) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QTextEdit_LoadResourceDefault(ptr.Pointer(), C.int(int32(ty)), core.PointerFromQUrl(name)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) Find2(exp core.QRegExp_ITF, options gui.QTextDocument__FindFlag) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_Find2(ptr.Pointer(), core.PointerFromQRegExp(exp), C.longlong(options))) != 0
	}
	return false
}

func (ptr *QTextEdit) Find(exp string, options gui.QTextDocument__FindFlag) bool {
	if ptr.Pointer() != nil {
		var expC *C.char
		if exp != "" {
			expC = C.CString(exp)
			defer C.free(unsafe.Pointer(expC))
		}
		return int8(C.QTextEdit_Find(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: expC, len: C.longlong(len(exp))}, C.longlong(options))) != 0
	}
	return false
}

//export callbackQTextEdit_Append
func callbackQTextEdit_Append(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "append"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQTextEditFromPointer(ptr).AppendDefault(cGoUnpackString(text))
	}
}

func (ptr *QTextEdit) ConnectAppend(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "append"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "append", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "append", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectAppend() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "append")
	}
}

func (ptr *QTextEdit) Append(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_Append(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTextEdit) AppendDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_AppendDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQTextEdit_Clear
func callbackQTextEdit_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextEditFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QTextEdit) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QTextEdit) Clear() {
	if ptr.Pointer() != nil {
		C.QTextEdit_Clear(ptr.Pointer())
	}
}

func (ptr *QTextEdit) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QTextEdit_ClearDefault(ptr.Pointer())
	}
}

//export callbackQTextEdit_Copy
func callbackQTextEdit_Copy(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "copy"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextEditFromPointer(ptr).CopyDefault()
	}
}

func (ptr *QTextEdit) ConnectCopy(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "copy"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "copy", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "copy", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectCopy() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "copy")
	}
}

func (ptr *QTextEdit) Copy() {
	if ptr.Pointer() != nil {
		C.QTextEdit_Copy(ptr.Pointer())
	}
}

func (ptr *QTextEdit) CopyDefault() {
	if ptr.Pointer() != nil {
		C.QTextEdit_CopyDefault(ptr.Pointer())
	}
}

//export callbackQTextEdit_CopyAvailable
func callbackQTextEdit_CopyAvailable(ptr unsafe.Pointer, yes C.char) {
	if signal := qt.GetSignal(ptr, "copyAvailable"); signal != nil {
		(*(*func(bool))(signal))(int8(yes) != 0)
	}

}

func (ptr *QTextEdit) ConnectCopyAvailable(f func(yes bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "copyAvailable") {
			C.QTextEdit_ConnectCopyAvailable(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "copyAvailable"); signal != nil {
			f := func(yes bool) {
				(*(*func(bool))(signal))(yes)
				f(yes)
			}
			qt.ConnectSignal(ptr.Pointer(), "copyAvailable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "copyAvailable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectCopyAvailable() {
	if ptr.Pointer() != nil {
		C.QTextEdit_DisconnectCopyAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "copyAvailable")
	}
}

func (ptr *QTextEdit) CopyAvailable(yes bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_CopyAvailable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(yes))))
	}
}

//export callbackQTextEdit_CurrentCharFormatChanged
func callbackQTextEdit_CurrentCharFormatChanged(ptr unsafe.Pointer, ff unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentCharFormatChanged"); signal != nil {
		(*(*func(*gui.QTextCharFormat))(signal))(gui.NewQTextCharFormatFromPointer(ff))
	}

}

func (ptr *QTextEdit) ConnectCurrentCharFormatChanged(f func(ff *gui.QTextCharFormat)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentCharFormatChanged") {
			C.QTextEdit_ConnectCurrentCharFormatChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentCharFormatChanged"); signal != nil {
			f := func(ff *gui.QTextCharFormat) {
				(*(*func(*gui.QTextCharFormat))(signal))(ff)
				f(ff)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentCharFormatChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentCharFormatChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectCurrentCharFormatChanged() {
	if ptr.Pointer() != nil {
		C.QTextEdit_DisconnectCurrentCharFormatChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentCharFormatChanged")
	}
}

func (ptr *QTextEdit) CurrentCharFormatChanged(ff gui.QTextCharFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_CurrentCharFormatChanged(ptr.Pointer(), gui.PointerFromQTextCharFormat(ff))
	}
}

//export callbackQTextEdit_CursorPositionChanged
func callbackQTextEdit_CursorPositionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "cursorPositionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QTextEdit) ConnectCursorPositionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cursorPositionChanged") {
			C.QTextEdit_ConnectCursorPositionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cursorPositionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "cursorPositionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cursorPositionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectCursorPositionChanged() {
	if ptr.Pointer() != nil {
		C.QTextEdit_DisconnectCursorPositionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cursorPositionChanged")
	}
}

func (ptr *QTextEdit) CursorPositionChanged() {
	if ptr.Pointer() != nil {
		C.QTextEdit_CursorPositionChanged(ptr.Pointer())
	}
}

//export callbackQTextEdit_Cut
func callbackQTextEdit_Cut(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "cut"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextEditFromPointer(ptr).CutDefault()
	}
}

func (ptr *QTextEdit) ConnectCut(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "cut"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "cut", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cut", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectCut() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "cut")
	}
}

func (ptr *QTextEdit) Cut() {
	if ptr.Pointer() != nil {
		C.QTextEdit_Cut(ptr.Pointer())
	}
}

func (ptr *QTextEdit) CutDefault() {
	if ptr.Pointer() != nil {
		C.QTextEdit_CutDefault(ptr.Pointer())
	}
}

func (ptr *QTextEdit) EnsureCursorVisible() {
	if ptr.Pointer() != nil {
		C.QTextEdit_EnsureCursorVisible(ptr.Pointer())
	}
}

//export callbackQTextEdit_InsertFromMimeData
func callbackQTextEdit_InsertFromMimeData(ptr unsafe.Pointer, source unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "insertFromMimeData"); signal != nil {
		(*(*func(*core.QMimeData))(signal))(core.NewQMimeDataFromPointer(source))
	} else {
		NewQTextEditFromPointer(ptr).InsertFromMimeDataDefault(core.NewQMimeDataFromPointer(source))
	}
}

func (ptr *QTextEdit) ConnectInsertFromMimeData(f func(source *core.QMimeData)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "insertFromMimeData"); signal != nil {
			f := func(source *core.QMimeData) {
				(*(*func(*core.QMimeData))(signal))(source)
				f(source)
			}
			qt.ConnectSignal(ptr.Pointer(), "insertFromMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "insertFromMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectInsertFromMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "insertFromMimeData")
	}
}

func (ptr *QTextEdit) InsertFromMimeData(source core.QMimeData_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_InsertFromMimeData(ptr.Pointer(), core.PointerFromQMimeData(source))
	}
}

func (ptr *QTextEdit) InsertFromMimeDataDefault(source core.QMimeData_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_InsertFromMimeDataDefault(ptr.Pointer(), core.PointerFromQMimeData(source))
	}
}

//export callbackQTextEdit_InsertHtml
func callbackQTextEdit_InsertHtml(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "insertHtml"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQTextEditFromPointer(ptr).InsertHtmlDefault(cGoUnpackString(text))
	}
}

func (ptr *QTextEdit) ConnectInsertHtml(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "insertHtml"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "insertHtml", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "insertHtml", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectInsertHtml() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "insertHtml")
	}
}

func (ptr *QTextEdit) InsertHtml(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_InsertHtml(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTextEdit) InsertHtmlDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_InsertHtmlDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQTextEdit_InsertPlainText
func callbackQTextEdit_InsertPlainText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "insertPlainText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQTextEditFromPointer(ptr).InsertPlainTextDefault(cGoUnpackString(text))
	}
}

func (ptr *QTextEdit) ConnectInsertPlainText(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "insertPlainText"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "insertPlainText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "insertPlainText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectInsertPlainText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "insertPlainText")
	}
}

func (ptr *QTextEdit) InsertPlainText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_InsertPlainText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTextEdit) InsertPlainTextDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_InsertPlainTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTextEdit) MergeCurrentCharFormat(modifier gui.QTextCharFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_MergeCurrentCharFormat(ptr.Pointer(), gui.PointerFromQTextCharFormat(modifier))
	}
}

func (ptr *QTextEdit) MoveCursor(operation gui.QTextCursor__MoveOperation, mode gui.QTextCursor__MoveMode) {
	if ptr.Pointer() != nil {
		C.QTextEdit_MoveCursor(ptr.Pointer(), C.longlong(operation), C.longlong(mode))
	}
}

//export callbackQTextEdit_Paste
func callbackQTextEdit_Paste(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paste"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextEditFromPointer(ptr).PasteDefault()
	}
}

func (ptr *QTextEdit) ConnectPaste(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paste"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "paste", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paste", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectPaste() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paste")
	}
}

func (ptr *QTextEdit) Paste() {
	if ptr.Pointer() != nil {
		C.QTextEdit_Paste(ptr.Pointer())
	}
}

func (ptr *QTextEdit) PasteDefault() {
	if ptr.Pointer() != nil {
		C.QTextEdit_PasteDefault(ptr.Pointer())
	}
}

//export callbackQTextEdit_Redo
func callbackQTextEdit_Redo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "redo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextEditFromPointer(ptr).RedoDefault()
	}
}

func (ptr *QTextEdit) ConnectRedo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "redo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectRedo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "redo")
	}
}

func (ptr *QTextEdit) Redo() {
	if ptr.Pointer() != nil {
		C.QTextEdit_Redo(ptr.Pointer())
	}
}

func (ptr *QTextEdit) RedoDefault() {
	if ptr.Pointer() != nil {
		C.QTextEdit_RedoDefault(ptr.Pointer())
	}
}

//export callbackQTextEdit_RedoAvailable
func callbackQTextEdit_RedoAvailable(ptr unsafe.Pointer, available C.char) {
	if signal := qt.GetSignal(ptr, "redoAvailable"); signal != nil {
		(*(*func(bool))(signal))(int8(available) != 0)
	}

}

func (ptr *QTextEdit) ConnectRedoAvailable(f func(available bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "redoAvailable") {
			C.QTextEdit_ConnectRedoAvailable(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "redoAvailable"); signal != nil {
			f := func(available bool) {
				(*(*func(bool))(signal))(available)
				f(available)
			}
			qt.ConnectSignal(ptr.Pointer(), "redoAvailable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redoAvailable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectRedoAvailable() {
	if ptr.Pointer() != nil {
		C.QTextEdit_DisconnectRedoAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "redoAvailable")
	}
}

func (ptr *QTextEdit) RedoAvailable(available bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_RedoAvailable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
	}
}

//export callbackQTextEdit_ScrollToAnchor
func callbackQTextEdit_ScrollToAnchor(ptr unsafe.Pointer, name C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "scrollToAnchor"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(name))
	} else {
		NewQTextEditFromPointer(ptr).ScrollToAnchorDefault(cGoUnpackString(name))
	}
}

func (ptr *QTextEdit) ConnectScrollToAnchor(f func(name string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "scrollToAnchor"); signal != nil {
			f := func(name string) {
				(*(*func(string))(signal))(name)
				f(name)
			}
			qt.ConnectSignal(ptr.Pointer(), "scrollToAnchor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scrollToAnchor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectScrollToAnchor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "scrollToAnchor")
	}
}

func (ptr *QTextEdit) ScrollToAnchor(name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QTextEdit_ScrollToAnchor(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

func (ptr *QTextEdit) ScrollToAnchorDefault(name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QTextEdit_ScrollToAnchorDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

//export callbackQTextEdit_SelectAll
func callbackQTextEdit_SelectAll(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectAll"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextEditFromPointer(ptr).SelectAllDefault()
	}
}

func (ptr *QTextEdit) ConnectSelectAll(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "selectAll"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "selectAll", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectAll", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSelectAll() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "selectAll")
	}
}

func (ptr *QTextEdit) SelectAll() {
	if ptr.Pointer() != nil {
		C.QTextEdit_SelectAll(ptr.Pointer())
	}
}

func (ptr *QTextEdit) SelectAllDefault() {
	if ptr.Pointer() != nil {
		C.QTextEdit_SelectAllDefault(ptr.Pointer())
	}
}

//export callbackQTextEdit_SelectionChanged
func callbackQTextEdit_SelectionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QTextEdit) ConnectSelectionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "selectionChanged") {
			C.QTextEdit_ConnectSelectionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "selectionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QTextEdit_DisconnectSelectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "selectionChanged")
	}
}

func (ptr *QTextEdit) SelectionChanged() {
	if ptr.Pointer() != nil {
		C.QTextEdit_SelectionChanged(ptr.Pointer())
	}
}

func (ptr *QTextEdit) SetAcceptRichText(accept bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetAcceptRichText(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(accept))))
	}
}

//export callbackQTextEdit_SetAlignment
func callbackQTextEdit_SetAlignment(ptr unsafe.Pointer, a C.longlong) {
	if signal := qt.GetSignal(ptr, "setAlignment"); signal != nil {
		(*(*func(core.Qt__AlignmentFlag))(signal))(core.Qt__AlignmentFlag(a))
	} else {
		NewQTextEditFromPointer(ptr).SetAlignmentDefault(core.Qt__AlignmentFlag(a))
	}
}

func (ptr *QTextEdit) ConnectSetAlignment(f func(a core.Qt__AlignmentFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setAlignment"); signal != nil {
			f := func(a core.Qt__AlignmentFlag) {
				(*(*func(core.Qt__AlignmentFlag))(signal))(a)
				f(a)
			}
			qt.ConnectSignal(ptr.Pointer(), "setAlignment", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setAlignment", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetAlignment() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setAlignment")
	}
}

func (ptr *QTextEdit) SetAlignment(a core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetAlignment(ptr.Pointer(), C.longlong(a))
	}
}

func (ptr *QTextEdit) SetAlignmentDefault(a core.Qt__AlignmentFlag) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetAlignmentDefault(ptr.Pointer(), C.longlong(a))
	}
}

func (ptr *QTextEdit) SetAutoFormatting(features QTextEdit__AutoFormattingFlag) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetAutoFormatting(ptr.Pointer(), C.longlong(features))
	}
}

func (ptr *QTextEdit) SetCurrentCharFormat(format gui.QTextCharFormat_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetCurrentCharFormat(ptr.Pointer(), gui.PointerFromQTextCharFormat(format))
	}
}

//export callbackQTextEdit_SetCurrentFont
func callbackQTextEdit_SetCurrentFont(ptr unsafe.Pointer, ff unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setCurrentFont"); signal != nil {
		(*(*func(*gui.QFont))(signal))(gui.NewQFontFromPointer(ff))
	} else {
		NewQTextEditFromPointer(ptr).SetCurrentFontDefault(gui.NewQFontFromPointer(ff))
	}
}

func (ptr *QTextEdit) ConnectSetCurrentFont(f func(ff *gui.QFont)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentFont"); signal != nil {
			f := func(ff *gui.QFont) {
				(*(*func(*gui.QFont))(signal))(ff)
				f(ff)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentFont", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetCurrentFont() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentFont")
	}
}

func (ptr *QTextEdit) SetCurrentFont(ff gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetCurrentFont(ptr.Pointer(), gui.PointerFromQFont(ff))
	}
}

func (ptr *QTextEdit) SetCurrentFontDefault(ff gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetCurrentFontDefault(ptr.Pointer(), gui.PointerFromQFont(ff))
	}
}

func (ptr *QTextEdit) SetCursorWidth(width int) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetCursorWidth(ptr.Pointer(), C.int(int32(width)))
	}
}

func (ptr *QTextEdit) SetDocument(document gui.QTextDocument_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetDocument(ptr.Pointer(), gui.PointerFromQTextDocument(document))
	}
}

func (ptr *QTextEdit) SetDocumentTitle(title string) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		C.QTextEdit_SetDocumentTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
	}
}

//export callbackQTextEdit_SetFontFamily
func callbackQTextEdit_SetFontFamily(ptr unsafe.Pointer, fontFamily C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setFontFamily"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(fontFamily))
	} else {
		NewQTextEditFromPointer(ptr).SetFontFamilyDefault(cGoUnpackString(fontFamily))
	}
}

func (ptr *QTextEdit) ConnectSetFontFamily(f func(fontFamily string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFontFamily"); signal != nil {
			f := func(fontFamily string) {
				(*(*func(string))(signal))(fontFamily)
				f(fontFamily)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFontFamily", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFontFamily", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetFontFamily() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFontFamily")
	}
}

func (ptr *QTextEdit) SetFontFamily(fontFamily string) {
	if ptr.Pointer() != nil {
		var fontFamilyC *C.char
		if fontFamily != "" {
			fontFamilyC = C.CString(fontFamily)
			defer C.free(unsafe.Pointer(fontFamilyC))
		}
		C.QTextEdit_SetFontFamily(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: fontFamilyC, len: C.longlong(len(fontFamily))})
	}
}

func (ptr *QTextEdit) SetFontFamilyDefault(fontFamily string) {
	if ptr.Pointer() != nil {
		var fontFamilyC *C.char
		if fontFamily != "" {
			fontFamilyC = C.CString(fontFamily)
			defer C.free(unsafe.Pointer(fontFamilyC))
		}
		C.QTextEdit_SetFontFamilyDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: fontFamilyC, len: C.longlong(len(fontFamily))})
	}
}

//export callbackQTextEdit_SetFontItalic
func callbackQTextEdit_SetFontItalic(ptr unsafe.Pointer, italic C.char) {
	if signal := qt.GetSignal(ptr, "setFontItalic"); signal != nil {
		(*(*func(bool))(signal))(int8(italic) != 0)
	} else {
		NewQTextEditFromPointer(ptr).SetFontItalicDefault(int8(italic) != 0)
	}
}

func (ptr *QTextEdit) ConnectSetFontItalic(f func(italic bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFontItalic"); signal != nil {
			f := func(italic bool) {
				(*(*func(bool))(signal))(italic)
				f(italic)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFontItalic", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFontItalic", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetFontItalic() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFontItalic")
	}
}

func (ptr *QTextEdit) SetFontItalic(italic bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetFontItalic(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(italic))))
	}
}

func (ptr *QTextEdit) SetFontItalicDefault(italic bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetFontItalicDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(italic))))
	}
}

//export callbackQTextEdit_SetFontPointSize
func callbackQTextEdit_SetFontPointSize(ptr unsafe.Pointer, s C.double) {
	if signal := qt.GetSignal(ptr, "setFontPointSize"); signal != nil {
		(*(*func(float64))(signal))(float64(s))
	} else {
		NewQTextEditFromPointer(ptr).SetFontPointSizeDefault(float64(s))
	}
}

func (ptr *QTextEdit) ConnectSetFontPointSize(f func(s float64)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFontPointSize"); signal != nil {
			f := func(s float64) {
				(*(*func(float64))(signal))(s)
				f(s)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFontPointSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFontPointSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetFontPointSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFontPointSize")
	}
}

func (ptr *QTextEdit) SetFontPointSize(s float64) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetFontPointSize(ptr.Pointer(), C.double(s))
	}
}

func (ptr *QTextEdit) SetFontPointSizeDefault(s float64) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetFontPointSizeDefault(ptr.Pointer(), C.double(s))
	}
}

//export callbackQTextEdit_SetFontUnderline
func callbackQTextEdit_SetFontUnderline(ptr unsafe.Pointer, underline C.char) {
	if signal := qt.GetSignal(ptr, "setFontUnderline"); signal != nil {
		(*(*func(bool))(signal))(int8(underline) != 0)
	} else {
		NewQTextEditFromPointer(ptr).SetFontUnderlineDefault(int8(underline) != 0)
	}
}

func (ptr *QTextEdit) ConnectSetFontUnderline(f func(underline bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFontUnderline"); signal != nil {
			f := func(underline bool) {
				(*(*func(bool))(signal))(underline)
				f(underline)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFontUnderline", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFontUnderline", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetFontUnderline() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFontUnderline")
	}
}

func (ptr *QTextEdit) SetFontUnderline(underline bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetFontUnderline(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(underline))))
	}
}

func (ptr *QTextEdit) SetFontUnderlineDefault(underline bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetFontUnderlineDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(underline))))
	}
}

//export callbackQTextEdit_SetFontWeight
func callbackQTextEdit_SetFontWeight(ptr unsafe.Pointer, weight C.int) {
	if signal := qt.GetSignal(ptr, "setFontWeight"); signal != nil {
		(*(*func(int))(signal))(int(int32(weight)))
	} else {
		NewQTextEditFromPointer(ptr).SetFontWeightDefault(int(int32(weight)))
	}
}

func (ptr *QTextEdit) ConnectSetFontWeight(f func(weight int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFontWeight"); signal != nil {
			f := func(weight int) {
				(*(*func(int))(signal))(weight)
				f(weight)
			}
			qt.ConnectSignal(ptr.Pointer(), "setFontWeight", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFontWeight", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetFontWeight() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFontWeight")
	}
}

func (ptr *QTextEdit) SetFontWeight(weight int) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetFontWeight(ptr.Pointer(), C.int(int32(weight)))
	}
}

func (ptr *QTextEdit) SetFontWeightDefault(weight int) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetFontWeightDefault(ptr.Pointer(), C.int(int32(weight)))
	}
}

//export callbackQTextEdit_SetHtml
func callbackQTextEdit_SetHtml(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setHtml"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQTextEditFromPointer(ptr).SetHtmlDefault(cGoUnpackString(text))
	}
}

func (ptr *QTextEdit) ConnectSetHtml(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setHtml"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "setHtml", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setHtml", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetHtml() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setHtml")
	}
}

func (ptr *QTextEdit) SetHtml(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_SetHtml(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTextEdit) SetHtmlDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_SetHtmlDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTextEdit) SetLineWrapColumnOrWidth(w int) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetLineWrapColumnOrWidth(ptr.Pointer(), C.int(int32(w)))
	}
}

func (ptr *QTextEdit) SetLineWrapMode(mode QTextEdit__LineWrapMode) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetLineWrapMode(ptr.Pointer(), C.longlong(mode))
	}
}

func (ptr *QTextEdit) SetOverwriteMode(overwrite bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetOverwriteMode(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(overwrite))))
	}
}

func (ptr *QTextEdit) SetPlaceholderText(placeholderText string) {
	if ptr.Pointer() != nil {
		var placeholderTextC *C.char
		if placeholderText != "" {
			placeholderTextC = C.CString(placeholderText)
			defer C.free(unsafe.Pointer(placeholderTextC))
		}
		C.QTextEdit_SetPlaceholderText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: placeholderTextC, len: C.longlong(len(placeholderText))})
	}
}

//export callbackQTextEdit_SetPlainText
func callbackQTextEdit_SetPlainText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setPlainText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQTextEditFromPointer(ptr).SetPlainTextDefault(cGoUnpackString(text))
	}
}

func (ptr *QTextEdit) ConnectSetPlainText(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setPlainText"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "setPlainText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setPlainText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetPlainText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setPlainText")
	}
}

func (ptr *QTextEdit) SetPlainText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_SetPlainText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTextEdit) SetPlainTextDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_SetPlainTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTextEdit) SetReadOnly(ro bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetReadOnly(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(ro))))
	}
}

func (ptr *QTextEdit) SetTabChangesFocus(b bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetTabChangesFocus(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(b))))
	}
}

func (ptr *QTextEdit) SetTabStopDistance(distance float64) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetTabStopDistance(ptr.Pointer(), C.double(distance))
	}
}

func (ptr *QTextEdit) SetTabStopWidth(width int) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetTabStopWidth(ptr.Pointer(), C.int(int32(width)))
	}
}

//export callbackQTextEdit_SetText
func callbackQTextEdit_SetText(ptr unsafe.Pointer, text C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setText"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(text))
	} else {
		NewQTextEditFromPointer(ptr).SetTextDefault(cGoUnpackString(text))
	}
}

func (ptr *QTextEdit) ConnectSetText(f func(text string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setText"); signal != nil {
			f := func(text string) {
				(*(*func(string))(signal))(text)
				f(text)
			}
			qt.ConnectSignal(ptr.Pointer(), "setText", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setText", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetText() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setText")
	}
}

func (ptr *QTextEdit) SetText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTextEdit) SetTextDefault(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTextEdit_SetTextDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQTextEdit_SetTextBackgroundColor
func callbackQTextEdit_SetTextBackgroundColor(ptr unsafe.Pointer, c unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setTextBackgroundColor"); signal != nil {
		(*(*func(*gui.QColor))(signal))(gui.NewQColorFromPointer(c))
	} else {
		NewQTextEditFromPointer(ptr).SetTextBackgroundColorDefault(gui.NewQColorFromPointer(c))
	}
}

func (ptr *QTextEdit) ConnectSetTextBackgroundColor(f func(c *gui.QColor)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setTextBackgroundColor"); signal != nil {
			f := func(c *gui.QColor) {
				(*(*func(*gui.QColor))(signal))(c)
				f(c)
			}
			qt.ConnectSignal(ptr.Pointer(), "setTextBackgroundColor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setTextBackgroundColor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetTextBackgroundColor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setTextBackgroundColor")
	}
}

func (ptr *QTextEdit) SetTextBackgroundColor(c gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetTextBackgroundColor(ptr.Pointer(), gui.PointerFromQColor(c))
	}
}

func (ptr *QTextEdit) SetTextBackgroundColorDefault(c gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetTextBackgroundColorDefault(ptr.Pointer(), gui.PointerFromQColor(c))
	}
}

//export callbackQTextEdit_SetTextColor
func callbackQTextEdit_SetTextColor(ptr unsafe.Pointer, c unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setTextColor"); signal != nil {
		(*(*func(*gui.QColor))(signal))(gui.NewQColorFromPointer(c))
	} else {
		NewQTextEditFromPointer(ptr).SetTextColorDefault(gui.NewQColorFromPointer(c))
	}
}

func (ptr *QTextEdit) ConnectSetTextColor(f func(c *gui.QColor)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setTextColor"); signal != nil {
			f := func(c *gui.QColor) {
				(*(*func(*gui.QColor))(signal))(c)
				f(c)
			}
			qt.ConnectSignal(ptr.Pointer(), "setTextColor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setTextColor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectSetTextColor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setTextColor")
	}
}

func (ptr *QTextEdit) SetTextColor(c gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetTextColor(ptr.Pointer(), gui.PointerFromQColor(c))
	}
}

func (ptr *QTextEdit) SetTextColorDefault(c gui.QColor_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetTextColorDefault(ptr.Pointer(), gui.PointerFromQColor(c))
	}
}

func (ptr *QTextEdit) SetTextCursor(cursor gui.QTextCursor_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetTextCursor(ptr.Pointer(), gui.PointerFromQTextCursor(cursor))
	}
}

func (ptr *QTextEdit) SetTextInteractionFlags(flags core.Qt__TextInteractionFlag) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetTextInteractionFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QTextEdit) SetUndoRedoEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetUndoRedoEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QTextEdit) SetWordWrapMode(policy gui.QTextOption__WrapMode) {
	if ptr.Pointer() != nil {
		C.QTextEdit_SetWordWrapMode(ptr.Pointer(), C.longlong(policy))
	}
}

//export callbackQTextEdit_TextChanged
func callbackQTextEdit_TextChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "textChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QTextEdit) ConnectTextChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "textChanged") {
			C.QTextEdit_ConnectTextChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "textChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "textChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "textChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectTextChanged() {
	if ptr.Pointer() != nil {
		C.QTextEdit_DisconnectTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "textChanged")
	}
}

func (ptr *QTextEdit) TextChanged() {
	if ptr.Pointer() != nil {
		C.QTextEdit_TextChanged(ptr.Pointer())
	}
}

//export callbackQTextEdit_Undo
func callbackQTextEdit_Undo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "undo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextEditFromPointer(ptr).UndoDefault()
	}
}

func (ptr *QTextEdit) ConnectUndo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "undo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectUndo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "undo")
	}
}

func (ptr *QTextEdit) Undo() {
	if ptr.Pointer() != nil {
		C.QTextEdit_Undo(ptr.Pointer())
	}
}

func (ptr *QTextEdit) UndoDefault() {
	if ptr.Pointer() != nil {
		C.QTextEdit_UndoDefault(ptr.Pointer())
	}
}

//export callbackQTextEdit_UndoAvailable
func callbackQTextEdit_UndoAvailable(ptr unsafe.Pointer, available C.char) {
	if signal := qt.GetSignal(ptr, "undoAvailable"); signal != nil {
		(*(*func(bool))(signal))(int8(available) != 0)
	}

}

func (ptr *QTextEdit) ConnectUndoAvailable(f func(available bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "undoAvailable") {
			C.QTextEdit_ConnectUndoAvailable(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "undoAvailable"); signal != nil {
			f := func(available bool) {
				(*(*func(bool))(signal))(available)
				f(available)
			}
			qt.ConnectSignal(ptr.Pointer(), "undoAvailable", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undoAvailable", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectUndoAvailable() {
	if ptr.Pointer() != nil {
		C.QTextEdit_DisconnectUndoAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "undoAvailable")
	}
}

func (ptr *QTextEdit) UndoAvailable(available bool) {
	if ptr.Pointer() != nil {
		C.QTextEdit_UndoAvailable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
	}
}

//export callbackQTextEdit_ZoomIn
func callbackQTextEdit_ZoomIn(ptr unsafe.Pointer, ran C.int) {
	if signal := qt.GetSignal(ptr, "zoomIn"); signal != nil {
		(*(*func(int))(signal))(int(int32(ran)))
	} else {
		NewQTextEditFromPointer(ptr).ZoomInDefault(int(int32(ran)))
	}
}

func (ptr *QTextEdit) ConnectZoomIn(f func(ran int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "zoomIn"); signal != nil {
			f := func(ran int) {
				(*(*func(int))(signal))(ran)
				f(ran)
			}
			qt.ConnectSignal(ptr.Pointer(), "zoomIn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "zoomIn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectZoomIn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "zoomIn")
	}
}

func (ptr *QTextEdit) ZoomIn(ran int) {
	if ptr.Pointer() != nil {
		C.QTextEdit_ZoomIn(ptr.Pointer(), C.int(int32(ran)))
	}
}

func (ptr *QTextEdit) ZoomInDefault(ran int) {
	if ptr.Pointer() != nil {
		C.QTextEdit_ZoomInDefault(ptr.Pointer(), C.int(int32(ran)))
	}
}

//export callbackQTextEdit_ZoomOut
func callbackQTextEdit_ZoomOut(ptr unsafe.Pointer, ran C.int) {
	if signal := qt.GetSignal(ptr, "zoomOut"); signal != nil {
		(*(*func(int))(signal))(int(int32(ran)))
	} else {
		NewQTextEditFromPointer(ptr).ZoomOutDefault(int(int32(ran)))
	}
}

func (ptr *QTextEdit) ConnectZoomOut(f func(ran int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "zoomOut"); signal != nil {
			f := func(ran int) {
				(*(*func(int))(signal))(ran)
				f(ran)
			}
			qt.ConnectSignal(ptr.Pointer(), "zoomOut", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "zoomOut", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectZoomOut() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "zoomOut")
	}
}

func (ptr *QTextEdit) ZoomOut(ran int) {
	if ptr.Pointer() != nil {
		C.QTextEdit_ZoomOut(ptr.Pointer(), C.int(int32(ran)))
	}
}

func (ptr *QTextEdit) ZoomOutDefault(ran int) {
	if ptr.Pointer() != nil {
		C.QTextEdit_ZoomOutDefault(ptr.Pointer(), C.int(int32(ran)))
	}
}

//export callbackQTextEdit_DestroyQTextEdit
func callbackQTextEdit_DestroyQTextEdit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTextEdit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTextEditFromPointer(ptr).DestroyQTextEditDefault()
	}
}

func (ptr *QTextEdit) ConnectDestroyQTextEdit(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTextEdit"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTextEdit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTextEdit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectDestroyQTextEdit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTextEdit")
	}
}

func (ptr *QTextEdit) DestroyQTextEdit() {
	if ptr.Pointer() != nil {
		C.QTextEdit_DestroyQTextEdit(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTextEdit) DestroyQTextEditDefault() {
	if ptr.Pointer() != nil {
		C.QTextEdit_DestroyQTextEditDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTextEdit) TextBackgroundColor() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QTextEdit_TextBackgroundColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) TextColor() *gui.QColor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQColorFromPointer(C.QTextEdit_TextColor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QColor).DestroyQColor)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) CurrentFont() *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QTextEdit_CurrentFont(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

//export callbackQTextEdit_CreateMimeDataFromSelection
func callbackQTextEdit_CreateMimeDataFromSelection(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "createMimeDataFromSelection"); signal != nil {
		return core.PointerFromQMimeData((*(*func() *core.QMimeData)(signal))())
	}

	return core.PointerFromQMimeData(NewQTextEditFromPointer(ptr).CreateMimeDataFromSelectionDefault())
}

func (ptr *QTextEdit) ConnectCreateMimeDataFromSelection(f func() *core.QMimeData) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "createMimeDataFromSelection"); signal != nil {
			f := func() *core.QMimeData {
				(*(*func() *core.QMimeData)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "createMimeDataFromSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "createMimeDataFromSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectCreateMimeDataFromSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "createMimeDataFromSelection")
	}
}

func (ptr *QTextEdit) CreateMimeDataFromSelection() *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QTextEdit_CreateMimeDataFromSelection(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) CreateMimeDataFromSelectionDefault() *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QTextEdit_CreateMimeDataFromSelectionDefault(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) CursorRect2() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QTextEdit_CursorRect2(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) CursorRect(cursor gui.QTextCursor_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QTextEdit_CursorRect(ptr.Pointer(), gui.PointerFromQTextCursor(cursor)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) AnchorAt(pos core.QPoint_ITF) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextEdit_AnchorAt(ptr.Pointer(), core.PointerFromQPoint(pos)))
	}
	return ""
}

func (ptr *QTextEdit) DocumentTitle() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextEdit_DocumentTitle(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextEdit) FontFamily() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextEdit_FontFamily(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextEdit) PlaceholderText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextEdit_PlaceholderText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextEdit) ToHtml() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextEdit_ToHtml(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextEdit) ToPlainText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTextEdit_ToPlainText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextEdit) CurrentCharFormat() *gui.QTextCharFormat {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCharFormatFromPointer(C.QTextEdit_CurrentCharFormat(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCharFormat).DestroyQTextCharFormat)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) CursorForPosition(pos core.QPoint_ITF) *gui.QTextCursor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCursorFromPointer(C.QTextEdit_CursorForPosition(ptr.Pointer(), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCursor).DestroyQTextCursor)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) TextCursor() *gui.QTextCursor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextCursorFromPointer(C.QTextEdit_TextCursor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QTextCursor).DestroyQTextCursor)
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) Document() *gui.QTextDocument {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQTextDocumentFromPointer(C.QTextEdit_Document(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTextEdit) AutoFormatting() QTextEdit__AutoFormattingFlag {
	if ptr.Pointer() != nil {
		return QTextEdit__AutoFormattingFlag(C.QTextEdit_AutoFormatting(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextEdit) LineWrapMode() QTextEdit__LineWrapMode {
	if ptr.Pointer() != nil {
		return QTextEdit__LineWrapMode(C.QTextEdit_LineWrapMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextEdit) WordWrapMode() gui.QTextOption__WrapMode {
	if ptr.Pointer() != nil {
		return gui.QTextOption__WrapMode(C.QTextEdit_WordWrapMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextEdit) Alignment() core.Qt__AlignmentFlag {
	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QTextEdit_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextEdit) TextInteractionFlags() core.Qt__TextInteractionFlag {
	if ptr.Pointer() != nil {
		return core.Qt__TextInteractionFlag(C.QTextEdit_TextInteractionFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextEdit) AcceptRichText() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_AcceptRichText(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQTextEdit_CanInsertFromMimeData
func callbackQTextEdit_CanInsertFromMimeData(ptr unsafe.Pointer, source unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "canInsertFromMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QMimeData) bool)(signal))(core.NewQMimeDataFromPointer(source)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQTextEditFromPointer(ptr).CanInsertFromMimeDataDefault(core.NewQMimeDataFromPointer(source)))))
}

func (ptr *QTextEdit) ConnectCanInsertFromMimeData(f func(source *core.QMimeData) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "canInsertFromMimeData"); signal != nil {
			f := func(source *core.QMimeData) bool {
				(*(*func(*core.QMimeData) bool)(signal))(source)
				return f(source)
			}
			qt.ConnectSignal(ptr.Pointer(), "canInsertFromMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canInsertFromMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTextEdit) DisconnectCanInsertFromMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "canInsertFromMimeData")
	}
}

func (ptr *QTextEdit) CanInsertFromMimeData(source core.QMimeData_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_CanInsertFromMimeData(ptr.Pointer(), core.PointerFromQMimeData(source))) != 0
	}
	return false
}

func (ptr *QTextEdit) CanInsertFromMimeDataDefault(source core.QMimeData_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_CanInsertFromMimeDataDefault(ptr.Pointer(), core.PointerFromQMimeData(source))) != 0
	}
	return false
}

func (ptr *QTextEdit) CanPaste() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_CanPaste(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextEdit) FontItalic() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_FontItalic(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextEdit) FontUnderline() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_FontUnderline(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextEdit) IsReadOnly() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_IsReadOnly(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextEdit) IsUndoRedoEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_IsUndoRedoEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextEdit) OverwriteMode() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_OverwriteMode(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextEdit) TabChangesFocus() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTextEdit_TabChangesFocus(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTextEdit) CursorWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextEdit_CursorWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextEdit) FontWeight() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextEdit_FontWeight(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextEdit) LineWrapColumnOrWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextEdit_LineWrapColumnOrWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextEdit) TabStopWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTextEdit_TabStopWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTextEdit) FontPointSize() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QTextEdit_FontPointSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextEdit) TabStopDistance() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QTextEdit_TabStopDistance(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextEdit) Print(printer gui.QPagedPaintDevice_ITF) {
	if ptr.Pointer() != nil {
		C.QTextEdit_Print(ptr.Pointer(), gui.PointerFromQPagedPaintDevice(printer))
	}
}

type QTileRules struct {
	ptr unsafe.Pointer
}

type QTileRules_ITF interface {
	QTileRules_PTR() *QTileRules
}

func (ptr *QTileRules) QTileRules_PTR() *QTileRules {
	return ptr
}

func (ptr *QTileRules) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QTileRules) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQTileRules(ptr QTileRules_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTileRules_PTR().Pointer()
	}
	return nil
}

func NewQTileRulesFromPointer(ptr unsafe.Pointer) (n *QTileRules) {
	n = new(QTileRules)
	n.SetPointer(ptr)
	return
}

func (ptr *QTileRules) DestroyQTileRules() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func NewQTileRules(horizontalRule core.Qt__TileRule, verticalRule core.Qt__TileRule) *QTileRules {
	tmpValue := NewQTileRulesFromPointer(C.QTileRules_NewQTileRules(C.longlong(horizontalRule), C.longlong(verticalRule)))
	runtime.SetFinalizer(tmpValue, (*QTileRules).DestroyQTileRules)
	return tmpValue
}

func NewQTileRules2(rule core.Qt__TileRule) *QTileRules {
	tmpValue := NewQTileRulesFromPointer(C.QTileRules_NewQTileRules2(C.longlong(rule)))
	runtime.SetFinalizer(tmpValue, (*QTileRules).DestroyQTileRules)
	return tmpValue
}

func (ptr *QTileRules) Horizontal() core.Qt__TileRule {
	if ptr.Pointer() != nil {
		return core.Qt__TileRule(C.QTileRules_Horizontal(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTileRules) SetHorizontal(vqt core.Qt__TileRule) {
	if ptr.Pointer() != nil {
		C.QTileRules_SetHorizontal(ptr.Pointer(), C.longlong(vqt))
	}
}

func (ptr *QTileRules) Vertical() core.Qt__TileRule {
	if ptr.Pointer() != nil {
		return core.Qt__TileRule(C.QTileRules_Vertical(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTileRules) SetVertical(vqt core.Qt__TileRule) {
	if ptr.Pointer() != nil {
		C.QTileRules_SetVertical(ptr.Pointer(), C.longlong(vqt))
	}
}

type QTimeEdit struct {
	QDateTimeEdit
}

type QTimeEdit_ITF interface {
	QDateTimeEdit_ITF
	QTimeEdit_PTR() *QTimeEdit
}

func (ptr *QTimeEdit) QTimeEdit_PTR() *QTimeEdit {
	return ptr
}

func (ptr *QTimeEdit) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QDateTimeEdit_PTR().Pointer()
	}
	return nil
}

func (ptr *QTimeEdit) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QDateTimeEdit_PTR().SetPointer(p)
	}
}

func PointerFromQTimeEdit(ptr QTimeEdit_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTimeEdit_PTR().Pointer()
	}
	return nil
}

func NewQTimeEditFromPointer(ptr unsafe.Pointer) (n *QTimeEdit) {
	n = new(QTimeEdit)
	n.SetPointer(ptr)
	return
}
func NewQTimeEdit(parent QWidget_ITF) *QTimeEdit {
	tmpValue := NewQTimeEditFromPointer(C.QTimeEdit_NewQTimeEdit(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQTimeEdit2(ti core.QTime_ITF, parent QWidget_ITF) *QTimeEdit {
	tmpValue := NewQTimeEditFromPointer(C.QTimeEdit_NewQTimeEdit2(core.PointerFromQTime(ti), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQTimeEdit_DestroyQTimeEdit
func callbackQTimeEdit_DestroyQTimeEdit(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTimeEdit"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTimeEditFromPointer(ptr).DestroyQTimeEditDefault()
	}
}

func (ptr *QTimeEdit) ConnectDestroyQTimeEdit(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTimeEdit"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTimeEdit", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTimeEdit", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTimeEdit) DisconnectDestroyQTimeEdit() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTimeEdit")
	}
}

func (ptr *QTimeEdit) DestroyQTimeEdit() {
	if ptr.Pointer() != nil {
		C.QTimeEdit_DestroyQTimeEdit(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTimeEdit) DestroyQTimeEditDefault() {
	if ptr.Pointer() != nil {
		C.QTimeEdit_DestroyQTimeEditDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QToolBar struct {
	QWidget
}

type QToolBar_ITF interface {
	QWidget_ITF
	QToolBar_PTR() *QToolBar
}

func (ptr *QToolBar) QToolBar_PTR() *QToolBar {
	return ptr
}

func (ptr *QToolBar) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QToolBar) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQToolBar(ptr QToolBar_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QToolBar_PTR().Pointer()
	}
	return nil
}

func NewQToolBarFromPointer(ptr unsafe.Pointer) (n *QToolBar) {
	n = new(QToolBar)
	n.SetPointer(ptr)
	return
}
func (ptr *QToolBar) AddAction2(icon gui.QIcon_ITF, text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QToolBar_AddAction2(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) AddAction4(icon gui.QIcon_ITF, text string, receiver core.QObject_ITF, member string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		tmpValue := NewQActionFromPointer(C.QToolBar_AddAction4(ptr.Pointer(), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQObject(receiver), memberC))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) AddAction(text string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		tmpValue := NewQActionFromPointer(C.QToolBar_AddAction(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) AddAction3(text string, receiver core.QObject_ITF, member string) *QAction {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		var memberC *C.char
		if member != "" {
			memberC = C.CString(member)
			defer C.free(unsafe.Pointer(memberC))
		}
		tmpValue := NewQActionFromPointer(C.QToolBar_AddAction3(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, core.PointerFromQObject(receiver), memberC))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) AddSeparator() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QToolBar_AddSeparator(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) AddWidget(widget QWidget_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QToolBar_AddWidget(ptr.Pointer(), PointerFromQWidget(widget)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) InsertSeparator(before QAction_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QToolBar_InsertSeparator(ptr.Pointer(), PointerFromQAction(before)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) InsertWidget(before QAction_ITF, widget QWidget_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QToolBar_InsertWidget(ptr.Pointer(), PointerFromQAction(before), PointerFromQWidget(widget)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQToolBar2(parent QWidget_ITF) *QToolBar {
	tmpValue := NewQToolBarFromPointer(C.QToolBar_NewQToolBar2(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQToolBar(title string, parent QWidget_ITF) *QToolBar {
	var titleC *C.char
	if title != "" {
		titleC = C.CString(title)
		defer C.free(unsafe.Pointer(titleC))
	}
	tmpValue := NewQToolBarFromPointer(C.QToolBar_NewQToolBar(C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))}, PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQToolBar_ActionTriggered
func callbackQToolBar_ActionTriggered(ptr unsafe.Pointer, action unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "actionTriggered"); signal != nil {
		(*(*func(*QAction))(signal))(NewQActionFromPointer(action))
	}

}

func (ptr *QToolBar) ConnectActionTriggered(f func(action *QAction)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "actionTriggered") {
			C.QToolBar_ConnectActionTriggered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "actionTriggered"); signal != nil {
			f := func(action *QAction) {
				(*(*func(*QAction))(signal))(action)
				f(action)
			}
			qt.ConnectSignal(ptr.Pointer(), "actionTriggered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "actionTriggered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectActionTriggered() {
	if ptr.Pointer() != nil {
		C.QToolBar_DisconnectActionTriggered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "actionTriggered")
	}
}

func (ptr *QToolBar) ActionTriggered(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QToolBar_ActionTriggered(ptr.Pointer(), PointerFromQAction(action))
	}
}

//export callbackQToolBar_AllowedAreasChanged
func callbackQToolBar_AllowedAreasChanged(ptr unsafe.Pointer, allowedAreas C.longlong) {
	if signal := qt.GetSignal(ptr, "allowedAreasChanged"); signal != nil {
		(*(*func(core.Qt__ToolBarArea))(signal))(core.Qt__ToolBarArea(allowedAreas))
	}

}

func (ptr *QToolBar) ConnectAllowedAreasChanged(f func(allowedAreas core.Qt__ToolBarArea)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "allowedAreasChanged") {
			C.QToolBar_ConnectAllowedAreasChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "allowedAreasChanged"); signal != nil {
			f := func(allowedAreas core.Qt__ToolBarArea) {
				(*(*func(core.Qt__ToolBarArea))(signal))(allowedAreas)
				f(allowedAreas)
			}
			qt.ConnectSignal(ptr.Pointer(), "allowedAreasChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "allowedAreasChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectAllowedAreasChanged() {
	if ptr.Pointer() != nil {
		C.QToolBar_DisconnectAllowedAreasChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "allowedAreasChanged")
	}
}

func (ptr *QToolBar) AllowedAreasChanged(allowedAreas core.Qt__ToolBarArea) {
	if ptr.Pointer() != nil {
		C.QToolBar_AllowedAreasChanged(ptr.Pointer(), C.longlong(allowedAreas))
	}
}

func (ptr *QToolBar) Clear() {
	if ptr.Pointer() != nil {
		C.QToolBar_Clear(ptr.Pointer())
	}
}

//export callbackQToolBar_IconSizeChanged
func callbackQToolBar_IconSizeChanged(ptr unsafe.Pointer, iconSize unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "iconSizeChanged"); signal != nil {
		(*(*func(*core.QSize))(signal))(core.NewQSizeFromPointer(iconSize))
	}

}

func (ptr *QToolBar) ConnectIconSizeChanged(f func(iconSize *core.QSize)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "iconSizeChanged") {
			C.QToolBar_ConnectIconSizeChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "iconSizeChanged"); signal != nil {
			f := func(iconSize *core.QSize) {
				(*(*func(*core.QSize))(signal))(iconSize)
				f(iconSize)
			}
			qt.ConnectSignal(ptr.Pointer(), "iconSizeChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "iconSizeChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectIconSizeChanged() {
	if ptr.Pointer() != nil {
		C.QToolBar_DisconnectIconSizeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "iconSizeChanged")
	}
}

func (ptr *QToolBar) IconSizeChanged(iconSize core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QToolBar_IconSizeChanged(ptr.Pointer(), core.PointerFromQSize(iconSize))
	}
}

//export callbackQToolBar_MovableChanged
func callbackQToolBar_MovableChanged(ptr unsafe.Pointer, movable C.char) {
	if signal := qt.GetSignal(ptr, "movableChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(movable) != 0)
	}

}

func (ptr *QToolBar) ConnectMovableChanged(f func(movable bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "movableChanged") {
			C.QToolBar_ConnectMovableChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "movableChanged"); signal != nil {
			f := func(movable bool) {
				(*(*func(bool))(signal))(movable)
				f(movable)
			}
			qt.ConnectSignal(ptr.Pointer(), "movableChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "movableChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectMovableChanged() {
	if ptr.Pointer() != nil {
		C.QToolBar_DisconnectMovableChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "movableChanged")
	}
}

func (ptr *QToolBar) MovableChanged(movable bool) {
	if ptr.Pointer() != nil {
		C.QToolBar_MovableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(movable))))
	}
}

//export callbackQToolBar_OrientationChanged
func callbackQToolBar_OrientationChanged(ptr unsafe.Pointer, orientation C.longlong) {
	if signal := qt.GetSignal(ptr, "orientationChanged"); signal != nil {
		(*(*func(core.Qt__Orientation))(signal))(core.Qt__Orientation(orientation))
	}

}

func (ptr *QToolBar) ConnectOrientationChanged(f func(orientation core.Qt__Orientation)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "orientationChanged") {
			C.QToolBar_ConnectOrientationChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "orientationChanged"); signal != nil {
			f := func(orientation core.Qt__Orientation) {
				(*(*func(core.Qt__Orientation))(signal))(orientation)
				f(orientation)
			}
			qt.ConnectSignal(ptr.Pointer(), "orientationChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "orientationChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectOrientationChanged() {
	if ptr.Pointer() != nil {
		C.QToolBar_DisconnectOrientationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "orientationChanged")
	}
}

func (ptr *QToolBar) OrientationChanged(orientation core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QToolBar_OrientationChanged(ptr.Pointer(), C.longlong(orientation))
	}
}

func (ptr *QToolBar) SetAllowedAreas(areas core.Qt__ToolBarArea) {
	if ptr.Pointer() != nil {
		C.QToolBar_SetAllowedAreas(ptr.Pointer(), C.longlong(areas))
	}
}

func (ptr *QToolBar) SetFloatable(floatable bool) {
	if ptr.Pointer() != nil {
		C.QToolBar_SetFloatable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(floatable))))
	}
}

//export callbackQToolBar_SetIconSize
func callbackQToolBar_SetIconSize(ptr unsafe.Pointer, iconSize unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setIconSize"); signal != nil {
		(*(*func(*core.QSize))(signal))(core.NewQSizeFromPointer(iconSize))
	} else {
		NewQToolBarFromPointer(ptr).SetIconSizeDefault(core.NewQSizeFromPointer(iconSize))
	}
}

func (ptr *QToolBar) ConnectSetIconSize(f func(iconSize *core.QSize)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setIconSize"); signal != nil {
			f := func(iconSize *core.QSize) {
				(*(*func(*core.QSize))(signal))(iconSize)
				f(iconSize)
			}
			qt.ConnectSignal(ptr.Pointer(), "setIconSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setIconSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectSetIconSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setIconSize")
	}
}

func (ptr *QToolBar) SetIconSize(iconSize core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QToolBar_SetIconSize(ptr.Pointer(), core.PointerFromQSize(iconSize))
	}
}

func (ptr *QToolBar) SetIconSizeDefault(iconSize core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QToolBar_SetIconSizeDefault(ptr.Pointer(), core.PointerFromQSize(iconSize))
	}
}

func (ptr *QToolBar) SetMovable(movable bool) {
	if ptr.Pointer() != nil {
		C.QToolBar_SetMovable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(movable))))
	}
}

func (ptr *QToolBar) SetOrientation(orientation core.Qt__Orientation) {
	if ptr.Pointer() != nil {
		C.QToolBar_SetOrientation(ptr.Pointer(), C.longlong(orientation))
	}
}

//export callbackQToolBar_SetToolButtonStyle
func callbackQToolBar_SetToolButtonStyle(ptr unsafe.Pointer, toolButtonStyle C.longlong) {
	if signal := qt.GetSignal(ptr, "setToolButtonStyle"); signal != nil {
		(*(*func(core.Qt__ToolButtonStyle))(signal))(core.Qt__ToolButtonStyle(toolButtonStyle))
	} else {
		NewQToolBarFromPointer(ptr).SetToolButtonStyleDefault(core.Qt__ToolButtonStyle(toolButtonStyle))
	}
}

func (ptr *QToolBar) ConnectSetToolButtonStyle(f func(toolButtonStyle core.Qt__ToolButtonStyle)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setToolButtonStyle"); signal != nil {
			f := func(toolButtonStyle core.Qt__ToolButtonStyle) {
				(*(*func(core.Qt__ToolButtonStyle))(signal))(toolButtonStyle)
				f(toolButtonStyle)
			}
			qt.ConnectSignal(ptr.Pointer(), "setToolButtonStyle", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setToolButtonStyle", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectSetToolButtonStyle() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setToolButtonStyle")
	}
}

func (ptr *QToolBar) SetToolButtonStyle(toolButtonStyle core.Qt__ToolButtonStyle) {
	if ptr.Pointer() != nil {
		C.QToolBar_SetToolButtonStyle(ptr.Pointer(), C.longlong(toolButtonStyle))
	}
}

func (ptr *QToolBar) SetToolButtonStyleDefault(toolButtonStyle core.Qt__ToolButtonStyle) {
	if ptr.Pointer() != nil {
		C.QToolBar_SetToolButtonStyleDefault(ptr.Pointer(), C.longlong(toolButtonStyle))
	}
}

//export callbackQToolBar_ToolButtonStyleChanged
func callbackQToolBar_ToolButtonStyleChanged(ptr unsafe.Pointer, toolButtonStyle C.longlong) {
	if signal := qt.GetSignal(ptr, "toolButtonStyleChanged"); signal != nil {
		(*(*func(core.Qt__ToolButtonStyle))(signal))(core.Qt__ToolButtonStyle(toolButtonStyle))
	}

}

func (ptr *QToolBar) ConnectToolButtonStyleChanged(f func(toolButtonStyle core.Qt__ToolButtonStyle)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "toolButtonStyleChanged") {
			C.QToolBar_ConnectToolButtonStyleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "toolButtonStyleChanged"); signal != nil {
			f := func(toolButtonStyle core.Qt__ToolButtonStyle) {
				(*(*func(core.Qt__ToolButtonStyle))(signal))(toolButtonStyle)
				f(toolButtonStyle)
			}
			qt.ConnectSignal(ptr.Pointer(), "toolButtonStyleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "toolButtonStyleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectToolButtonStyleChanged() {
	if ptr.Pointer() != nil {
		C.QToolBar_DisconnectToolButtonStyleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "toolButtonStyleChanged")
	}
}

func (ptr *QToolBar) ToolButtonStyleChanged(toolButtonStyle core.Qt__ToolButtonStyle) {
	if ptr.Pointer() != nil {
		C.QToolBar_ToolButtonStyleChanged(ptr.Pointer(), C.longlong(toolButtonStyle))
	}
}

//export callbackQToolBar_TopLevelChanged
func callbackQToolBar_TopLevelChanged(ptr unsafe.Pointer, topLevel C.char) {
	if signal := qt.GetSignal(ptr, "topLevelChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(topLevel) != 0)
	}

}

func (ptr *QToolBar) ConnectTopLevelChanged(f func(topLevel bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "topLevelChanged") {
			C.QToolBar_ConnectTopLevelChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "topLevelChanged"); signal != nil {
			f := func(topLevel bool) {
				(*(*func(bool))(signal))(topLevel)
				f(topLevel)
			}
			qt.ConnectSignal(ptr.Pointer(), "topLevelChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "topLevelChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectTopLevelChanged() {
	if ptr.Pointer() != nil {
		C.QToolBar_DisconnectTopLevelChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "topLevelChanged")
	}
}

func (ptr *QToolBar) TopLevelChanged(topLevel bool) {
	if ptr.Pointer() != nil {
		C.QToolBar_TopLevelChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(topLevel))))
	}
}

//export callbackQToolBar_VisibilityChanged
func callbackQToolBar_VisibilityChanged(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(ptr, "visibilityChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(visible) != 0)
	}

}

func (ptr *QToolBar) ConnectVisibilityChanged(f func(visible bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "visibilityChanged") {
			C.QToolBar_ConnectVisibilityChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "visibilityChanged"); signal != nil {
			f := func(visible bool) {
				(*(*func(bool))(signal))(visible)
				f(visible)
			}
			qt.ConnectSignal(ptr.Pointer(), "visibilityChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "visibilityChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectVisibilityChanged() {
	if ptr.Pointer() != nil {
		C.QToolBar_DisconnectVisibilityChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "visibilityChanged")
	}
}

func (ptr *QToolBar) VisibilityChanged(visible bool) {
	if ptr.Pointer() != nil {
		C.QToolBar_VisibilityChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

//export callbackQToolBar_DestroyQToolBar
func callbackQToolBar_DestroyQToolBar(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QToolBar"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQToolBarFromPointer(ptr).DestroyQToolBarDefault()
	}
}

func (ptr *QToolBar) ConnectDestroyQToolBar(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QToolBar"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QToolBar", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QToolBar", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBar) DisconnectDestroyQToolBar() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QToolBar")
	}
}

func (ptr *QToolBar) DestroyQToolBar() {
	if ptr.Pointer() != nil {
		C.QToolBar_DestroyQToolBar(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QToolBar) DestroyQToolBarDefault() {
	if ptr.Pointer() != nil {
		C.QToolBar_DestroyQToolBarDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QToolBar) ActionAt(p core.QPoint_ITF) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QToolBar_ActionAt(ptr.Pointer(), core.PointerFromQPoint(p)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) ActionAt2(x int, y int) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QToolBar_ActionAt2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) ToggleViewAction() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QToolBar_ToggleViewAction(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) IconSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QToolBar_IconSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) WidgetForAction(action QAction_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QToolBar_WidgetForAction(ptr.Pointer(), PointerFromQAction(action)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBar) Orientation() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QToolBar_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QToolBar) AllowedAreas() core.Qt__ToolBarArea {
	if ptr.Pointer() != nil {
		return core.Qt__ToolBarArea(C.QToolBar_AllowedAreas(ptr.Pointer()))
	}
	return 0
}

func (ptr *QToolBar) ToolButtonStyle() core.Qt__ToolButtonStyle {
	if ptr.Pointer() != nil {
		return core.Qt__ToolButtonStyle(C.QToolBar_ToolButtonStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QToolBar) IsAreaAllowed(area core.Qt__ToolBarArea) bool {
	if ptr.Pointer() != nil {
		return int8(C.QToolBar_IsAreaAllowed(ptr.Pointer(), C.longlong(area))) != 0
	}
	return false
}

func (ptr *QToolBar) IsFloatable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QToolBar_IsFloatable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QToolBar) IsFloating() bool {
	if ptr.Pointer() != nil {
		return int8(C.QToolBar_IsFloating(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QToolBar) IsMovable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QToolBar_IsMovable(ptr.Pointer())) != 0
	}
	return false
}

type QToolBox struct {
	QFrame
}

type QToolBox_ITF interface {
	QFrame_ITF
	QToolBox_PTR() *QToolBox
}

func (ptr *QToolBox) QToolBox_PTR() *QToolBox {
	return ptr
}

func (ptr *QToolBox) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QFrame_PTR().Pointer()
	}
	return nil
}

func (ptr *QToolBox) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QFrame_PTR().SetPointer(p)
	}
}

func PointerFromQToolBox(ptr QToolBox_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QToolBox_PTR().Pointer()
	}
	return nil
}

func NewQToolBoxFromPointer(ptr unsafe.Pointer) (n *QToolBox) {
	n = new(QToolBox)
	n.SetPointer(ptr)
	return
}
func NewQToolBox(parent QWidget_ITF, ff core.Qt__WindowType) *QToolBox {
	tmpValue := NewQToolBoxFromPointer(C.QToolBox_NewQToolBox(PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QToolBox) AddItem2(w QWidget_ITF, text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QToolBox_AddItem2(ptr.Pointer(), PointerFromQWidget(w), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

func (ptr *QToolBox) AddItem(widget QWidget_ITF, iconSet gui.QIcon_ITF, text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QToolBox_AddItem(ptr.Pointer(), PointerFromQWidget(widget), gui.PointerFromQIcon(iconSet), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

func (ptr *QToolBox) InsertItem(index int, widget QWidget_ITF, icon gui.QIcon_ITF, text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QToolBox_InsertItem(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(widget), gui.PointerFromQIcon(icon), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

func (ptr *QToolBox) InsertItem2(index int, widget QWidget_ITF, text string) int {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return int(int32(C.QToolBox_InsertItem2(ptr.Pointer(), C.int(int32(index)), PointerFromQWidget(widget), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})))
	}
	return 0
}

//export callbackQToolBox_CurrentChanged
func callbackQToolBox_CurrentChanged(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	}

}

func (ptr *QToolBox) ConnectCurrentChanged(f func(index int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentChanged") {
			C.QToolBox_ConnectCurrentChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBox) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {
		C.QToolBox_DisconnectCurrentChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QToolBox) CurrentChanged(index int) {
	if ptr.Pointer() != nil {
		C.QToolBox_CurrentChanged(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQToolBox_ItemInserted
func callbackQToolBox_ItemInserted(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "itemInserted"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQToolBoxFromPointer(ptr).ItemInsertedDefault(int(int32(index)))
	}
}

func (ptr *QToolBox) ConnectItemInserted(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemInserted"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBox) DisconnectItemInserted() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemInserted")
	}
}

func (ptr *QToolBox) ItemInserted(index int) {
	if ptr.Pointer() != nil {
		C.QToolBox_ItemInserted(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QToolBox) ItemInsertedDefault(index int) {
	if ptr.Pointer() != nil {
		C.QToolBox_ItemInsertedDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQToolBox_ItemRemoved
func callbackQToolBox_ItemRemoved(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "itemRemoved"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQToolBoxFromPointer(ptr).ItemRemovedDefault(int(int32(index)))
	}
}

func (ptr *QToolBox) ConnectItemRemoved(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "itemRemoved"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBox) DisconnectItemRemoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "itemRemoved")
	}
}

func (ptr *QToolBox) ItemRemoved(index int) {
	if ptr.Pointer() != nil {
		C.QToolBox_ItemRemoved(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QToolBox) ItemRemovedDefault(index int) {
	if ptr.Pointer() != nil {
		C.QToolBox_ItemRemovedDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QToolBox) RemoveItem(index int) {
	if ptr.Pointer() != nil {
		C.QToolBox_RemoveItem(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQToolBox_SetCurrentIndex
func callbackQToolBox_SetCurrentIndex(ptr unsafe.Pointer, index C.int) {
	if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
		(*(*func(int))(signal))(int(int32(index)))
	} else {
		NewQToolBoxFromPointer(ptr).SetCurrentIndexDefault(int(int32(index)))
	}
}

func (ptr *QToolBox) ConnectSetCurrentIndex(f func(index int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentIndex"); signal != nil {
			f := func(index int) {
				(*(*func(int))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBox) DisconnectSetCurrentIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentIndex")
	}
}

func (ptr *QToolBox) SetCurrentIndex(index int) {
	if ptr.Pointer() != nil {
		C.QToolBox_SetCurrentIndex(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QToolBox) SetCurrentIndexDefault(index int) {
	if ptr.Pointer() != nil {
		C.QToolBox_SetCurrentIndexDefault(ptr.Pointer(), C.int(int32(index)))
	}
}

//export callbackQToolBox_SetCurrentWidget
func callbackQToolBox_SetCurrentWidget(ptr unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setCurrentWidget"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(widget))
	} else {
		NewQToolBoxFromPointer(ptr).SetCurrentWidgetDefault(NewQWidgetFromPointer(widget))
	}
}

func (ptr *QToolBox) ConnectSetCurrentWidget(f func(widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setCurrentWidget"); signal != nil {
			f := func(widget *QWidget) {
				(*(*func(*QWidget))(signal))(widget)
				f(widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "setCurrentWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setCurrentWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBox) DisconnectSetCurrentWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setCurrentWidget")
	}
}

func (ptr *QToolBox) SetCurrentWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QToolBox_SetCurrentWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QToolBox) SetCurrentWidgetDefault(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QToolBox_SetCurrentWidgetDefault(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QToolBox) SetItemEnabled(index int, enabled bool) {
	if ptr.Pointer() != nil {
		C.QToolBox_SetItemEnabled(ptr.Pointer(), C.int(int32(index)), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QToolBox) SetItemIcon(index int, icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QToolBox_SetItemIcon(ptr.Pointer(), C.int(int32(index)), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QToolBox) SetItemText(index int, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QToolBox_SetItemText(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QToolBox) SetItemToolTip(index int, toolTip string) {
	if ptr.Pointer() != nil {
		var toolTipC *C.char
		if toolTip != "" {
			toolTipC = C.CString(toolTip)
			defer C.free(unsafe.Pointer(toolTipC))
		}
		C.QToolBox_SetItemToolTip(ptr.Pointer(), C.int(int32(index)), C.struct_QtWidgets_PackedString{data: toolTipC, len: C.longlong(len(toolTip))})
	}
}

//export callbackQToolBox_DestroyQToolBox
func callbackQToolBox_DestroyQToolBox(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QToolBox"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQToolBoxFromPointer(ptr).DestroyQToolBoxDefault()
	}
}

func (ptr *QToolBox) ConnectDestroyQToolBox(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QToolBox"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QToolBox", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QToolBox", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolBox) DisconnectDestroyQToolBox() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QToolBox")
	}
}

func (ptr *QToolBox) DestroyQToolBox() {
	if ptr.Pointer() != nil {
		C.QToolBox_DestroyQToolBox(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QToolBox) DestroyQToolBoxDefault() {
	if ptr.Pointer() != nil {
		C.QToolBox_DestroyQToolBoxDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QToolBox) ItemIcon(index int) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QToolBox_ItemIcon(ptr.Pointer(), C.int(int32(index))))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QToolBox) ItemText(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QToolBox_ItemText(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QToolBox) ItemToolTip(index int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QToolBox_ItemToolTip(ptr.Pointer(), C.int(int32(index))))
	}
	return ""
}

func (ptr *QToolBox) CurrentWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QToolBox_CurrentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBox) Widget(index int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QToolBox_Widget(ptr.Pointer(), C.int(int32(index))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolBox) IsItemEnabled(index int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QToolBox_IsItemEnabled(ptr.Pointer(), C.int(int32(index)))) != 0
	}
	return false
}

func (ptr *QToolBox) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QToolBox_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QToolBox) CurrentIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QToolBox_CurrentIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QToolBox) IndexOf(widget QWidget_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QToolBox_IndexOf(ptr.Pointer(), PointerFromQWidget(widget))))
	}
	return 0
}

type QToolButton struct {
	QAbstractButton
}

type QToolButton_ITF interface {
	QAbstractButton_ITF
	QToolButton_PTR() *QToolButton
}

func (ptr *QToolButton) QToolButton_PTR() *QToolButton {
	return ptr
}

func (ptr *QToolButton) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractButton_PTR().Pointer()
	}
	return nil
}

func (ptr *QToolButton) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractButton_PTR().SetPointer(p)
	}
}

func PointerFromQToolButton(ptr QToolButton_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QToolButton_PTR().Pointer()
	}
	return nil
}

func NewQToolButtonFromPointer(ptr unsafe.Pointer) (n *QToolButton) {
	n = new(QToolButton)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QToolButton__ToolButtonPopupMode
//QToolButton::ToolButtonPopupMode
type QToolButton__ToolButtonPopupMode int64

const (
	QToolButton__DelayedPopup    QToolButton__ToolButtonPopupMode = QToolButton__ToolButtonPopupMode(0)
	QToolButton__MenuButtonPopup QToolButton__ToolButtonPopupMode = QToolButton__ToolButtonPopupMode(1)
	QToolButton__InstantPopup    QToolButton__ToolButtonPopupMode = QToolButton__ToolButtonPopupMode(2)
)

func NewQToolButton(parent QWidget_ITF) *QToolButton {
	tmpValue := NewQToolButtonFromPointer(C.QToolButton_NewQToolButton(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQToolButton_PaintEvent
func callbackQToolButton_PaintEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paintEvent"); signal != nil {
		(*(*func(*gui.QPaintEvent))(signal))(gui.NewQPaintEventFromPointer(event))
	} else {
		NewQToolButtonFromPointer(ptr).PaintEventDefault(gui.NewQPaintEventFromPointer(event))
	}
}

func (ptr *QToolButton) ConnectPaintEvent(f func(event *gui.QPaintEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paintEvent"); signal != nil {
			f := func(event *gui.QPaintEvent) {
				(*(*func(*gui.QPaintEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolButton) DisconnectPaintEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paintEvent")
	}
}

func (ptr *QToolButton) PaintEvent(event gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QToolButton_PaintEvent(ptr.Pointer(), gui.PointerFromQPaintEvent(event))
	}
}

func (ptr *QToolButton) PaintEventDefault(event gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QToolButton_PaintEventDefault(ptr.Pointer(), gui.PointerFromQPaintEvent(event))
	}
}

func (ptr *QToolButton) SetArrowType(ty core.Qt__ArrowType) {
	if ptr.Pointer() != nil {
		C.QToolButton_SetArrowType(ptr.Pointer(), C.longlong(ty))
	}
}

func (ptr *QToolButton) SetAutoRaise(enable bool) {
	if ptr.Pointer() != nil {
		C.QToolButton_SetAutoRaise(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQToolButton_SetDefaultAction
func callbackQToolButton_SetDefaultAction(ptr unsafe.Pointer, action unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setDefaultAction"); signal != nil {
		(*(*func(*QAction))(signal))(NewQActionFromPointer(action))
	} else {
		NewQToolButtonFromPointer(ptr).SetDefaultActionDefault(NewQActionFromPointer(action))
	}
}

func (ptr *QToolButton) ConnectSetDefaultAction(f func(action *QAction)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setDefaultAction"); signal != nil {
			f := func(action *QAction) {
				(*(*func(*QAction))(signal))(action)
				f(action)
			}
			qt.ConnectSignal(ptr.Pointer(), "setDefaultAction", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setDefaultAction", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolButton) DisconnectSetDefaultAction() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setDefaultAction")
	}
}

func (ptr *QToolButton) SetDefaultAction(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QToolButton_SetDefaultAction(ptr.Pointer(), PointerFromQAction(action))
	}
}

func (ptr *QToolButton) SetDefaultActionDefault(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QToolButton_SetDefaultActionDefault(ptr.Pointer(), PointerFromQAction(action))
	}
}

func (ptr *QToolButton) SetMenu(menu QMenu_ITF) {
	if ptr.Pointer() != nil {
		C.QToolButton_SetMenu(ptr.Pointer(), PointerFromQMenu(menu))
	}
}

func (ptr *QToolButton) SetPopupMode(mode QToolButton__ToolButtonPopupMode) {
	if ptr.Pointer() != nil {
		C.QToolButton_SetPopupMode(ptr.Pointer(), C.longlong(mode))
	}
}

//export callbackQToolButton_SetToolButtonStyle
func callbackQToolButton_SetToolButtonStyle(ptr unsafe.Pointer, style C.longlong) {
	if signal := qt.GetSignal(ptr, "setToolButtonStyle"); signal != nil {
		(*(*func(core.Qt__ToolButtonStyle))(signal))(core.Qt__ToolButtonStyle(style))
	} else {
		NewQToolButtonFromPointer(ptr).SetToolButtonStyleDefault(core.Qt__ToolButtonStyle(style))
	}
}

func (ptr *QToolButton) ConnectSetToolButtonStyle(f func(style core.Qt__ToolButtonStyle)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setToolButtonStyle"); signal != nil {
			f := func(style core.Qt__ToolButtonStyle) {
				(*(*func(core.Qt__ToolButtonStyle))(signal))(style)
				f(style)
			}
			qt.ConnectSignal(ptr.Pointer(), "setToolButtonStyle", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setToolButtonStyle", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolButton) DisconnectSetToolButtonStyle() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setToolButtonStyle")
	}
}

func (ptr *QToolButton) SetToolButtonStyle(style core.Qt__ToolButtonStyle) {
	if ptr.Pointer() != nil {
		C.QToolButton_SetToolButtonStyle(ptr.Pointer(), C.longlong(style))
	}
}

func (ptr *QToolButton) SetToolButtonStyleDefault(style core.Qt__ToolButtonStyle) {
	if ptr.Pointer() != nil {
		C.QToolButton_SetToolButtonStyleDefault(ptr.Pointer(), C.longlong(style))
	}
}

//export callbackQToolButton_ShowMenu
func callbackQToolButton_ShowMenu(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showMenu"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQToolButtonFromPointer(ptr).ShowMenuDefault()
	}
}

func (ptr *QToolButton) ConnectShowMenu(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMenu"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "showMenu", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMenu", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolButton) DisconnectShowMenu() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMenu")
	}
}

func (ptr *QToolButton) ShowMenu() {
	if ptr.Pointer() != nil {
		C.QToolButton_ShowMenu(ptr.Pointer())
	}
}

func (ptr *QToolButton) ShowMenuDefault() {
	if ptr.Pointer() != nil {
		C.QToolButton_ShowMenuDefault(ptr.Pointer())
	}
}

//export callbackQToolButton_Triggered
func callbackQToolButton_Triggered(ptr unsafe.Pointer, action unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "triggered"); signal != nil {
		(*(*func(*QAction))(signal))(NewQActionFromPointer(action))
	}

}

func (ptr *QToolButton) ConnectTriggered(f func(action *QAction)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "triggered") {
			C.QToolButton_ConnectTriggered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "triggered"); signal != nil {
			f := func(action *QAction) {
				(*(*func(*QAction))(signal))(action)
				f(action)
			}
			qt.ConnectSignal(ptr.Pointer(), "triggered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "triggered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolButton) DisconnectTriggered() {
	if ptr.Pointer() != nil {
		C.QToolButton_DisconnectTriggered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "triggered")
	}
}

func (ptr *QToolButton) Triggered(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QToolButton_Triggered(ptr.Pointer(), PointerFromQAction(action))
	}
}

//export callbackQToolButton_DestroyQToolButton
func callbackQToolButton_DestroyQToolButton(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QToolButton"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQToolButtonFromPointer(ptr).DestroyQToolButtonDefault()
	}
}

func (ptr *QToolButton) ConnectDestroyQToolButton(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QToolButton"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QToolButton", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QToolButton", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QToolButton) DisconnectDestroyQToolButton() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QToolButton")
	}
}

func (ptr *QToolButton) DestroyQToolButton() {
	if ptr.Pointer() != nil {
		C.QToolButton_DestroyQToolButton(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QToolButton) DestroyQToolButtonDefault() {
	if ptr.Pointer() != nil {
		C.QToolButton_DestroyQToolButtonDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QToolButton) DefaultAction() *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QToolButton_DefaultAction(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolButton) Menu() *QMenu {
	if ptr.Pointer() != nil {
		tmpValue := NewQMenuFromPointer(C.QToolButton_Menu(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QToolButton) PopupMode() QToolButton__ToolButtonPopupMode {
	if ptr.Pointer() != nil {
		return QToolButton__ToolButtonPopupMode(C.QToolButton_PopupMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QToolButton) ArrowType() core.Qt__ArrowType {
	if ptr.Pointer() != nil {
		return core.Qt__ArrowType(C.QToolButton_ArrowType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QToolButton) ToolButtonStyle() core.Qt__ToolButtonStyle {
	if ptr.Pointer() != nil {
		return core.Qt__ToolButtonStyle(C.QToolButton_ToolButtonStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QToolButton) AutoRaise() bool {
	if ptr.Pointer() != nil {
		return int8(C.QToolButton_AutoRaise(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QToolButton) InitStyleOption(option QStyleOptionToolButton_ITF) {
	if ptr.Pointer() != nil {
		C.QToolButton_InitStyleOption(ptr.Pointer(), PointerFromQStyleOptionToolButton(option))
	}
}

type QToolTip struct {
	ptr unsafe.Pointer
}

type QToolTip_ITF interface {
	QToolTip_PTR() *QToolTip
}

func (ptr *QToolTip) QToolTip_PTR() *QToolTip {
	return ptr
}

func (ptr *QToolTip) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QToolTip) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQToolTip(ptr QToolTip_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QToolTip_PTR().Pointer()
	}
	return nil
}

func NewQToolTipFromPointer(ptr unsafe.Pointer) (n *QToolTip) {
	n = new(QToolTip)
	n.SetPointer(ptr)
	return
}

func (ptr *QToolTip) DestroyQToolTip() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func QToolTip_Font() *gui.QFont {
	tmpValue := gui.NewQFontFromPointer(C.QToolTip_QToolTip_Font())
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func (ptr *QToolTip) Font() *gui.QFont {
	tmpValue := gui.NewQFontFromPointer(C.QToolTip_QToolTip_Font())
	runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
	return tmpValue
}

func QToolTip_Palette() *gui.QPalette {
	tmpValue := gui.NewQPaletteFromPointer(C.QToolTip_QToolTip_Palette())
	runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
	return tmpValue
}

func (ptr *QToolTip) Palette() *gui.QPalette {
	tmpValue := gui.NewQPaletteFromPointer(C.QToolTip_QToolTip_Palette())
	runtime.SetFinalizer(tmpValue, (*gui.QPalette).DestroyQPalette)
	return tmpValue
}

func QToolTip_Text() string {
	return cGoUnpackString(C.QToolTip_QToolTip_Text())
}

func (ptr *QToolTip) Text() string {
	return cGoUnpackString(C.QToolTip_QToolTip_Text())
}

func QToolTip_IsVisible() bool {
	return int8(C.QToolTip_QToolTip_IsVisible()) != 0
}

func (ptr *QToolTip) IsVisible() bool {
	return int8(C.QToolTip_QToolTip_IsVisible()) != 0
}

func QToolTip_HideText() {
	C.QToolTip_QToolTip_HideText()
}

func (ptr *QToolTip) HideText() {
	C.QToolTip_QToolTip_HideText()
}

func QToolTip_SetFont(font gui.QFont_ITF) {
	C.QToolTip_QToolTip_SetFont(gui.PointerFromQFont(font))
}

func (ptr *QToolTip) SetFont(font gui.QFont_ITF) {
	C.QToolTip_QToolTip_SetFont(gui.PointerFromQFont(font))
}

func QToolTip_SetPalette(palette gui.QPalette_ITF) {
	C.QToolTip_QToolTip_SetPalette(gui.PointerFromQPalette(palette))
}

func (ptr *QToolTip) SetPalette(palette gui.QPalette_ITF) {
	C.QToolTip_QToolTip_SetPalette(gui.PointerFromQPalette(palette))
}

func QToolTip_ShowText2(pos core.QPoint_ITF, text string, w QWidget_ITF) {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QToolTip_QToolTip_ShowText2(core.PointerFromQPoint(pos), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(w))
}

func (ptr *QToolTip) ShowText2(pos core.QPoint_ITF, text string, w QWidget_ITF) {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QToolTip_QToolTip_ShowText2(core.PointerFromQPoint(pos), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(w))
}

func QToolTip_ShowText(pos core.QPoint_ITF, text string, w QWidget_ITF, rect core.QRect_ITF) {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QToolTip_QToolTip_ShowText(core.PointerFromQPoint(pos), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(w), core.PointerFromQRect(rect))
}

func (ptr *QToolTip) ShowText(pos core.QPoint_ITF, text string, w QWidget_ITF, rect core.QRect_ITF) {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QToolTip_QToolTip_ShowText(core.PointerFromQPoint(pos), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(w), core.PointerFromQRect(rect))
}

func QToolTip_ShowText3(pos core.QPoint_ITF, text string, w QWidget_ITF, rect core.QRect_ITF, msecDisplayTime int) {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QToolTip_QToolTip_ShowText3(core.PointerFromQPoint(pos), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(w), core.PointerFromQRect(rect), C.int(int32(msecDisplayTime)))
}

func (ptr *QToolTip) ShowText3(pos core.QPoint_ITF, text string, w QWidget_ITF, rect core.QRect_ITF, msecDisplayTime int) {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QToolTip_QToolTip_ShowText3(core.PointerFromQPoint(pos), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(w), core.PointerFromQRect(rect), C.int(int32(msecDisplayTime)))
}

type QTreeView struct {
	QAbstractItemView
}

type QTreeView_ITF interface {
	QAbstractItemView_ITF
	QTreeView_PTR() *QTreeView
}

func (ptr *QTreeView) QTreeView_PTR() *QTreeView {
	return ptr
}

func (ptr *QTreeView) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractItemView_PTR().Pointer()
	}
	return nil
}

func (ptr *QTreeView) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAbstractItemView_PTR().SetPointer(p)
	}
}

func PointerFromQTreeView(ptr QTreeView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTreeView_PTR().Pointer()
	}
	return nil
}

func NewQTreeViewFromPointer(ptr unsafe.Pointer) (n *QTreeView) {
	n = new(QTreeView)
	n.SetPointer(ptr)
	return
}

//export callbackQTreeView_MoveCursor
func callbackQTreeView_MoveCursor(ptr unsafe.Pointer, cursorAction C.longlong, modifiers C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "moveCursor"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
	}

	return core.PointerFromQModelIndex(NewQTreeViewFromPointer(ptr).MoveCursorDefault(QAbstractItemView__CursorAction(cursorAction), core.Qt__KeyboardModifier(modifiers)))
}

func (ptr *QTreeView) ConnectMoveCursor(f func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "moveCursor"); signal != nil {
			f := func(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
				(*(*func(QAbstractItemView__CursorAction, core.Qt__KeyboardModifier) *core.QModelIndex)(signal))(cursorAction, modifiers)
				return f(cursorAction, modifiers)
			}
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "moveCursor", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectMoveCursor() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "moveCursor")
	}
}

func (ptr *QTreeView) MoveCursor(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTreeView_MoveCursor(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeView) MoveCursorDefault(cursorAction QAbstractItemView__CursorAction, modifiers core.Qt__KeyboardModifier) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTreeView_MoveCursorDefault(ptr.Pointer(), C.longlong(cursorAction), C.longlong(modifiers)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func NewQTreeView(parent QWidget_ITF) *QTreeView {
	tmpValue := NewQTreeViewFromPointer(C.QTreeView_NewQTreeView(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQTreeView_Collapse
func callbackQTreeView_Collapse(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "collapse"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQTreeViewFromPointer(ptr).CollapseDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QTreeView) ConnectCollapse(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "collapse"); signal != nil {
			f := func(index *core.QModelIndex) {
				(*(*func(*core.QModelIndex))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "collapse", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "collapse", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectCollapse() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "collapse")
	}
}

func (ptr *QTreeView) Collapse(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_Collapse(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QTreeView) CollapseDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_CollapseDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQTreeView_CollapseAll
func callbackQTreeView_CollapseAll(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "collapseAll"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeViewFromPointer(ptr).CollapseAllDefault()
	}
}

func (ptr *QTreeView) ConnectCollapseAll(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "collapseAll"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "collapseAll", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "collapseAll", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectCollapseAll() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "collapseAll")
	}
}

func (ptr *QTreeView) CollapseAll() {
	if ptr.Pointer() != nil {
		C.QTreeView_CollapseAll(ptr.Pointer())
	}
}

func (ptr *QTreeView) CollapseAllDefault() {
	if ptr.Pointer() != nil {
		C.QTreeView_CollapseAllDefault(ptr.Pointer())
	}
}

//export callbackQTreeView_Collapsed
func callbackQTreeView_Collapsed(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "collapsed"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QTreeView) ConnectCollapsed(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "collapsed") {
			C.QTreeView_ConnectCollapsed(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "collapsed"); signal != nil {
			f := func(index *core.QModelIndex) {
				(*(*func(*core.QModelIndex))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "collapsed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "collapsed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectCollapsed() {
	if ptr.Pointer() != nil {
		C.QTreeView_DisconnectCollapsed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "collapsed")
	}
}

func (ptr *QTreeView) Collapsed(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_Collapsed(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQTreeView_ColumnCountChanged
func callbackQTreeView_ColumnCountChanged(ptr unsafe.Pointer, oldCount C.int, newCount C.int) {
	if signal := qt.GetSignal(ptr, "columnCountChanged"); signal != nil {
		(*(*func(int, int))(signal))(int(int32(oldCount)), int(int32(newCount)))
	} else {
		NewQTreeViewFromPointer(ptr).ColumnCountChangedDefault(int(int32(oldCount)), int(int32(newCount)))
	}
}

func (ptr *QTreeView) ConnectColumnCountChanged(f func(oldCount int, newCount int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnCountChanged"); signal != nil {
			f := func(oldCount int, newCount int) {
				(*(*func(int, int))(signal))(oldCount, newCount)
				f(oldCount, newCount)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnCountChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnCountChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectColumnCountChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnCountChanged")
	}
}

func (ptr *QTreeView) ColumnCountChanged(oldCount int, newCount int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ColumnCountChanged(ptr.Pointer(), C.int(int32(oldCount)), C.int(int32(newCount)))
	}
}

func (ptr *QTreeView) ColumnCountChangedDefault(oldCount int, newCount int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ColumnCountChangedDefault(ptr.Pointer(), C.int(int32(oldCount)), C.int(int32(newCount)))
	}
}

//export callbackQTreeView_ColumnMoved
func callbackQTreeView_ColumnMoved(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "columnMoved"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeViewFromPointer(ptr).ColumnMovedDefault()
	}
}

func (ptr *QTreeView) ConnectColumnMoved(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnMoved"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "columnMoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnMoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectColumnMoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnMoved")
	}
}

func (ptr *QTreeView) ColumnMoved() {
	if ptr.Pointer() != nil {
		C.QTreeView_ColumnMoved(ptr.Pointer())
	}
}

func (ptr *QTreeView) ColumnMovedDefault() {
	if ptr.Pointer() != nil {
		C.QTreeView_ColumnMovedDefault(ptr.Pointer())
	}
}

//export callbackQTreeView_ColumnResized
func callbackQTreeView_ColumnResized(ptr unsafe.Pointer, column C.int, oldSize C.int, newSize C.int) {
	if signal := qt.GetSignal(ptr, "columnResized"); signal != nil {
		(*(*func(int, int, int))(signal))(int(int32(column)), int(int32(oldSize)), int(int32(newSize)))
	} else {
		NewQTreeViewFromPointer(ptr).ColumnResizedDefault(int(int32(column)), int(int32(oldSize)), int(int32(newSize)))
	}
}

func (ptr *QTreeView) ConnectColumnResized(f func(column int, oldSize int, newSize int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "columnResized"); signal != nil {
			f := func(column int, oldSize int, newSize int) {
				(*(*func(int, int, int))(signal))(column, oldSize, newSize)
				f(column, oldSize, newSize)
			}
			qt.ConnectSignal(ptr.Pointer(), "columnResized", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "columnResized", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectColumnResized() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "columnResized")
	}
}

func (ptr *QTreeView) ColumnResized(column int, oldSize int, newSize int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ColumnResized(ptr.Pointer(), C.int(int32(column)), C.int(int32(oldSize)), C.int(int32(newSize)))
	}
}

func (ptr *QTreeView) ColumnResizedDefault(column int, oldSize int, newSize int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ColumnResizedDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(oldSize)), C.int(int32(newSize)))
	}
}

//export callbackQTreeView_CurrentChanged
func callbackQTreeView_CurrentChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	} else {
		NewQTreeViewFromPointer(ptr).CurrentChangedDefault(core.NewQModelIndexFromPointer(current), core.NewQModelIndexFromPointer(previous))
	}
}

func (ptr *QTreeView) ConnectCurrentChanged(f func(current *core.QModelIndex, previous *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "currentChanged"); signal != nil {
			f := func(current *core.QModelIndex, previous *core.QModelIndex) {
				(*(*func(*core.QModelIndex, *core.QModelIndex))(signal))(current, previous)
				f(current, previous)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectCurrentChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "currentChanged")
	}
}

func (ptr *QTreeView) CurrentChanged(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_CurrentChanged(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

func (ptr *QTreeView) CurrentChangedDefault(current core.QModelIndex_ITF, previous core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_CurrentChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(current), core.PointerFromQModelIndex(previous))
	}
}

//export callbackQTreeView_DataChanged
func callbackQTreeView_DataChanged(ptr unsafe.Pointer, topLeft unsafe.Pointer, bottomRight unsafe.Pointer, roles C.struct_QtWidgets_PackedList) {
	if signal := qt.GetSignal(ptr, "dataChanged"); signal != nil {
		(*(*func(*core.QModelIndex, *core.QModelIndex, []int))(signal))(core.NewQModelIndexFromPointer(topLeft), core.NewQModelIndexFromPointer(bottomRight), func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQTreeViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__dataChanged_roles_atList(i)
			}
			return out
		}(roles))
	} else {
		NewQTreeViewFromPointer(ptr).DataChangedDefault(core.NewQModelIndexFromPointer(topLeft), core.NewQModelIndexFromPointer(bottomRight), func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQTreeViewFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__dataChanged_roles_atList(i)
			}
			return out
		}(roles))
	}
}

func (ptr *QTreeView) ConnectDataChanged(f func(topLeft *core.QModelIndex, bottomRight *core.QModelIndex, roles []int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dataChanged"); signal != nil {
			f := func(topLeft *core.QModelIndex, bottomRight *core.QModelIndex, roles []int) {
				(*(*func(*core.QModelIndex, *core.QModelIndex, []int))(signal))(topLeft, bottomRight, roles)
				f(topLeft, bottomRight, roles)
			}
			qt.ConnectSignal(ptr.Pointer(), "dataChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dataChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectDataChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dataChanged")
	}
}

func (ptr *QTreeView) DataChanged(topLeft core.QModelIndex_ITF, bottomRight core.QModelIndex_ITF, roles []int) {
	if ptr.Pointer() != nil {
		C.QTreeView_DataChanged(ptr.Pointer(), core.PointerFromQModelIndex(topLeft), core.PointerFromQModelIndex(bottomRight), func() unsafe.Pointer {
			tmpList := NewQTreeViewFromPointer(NewQTreeViewFromPointer(nil).__dataChanged_roles_newList())
			for _, v := range roles {
				tmpList.__dataChanged_roles_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QTreeView) DataChangedDefault(topLeft core.QModelIndex_ITF, bottomRight core.QModelIndex_ITF, roles []int) {
	if ptr.Pointer() != nil {
		C.QTreeView_DataChangedDefault(ptr.Pointer(), core.PointerFromQModelIndex(topLeft), core.PointerFromQModelIndex(bottomRight), func() unsafe.Pointer {
			tmpList := NewQTreeViewFromPointer(NewQTreeViewFromPointer(nil).__dataChanged_roles_newList())
			for _, v := range roles {
				tmpList.__dataChanged_roles_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQTreeView_Expand
func callbackQTreeView_Expand(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "expand"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQTreeViewFromPointer(ptr).ExpandDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QTreeView) ConnectExpand(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "expand"); signal != nil {
			f := func(index *core.QModelIndex) {
				(*(*func(*core.QModelIndex))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "expand", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "expand", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectExpand() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "expand")
	}
}

func (ptr *QTreeView) Expand(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_Expand(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QTreeView) ExpandDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_ExpandDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQTreeView_ExpandAll
func callbackQTreeView_ExpandAll(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "expandAll"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeViewFromPointer(ptr).ExpandAllDefault()
	}
}

func (ptr *QTreeView) ConnectExpandAll(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "expandAll"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "expandAll", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "expandAll", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectExpandAll() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "expandAll")
	}
}

func (ptr *QTreeView) ExpandAll() {
	if ptr.Pointer() != nil {
		C.QTreeView_ExpandAll(ptr.Pointer())
	}
}

func (ptr *QTreeView) ExpandAllDefault() {
	if ptr.Pointer() != nil {
		C.QTreeView_ExpandAllDefault(ptr.Pointer())
	}
}

//export callbackQTreeView_ExpandToDepth
func callbackQTreeView_ExpandToDepth(ptr unsafe.Pointer, depth C.int) {
	if signal := qt.GetSignal(ptr, "expandToDepth"); signal != nil {
		(*(*func(int))(signal))(int(int32(depth)))
	} else {
		NewQTreeViewFromPointer(ptr).ExpandToDepthDefault(int(int32(depth)))
	}
}

func (ptr *QTreeView) ConnectExpandToDepth(f func(depth int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "expandToDepth"); signal != nil {
			f := func(depth int) {
				(*(*func(int))(signal))(depth)
				f(depth)
			}
			qt.ConnectSignal(ptr.Pointer(), "expandToDepth", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "expandToDepth", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectExpandToDepth() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "expandToDepth")
	}
}

func (ptr *QTreeView) ExpandToDepth(depth int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ExpandToDepth(ptr.Pointer(), C.int(int32(depth)))
	}
}

func (ptr *QTreeView) ExpandToDepthDefault(depth int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ExpandToDepthDefault(ptr.Pointer(), C.int(int32(depth)))
	}
}

//export callbackQTreeView_Expanded
func callbackQTreeView_Expanded(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "expanded"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	}

}

func (ptr *QTreeView) ConnectExpanded(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "expanded") {
			C.QTreeView_ConnectExpanded(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "expanded"); signal != nil {
			f := func(index *core.QModelIndex) {
				(*(*func(*core.QModelIndex))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "expanded", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "expanded", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectExpanded() {
	if ptr.Pointer() != nil {
		C.QTreeView_DisconnectExpanded(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "expanded")
	}
}

func (ptr *QTreeView) Expanded(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_Expanded(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

//export callbackQTreeView_HideColumn
func callbackQTreeView_HideColumn(ptr unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "hideColumn"); signal != nil {
		(*(*func(int))(signal))(int(int32(column)))
	} else {
		NewQTreeViewFromPointer(ptr).HideColumnDefault(int(int32(column)))
	}
}

func (ptr *QTreeView) ConnectHideColumn(f func(column int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hideColumn"); signal != nil {
			f := func(column int) {
				(*(*func(int))(signal))(column)
				f(column)
			}
			qt.ConnectSignal(ptr.Pointer(), "hideColumn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hideColumn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectHideColumn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hideColumn")
	}
}

func (ptr *QTreeView) HideColumn(column int) {
	if ptr.Pointer() != nil {
		C.QTreeView_HideColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTreeView) HideColumnDefault(column int) {
	if ptr.Pointer() != nil {
		C.QTreeView_HideColumnDefault(ptr.Pointer(), C.int(int32(column)))
	}
}

//export callbackQTreeView_Reset
func callbackQTreeView_Reset(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "reset"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeViewFromPointer(ptr).ResetDefault()
	}
}

func (ptr *QTreeView) ConnectReset(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "reset"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectReset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "reset")
	}
}

func (ptr *QTreeView) Reset() {
	if ptr.Pointer() != nil {
		C.QTreeView_Reset(ptr.Pointer())
	}
}

func (ptr *QTreeView) ResetDefault() {
	if ptr.Pointer() != nil {
		C.QTreeView_ResetDefault(ptr.Pointer())
	}
}

func (ptr *QTreeView) ResetIndentation() {
	if ptr.Pointer() != nil {
		C.QTreeView_ResetIndentation(ptr.Pointer())
	}
}

//export callbackQTreeView_ResizeColumnToContents
func callbackQTreeView_ResizeColumnToContents(ptr unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "resizeColumnToContents"); signal != nil {
		(*(*func(int))(signal))(int(int32(column)))
	} else {
		NewQTreeViewFromPointer(ptr).ResizeColumnToContentsDefault(int(int32(column)))
	}
}

func (ptr *QTreeView) ConnectResizeColumnToContents(f func(column int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resizeColumnToContents"); signal != nil {
			f := func(column int) {
				(*(*func(int))(signal))(column)
				f(column)
			}
			qt.ConnectSignal(ptr.Pointer(), "resizeColumnToContents", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resizeColumnToContents", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectResizeColumnToContents() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resizeColumnToContents")
	}
}

func (ptr *QTreeView) ResizeColumnToContents(column int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ResizeColumnToContents(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTreeView) ResizeColumnToContentsDefault(column int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ResizeColumnToContentsDefault(ptr.Pointer(), C.int(int32(column)))
	}
}

//export callbackQTreeView_RowsAboutToBeRemoved
func callbackQTreeView_RowsAboutToBeRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsAboutToBeRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	} else {
		NewQTreeViewFromPointer(ptr).RowsAboutToBeRemovedDefault(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}
}

func (ptr *QTreeView) ConnectRowsAboutToBeRemoved(f func(parent *core.QModelIndex, start int, end int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowsAboutToBeRemoved"); signal != nil {
			f := func(parent *core.QModelIndex, start int, end int) {
				(*(*func(*core.QModelIndex, int, int))(signal))(parent, start, end)
				f(parent, start, end)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsAboutToBeRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectRowsAboutToBeRemoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowsAboutToBeRemoved")
	}
}

func (ptr *QTreeView) RowsAboutToBeRemoved(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QTreeView_RowsAboutToBeRemoved(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

func (ptr *QTreeView) RowsAboutToBeRemovedDefault(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QTreeView_RowsAboutToBeRemovedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

//export callbackQTreeView_RowsInserted
func callbackQTreeView_RowsInserted(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsInserted"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	} else {
		NewQTreeViewFromPointer(ptr).RowsInsertedDefault(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}
}

func (ptr *QTreeView) ConnectRowsInserted(f func(parent *core.QModelIndex, start int, end int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowsInserted"); signal != nil {
			f := func(parent *core.QModelIndex, start int, end int) {
				(*(*func(*core.QModelIndex, int, int))(signal))(parent, start, end)
				f(parent, start, end)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsInserted", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsInserted", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectRowsInserted() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowsInserted")
	}
}

func (ptr *QTreeView) RowsInserted(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QTreeView_RowsInserted(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

func (ptr *QTreeView) RowsInsertedDefault(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QTreeView_RowsInsertedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

//export callbackQTreeView_RowsRemoved
func callbackQTreeView_RowsRemoved(ptr unsafe.Pointer, parent unsafe.Pointer, start C.int, end C.int) {
	if signal := qt.GetSignal(ptr, "rowsRemoved"); signal != nil {
		(*(*func(*core.QModelIndex, int, int))(signal))(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	} else {
		NewQTreeViewFromPointer(ptr).RowsRemovedDefault(core.NewQModelIndexFromPointer(parent), int(int32(start)), int(int32(end)))
	}
}

func (ptr *QTreeView) ConnectRowsRemoved(f func(parent *core.QModelIndex, start int, end int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "rowsRemoved"); signal != nil {
			f := func(parent *core.QModelIndex, start int, end int) {
				(*(*func(*core.QModelIndex, int, int))(signal))(parent, start, end)
				f(parent, start, end)
			}
			qt.ConnectSignal(ptr.Pointer(), "rowsRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "rowsRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectRowsRemoved() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "rowsRemoved")
	}
}

func (ptr *QTreeView) RowsRemoved(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QTreeView_RowsRemoved(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

func (ptr *QTreeView) RowsRemovedDefault(parent core.QModelIndex_ITF, start int, end int) {
	if ptr.Pointer() != nil {
		C.QTreeView_RowsRemovedDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent), C.int(int32(start)), C.int(int32(end)))
	}
}

//export callbackQTreeView_ScrollTo
func callbackQTreeView_ScrollTo(ptr unsafe.Pointer, index unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "scrollTo"); signal != nil {
		(*(*func(*core.QModelIndex, QAbstractItemView__ScrollHint))(signal))(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	} else {
		NewQTreeViewFromPointer(ptr).ScrollToDefault(core.NewQModelIndexFromPointer(index), QAbstractItemView__ScrollHint(hint))
	}
}

func (ptr *QTreeView) ConnectScrollTo(f func(index *core.QModelIndex, hint QAbstractItemView__ScrollHint)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "scrollTo"); signal != nil {
			f := func(index *core.QModelIndex, hint QAbstractItemView__ScrollHint) {
				(*(*func(*core.QModelIndex, QAbstractItemView__ScrollHint))(signal))(index, hint)
				f(index, hint)
			}
			qt.ConnectSignal(ptr.Pointer(), "scrollTo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scrollTo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectScrollTo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "scrollTo")
	}
}

func (ptr *QTreeView) ScrollTo(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QTreeView_ScrollTo(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

func (ptr *QTreeView) ScrollToDefault(index core.QModelIndex_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QTreeView_ScrollToDefault(ptr.Pointer(), core.PointerFromQModelIndex(index), C.longlong(hint))
	}
}

//export callbackQTreeView_SelectAll
func callbackQTreeView_SelectAll(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectAll"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeViewFromPointer(ptr).SelectAllDefault()
	}
}

func (ptr *QTreeView) ConnectSelectAll(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "selectAll"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "selectAll", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectAll", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectSelectAll() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "selectAll")
	}
}

func (ptr *QTreeView) SelectAll() {
	if ptr.Pointer() != nil {
		C.QTreeView_SelectAll(ptr.Pointer())
	}
}

func (ptr *QTreeView) SelectAllDefault() {
	if ptr.Pointer() != nil {
		C.QTreeView_SelectAllDefault(ptr.Pointer())
	}
}

//export callbackQTreeView_SelectionChanged
func callbackQTreeView_SelectionChanged(ptr unsafe.Pointer, selected unsafe.Pointer, deselected unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
		(*(*func(*core.QItemSelection, *core.QItemSelection))(signal))(core.NewQItemSelectionFromPointer(selected), core.NewQItemSelectionFromPointer(deselected))
	} else {
		NewQTreeViewFromPointer(ptr).SelectionChangedDefault(core.NewQItemSelectionFromPointer(selected), core.NewQItemSelectionFromPointer(deselected))
	}
}

func (ptr *QTreeView) ConnectSelectionChanged(f func(selected *core.QItemSelection, deselected *core.QItemSelection)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "selectionChanged"); signal != nil {
			f := func(selected *core.QItemSelection, deselected *core.QItemSelection) {
				(*(*func(*core.QItemSelection, *core.QItemSelection))(signal))(selected, deselected)
				f(selected, deselected)
			}
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "selectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectSelectionChanged() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "selectionChanged")
	}
}

func (ptr *QTreeView) SelectionChanged(selected core.QItemSelection_ITF, deselected core.QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_SelectionChanged(ptr.Pointer(), core.PointerFromQItemSelection(selected), core.PointerFromQItemSelection(deselected))
	}
}

func (ptr *QTreeView) SelectionChangedDefault(selected core.QItemSelection_ITF, deselected core.QItemSelection_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_SelectionChangedDefault(ptr.Pointer(), core.PointerFromQItemSelection(selected), core.PointerFromQItemSelection(deselected))
	}
}

func (ptr *QTreeView) SetAllColumnsShowFocus(enable bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetAllColumnsShowFocus(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QTreeView) SetAnimated(enable bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetAnimated(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QTreeView) SetAutoExpandDelay(delay int) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetAutoExpandDelay(ptr.Pointer(), C.int(int32(delay)))
	}
}

func (ptr *QTreeView) SetColumnHidden(column int, hide bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetColumnHidden(ptr.Pointer(), C.int(int32(column)), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

func (ptr *QTreeView) SetColumnWidth(column int, width int) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetColumnWidth(ptr.Pointer(), C.int(int32(column)), C.int(int32(width)))
	}
}

func (ptr *QTreeView) SetExpanded(index core.QModelIndex_ITF, expanded bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetExpanded(ptr.Pointer(), core.PointerFromQModelIndex(index), C.char(int8(qt.GoBoolToInt(expanded))))
	}
}

func (ptr *QTreeView) SetExpandsOnDoubleClick(enable bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetExpandsOnDoubleClick(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QTreeView) SetFirstColumnSpanned(row int, parent core.QModelIndex_ITF, span bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetFirstColumnSpanned(ptr.Pointer(), C.int(int32(row)), core.PointerFromQModelIndex(parent), C.char(int8(qt.GoBoolToInt(span))))
	}
}

func (ptr *QTreeView) SetHeader(header QHeaderView_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetHeader(ptr.Pointer(), PointerFromQHeaderView(header))
	}
}

func (ptr *QTreeView) SetHeaderHidden(hide bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetHeaderHidden(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

func (ptr *QTreeView) SetIndentation(i int) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetIndentation(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QTreeView) SetItemsExpandable(enable bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetItemsExpandable(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQTreeView_SetRootIndex
func callbackQTreeView_SetRootIndex(ptr unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setRootIndex"); signal != nil {
		(*(*func(*core.QModelIndex))(signal))(core.NewQModelIndexFromPointer(index))
	} else {
		NewQTreeViewFromPointer(ptr).SetRootIndexDefault(core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QTreeView) ConnectSetRootIndex(f func(index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setRootIndex"); signal != nil {
			f := func(index *core.QModelIndex) {
				(*(*func(*core.QModelIndex))(signal))(index)
				f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "setRootIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setRootIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectSetRootIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setRootIndex")
	}
}

func (ptr *QTreeView) SetRootIndex(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetRootIndex(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QTreeView) SetRootIndexDefault(index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetRootIndexDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QTreeView) SetRootIsDecorated(show bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetRootIsDecorated(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(show))))
	}
}

func (ptr *QTreeView) SetRowHidden(row int, parent core.QModelIndex_ITF, hide bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetRowHidden(ptr.Pointer(), C.int(int32(row)), core.PointerFromQModelIndex(parent), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

//export callbackQTreeView_SetSelection
func callbackQTreeView_SetSelection(ptr unsafe.Pointer, rect unsafe.Pointer, command C.longlong) {
	if signal := qt.GetSignal(ptr, "setSelection"); signal != nil {
		(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(command))
	} else {
		NewQTreeViewFromPointer(ptr).SetSelectionDefault(core.NewQRectFromPointer(rect), core.QItemSelectionModel__SelectionFlag(command))
	}
}

func (ptr *QTreeView) ConnectSetSelection(f func(rect *core.QRect, command core.QItemSelectionModel__SelectionFlag)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setSelection"); signal != nil {
			f := func(rect *core.QRect, command core.QItemSelectionModel__SelectionFlag) {
				(*(*func(*core.QRect, core.QItemSelectionModel__SelectionFlag))(signal))(rect, command)
				f(rect, command)
			}
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectSetSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setSelection")
	}
}

func (ptr *QTreeView) SetSelection(rect core.QRect_ITF, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetSelection(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(command))
	}
}

func (ptr *QTreeView) SetSelectionDefault(rect core.QRect_ITF, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetSelectionDefault(ptr.Pointer(), core.PointerFromQRect(rect), C.longlong(command))
	}
}

func (ptr *QTreeView) SetSortingEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetSortingEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QTreeView) SetTreePosition(index int) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetTreePosition(ptr.Pointer(), C.int(int32(index)))
	}
}

func (ptr *QTreeView) SetUniformRowHeights(uniform bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetUniformRowHeights(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(uniform))))
	}
}

func (ptr *QTreeView) SetWordWrap(on bool) {
	if ptr.Pointer() != nil {
		C.QTreeView_SetWordWrap(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

//export callbackQTreeView_ShowColumn
func callbackQTreeView_ShowColumn(ptr unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "showColumn"); signal != nil {
		(*(*func(int))(signal))(int(int32(column)))
	} else {
		NewQTreeViewFromPointer(ptr).ShowColumnDefault(int(int32(column)))
	}
}

func (ptr *QTreeView) ConnectShowColumn(f func(column int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showColumn"); signal != nil {
			f := func(column int) {
				(*(*func(int))(signal))(column)
				f(column)
			}
			qt.ConnectSignal(ptr.Pointer(), "showColumn", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showColumn", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectShowColumn() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showColumn")
	}
}

func (ptr *QTreeView) ShowColumn(column int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ShowColumn(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTreeView) ShowColumnDefault(column int) {
	if ptr.Pointer() != nil {
		C.QTreeView_ShowColumnDefault(ptr.Pointer(), C.int(int32(column)))
	}
}

func (ptr *QTreeView) SortByColumn(column int, order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QTreeView_SortByColumn(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
	}
}

//export callbackQTreeView_UpdateGeometries
func callbackQTreeView_UpdateGeometries(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateGeometries"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeViewFromPointer(ptr).UpdateGeometriesDefault()
	}
}

func (ptr *QTreeView) ConnectUpdateGeometries(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateGeometries"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "updateGeometries", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateGeometries", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectUpdateGeometries() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateGeometries")
	}
}

func (ptr *QTreeView) UpdateGeometries() {
	if ptr.Pointer() != nil {
		C.QTreeView_UpdateGeometries(ptr.Pointer())
	}
}

func (ptr *QTreeView) UpdateGeometriesDefault() {
	if ptr.Pointer() != nil {
		C.QTreeView_UpdateGeometriesDefault(ptr.Pointer())
	}
}

//export callbackQTreeView_DestroyQTreeView
func callbackQTreeView_DestroyQTreeView(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTreeView"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeViewFromPointer(ptr).DestroyQTreeViewDefault()
	}
}

func (ptr *QTreeView) ConnectDestroyQTreeView(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTreeView"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTreeView", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTreeView", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectDestroyQTreeView() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTreeView")
	}
}

func (ptr *QTreeView) DestroyQTreeView() {
	if ptr.Pointer() != nil {
		C.QTreeView_DestroyQTreeView(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTreeView) DestroyQTreeViewDefault() {
	if ptr.Pointer() != nil {
		C.QTreeView_DestroyQTreeViewDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTreeView) Header() *QHeaderView {
	if ptr.Pointer() != nil {
		tmpValue := NewQHeaderViewFromPointer(C.QTreeView_Header(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTreeView) IndexAbove(index core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTreeView_IndexAbove(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQTreeView_IndexAt
func callbackQTreeView_IndexAt(ptr unsafe.Pointer, point unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "indexAt"); signal != nil {
		return core.PointerFromQModelIndex((*(*func(*core.QPoint) *core.QModelIndex)(signal))(core.NewQPointFromPointer(point)))
	}

	return core.PointerFromQModelIndex(NewQTreeViewFromPointer(ptr).IndexAtDefault(core.NewQPointFromPointer(point)))
}

func (ptr *QTreeView) ConnectIndexAt(f func(point *core.QPoint) *core.QModelIndex) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "indexAt"); signal != nil {
			f := func(point *core.QPoint) *core.QModelIndex {
				(*(*func(*core.QPoint) *core.QModelIndex)(signal))(point)
				return f(point)
			}
			qt.ConnectSignal(ptr.Pointer(), "indexAt", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "indexAt", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectIndexAt() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "indexAt")
	}
}

func (ptr *QTreeView) IndexAt(point core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTreeView_IndexAt(ptr.Pointer(), core.PointerFromQPoint(point)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeView) IndexAtDefault(point core.QPoint_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTreeView_IndexAtDefault(ptr.Pointer(), core.PointerFromQPoint(point)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeView) IndexBelow(index core.QModelIndex_ITF) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTreeView_IndexBelow(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

//export callbackQTreeView_VisualRect
func callbackQTreeView_VisualRect(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRect"); signal != nil {
		return core.PointerFromQRect((*(*func(*core.QModelIndex) *core.QRect)(signal))(core.NewQModelIndexFromPointer(index)))
	}

	return core.PointerFromQRect(NewQTreeViewFromPointer(ptr).VisualRectDefault(core.NewQModelIndexFromPointer(index)))
}

func (ptr *QTreeView) ConnectVisualRect(f func(index *core.QModelIndex) *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "visualRect"); signal != nil {
			f := func(index *core.QModelIndex) *core.QRect {
				(*(*func(*core.QModelIndex) *core.QRect)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "visualRect", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "visualRect", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectVisualRect() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "visualRect")
	}
}

func (ptr *QTreeView) VisualRect(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QTreeView_VisualRect(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeView) VisualRectDefault(index core.QModelIndex_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QTreeView_VisualRectDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQTreeView_VisualRegionForSelection
func callbackQTreeView_VisualRegionForSelection(ptr unsafe.Pointer, selection unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "visualRegionForSelection"); signal != nil {
		return gui.PointerFromQRegion((*(*func(*core.QItemSelection) *gui.QRegion)(signal))(core.NewQItemSelectionFromPointer(selection)))
	}

	return gui.PointerFromQRegion(NewQTreeViewFromPointer(ptr).VisualRegionForSelectionDefault(core.NewQItemSelectionFromPointer(selection)))
}

func (ptr *QTreeView) ConnectVisualRegionForSelection(f func(selection *core.QItemSelection) *gui.QRegion) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "visualRegionForSelection"); signal != nil {
			f := func(selection *core.QItemSelection) *gui.QRegion {
				(*(*func(*core.QItemSelection) *gui.QRegion)(signal))(selection)
				return f(selection)
			}
			qt.ConnectSignal(ptr.Pointer(), "visualRegionForSelection", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "visualRegionForSelection", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectVisualRegionForSelection() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "visualRegionForSelection")
	}
}

func (ptr *QTreeView) VisualRegionForSelection(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QTreeView_VisualRegionForSelection(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeView) VisualRegionForSelectionDefault(selection core.QItemSelection_ITF) *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QTreeView_VisualRegionForSelectionDefault(ptr.Pointer(), core.PointerFromQItemSelection(selection)))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeView) AllColumnsShowFocus() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_AllColumnsShowFocus(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeView) ExpandsOnDoubleClick() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_ExpandsOnDoubleClick(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeView) IsAnimated() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_IsAnimated(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeView) IsColumnHidden(column int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_IsColumnHidden(ptr.Pointer(), C.int(int32(column)))) != 0
	}
	return false
}

func (ptr *QTreeView) IsExpanded(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_IsExpanded(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QTreeView) IsFirstColumnSpanned(row int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_IsFirstColumnSpanned(ptr.Pointer(), C.int(int32(row)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QTreeView) IsHeaderHidden() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_IsHeaderHidden(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQTreeView_IsIndexHidden
func callbackQTreeView_IsIndexHidden(ptr unsafe.Pointer, index unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isIndexHidden"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QModelIndex) bool)(signal))(core.NewQModelIndexFromPointer(index)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQTreeViewFromPointer(ptr).IsIndexHiddenDefault(core.NewQModelIndexFromPointer(index)))))
}

func (ptr *QTreeView) ConnectIsIndexHidden(f func(index *core.QModelIndex) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isIndexHidden"); signal != nil {
			f := func(index *core.QModelIndex) bool {
				(*(*func(*core.QModelIndex) bool)(signal))(index)
				return f(index)
			}
			qt.ConnectSignal(ptr.Pointer(), "isIndexHidden", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isIndexHidden", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectIsIndexHidden() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isIndexHidden")
	}
}

func (ptr *QTreeView) IsIndexHidden(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_IsIndexHidden(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QTreeView) IsIndexHiddenDefault(index core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_IsIndexHiddenDefault(ptr.Pointer(), core.PointerFromQModelIndex(index))) != 0
	}
	return false
}

func (ptr *QTreeView) IsRowHidden(row int, parent core.QModelIndex_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_IsRowHidden(ptr.Pointer(), C.int(int32(row)), core.PointerFromQModelIndex(parent))) != 0
	}
	return false
}

func (ptr *QTreeView) IsSortingEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_IsSortingEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeView) ItemsExpandable() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_ItemsExpandable(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeView) RootIsDecorated() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_RootIsDecorated(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeView) UniformRowHeights() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_UniformRowHeights(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeView) WordWrap() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeView_WordWrap(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeView) AutoExpandDelay() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_AutoExpandDelay(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeView) ColumnAt(x int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_ColumnAt(ptr.Pointer(), C.int(int32(x)))))
	}
	return 0
}

func (ptr *QTreeView) ColumnViewportPosition(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_ColumnViewportPosition(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

func (ptr *QTreeView) ColumnWidth(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_ColumnWidth(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

//export callbackQTreeView_HorizontalOffset
func callbackQTreeView_HorizontalOffset(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "horizontalOffset"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQTreeViewFromPointer(ptr).HorizontalOffsetDefault()))
}

func (ptr *QTreeView) ConnectHorizontalOffset(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "horizontalOffset"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "horizontalOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "horizontalOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectHorizontalOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "horizontalOffset")
	}
}

func (ptr *QTreeView) HorizontalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_HorizontalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeView) HorizontalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_HorizontalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeView) Indentation() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_Indentation(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeView) IndexRowSizeHint(index core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_IndexRowSizeHint(ptr.Pointer(), core.PointerFromQModelIndex(index))))
	}
	return 0
}

func (ptr *QTreeView) RowHeight(index core.QModelIndex_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_RowHeight(ptr.Pointer(), core.PointerFromQModelIndex(index))))
	}
	return 0
}

func (ptr *QTreeView) TreePosition() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_TreePosition(ptr.Pointer())))
	}
	return 0
}

//export callbackQTreeView_VerticalOffset
func callbackQTreeView_VerticalOffset(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "verticalOffset"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQTreeViewFromPointer(ptr).VerticalOffsetDefault()))
}

func (ptr *QTreeView) ConnectVerticalOffset(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "verticalOffset"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "verticalOffset", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "verticalOffset", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectVerticalOffset() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "verticalOffset")
	}
}

func (ptr *QTreeView) VerticalOffset() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_VerticalOffset(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeView) VerticalOffsetDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeView_VerticalOffsetDefault(ptr.Pointer())))
	}
	return 0
}

//export callbackQTreeView_DrawBranches
func callbackQTreeView_DrawBranches(ptr unsafe.Pointer, painter unsafe.Pointer, rect unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawBranches"); signal != nil {
		(*(*func(*gui.QPainter, *core.QRect, *core.QModelIndex))(signal))(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rect), core.NewQModelIndexFromPointer(index))
	} else {
		NewQTreeViewFromPointer(ptr).DrawBranchesDefault(gui.NewQPainterFromPointer(painter), core.NewQRectFromPointer(rect), core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QTreeView) ConnectDrawBranches(f func(painter *gui.QPainter, rect *core.QRect, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawBranches"); signal != nil {
			f := func(painter *gui.QPainter, rect *core.QRect, index *core.QModelIndex) {
				(*(*func(*gui.QPainter, *core.QRect, *core.QModelIndex))(signal))(painter, rect, index)
				f(painter, rect, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawBranches", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawBranches", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectDrawBranches() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawBranches")
	}
}

func (ptr *QTreeView) DrawBranches(painter gui.QPainter_ITF, rect core.QRect_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_DrawBranches(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rect), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QTreeView) DrawBranchesDefault(painter gui.QPainter_ITF, rect core.QRect_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_DrawBranchesDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQRect(rect), core.PointerFromQModelIndex(index))
	}
}

//export callbackQTreeView_DrawRow
func callbackQTreeView_DrawRow(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, index unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "drawRow"); signal != nil {
		(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QModelIndex))(signal))(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	} else {
		NewQTreeViewFromPointer(ptr).DrawRowDefault(gui.NewQPainterFromPointer(painter), NewQStyleOptionViewItemFromPointer(option), core.NewQModelIndexFromPointer(index))
	}
}

func (ptr *QTreeView) ConnectDrawRow(f func(painter *gui.QPainter, option *QStyleOptionViewItem, index *core.QModelIndex)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "drawRow"); signal != nil {
			f := func(painter *gui.QPainter, option *QStyleOptionViewItem, index *core.QModelIndex) {
				(*(*func(*gui.QPainter, *QStyleOptionViewItem, *core.QModelIndex))(signal))(painter, option, index)
				f(painter, option, index)
			}
			qt.ConnectSignal(ptr.Pointer(), "drawRow", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "drawRow", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeView) DisconnectDrawRow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "drawRow")
	}
}

func (ptr *QTreeView) DrawRow(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_DrawRow(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QTreeView) DrawRowDefault(painter gui.QPainter_ITF, option QStyleOptionViewItem_ITF, index core.QModelIndex_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_DrawRowDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), PointerFromQStyleOptionViewItem(option), core.PointerFromQModelIndex(index))
	}
}

func (ptr *QTreeView) DrawTree(painter gui.QPainter_ITF, region gui.QRegion_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeView_DrawTree(ptr.Pointer(), gui.PointerFromQPainter(painter), gui.PointerFromQRegion(region))
	}
}

type QTreeWidget struct {
	QTreeView
}

type QTreeWidget_ITF interface {
	QTreeView_ITF
	QTreeWidget_PTR() *QTreeWidget
}

func (ptr *QTreeWidget) QTreeWidget_PTR() *QTreeWidget {
	return ptr
}

func (ptr *QTreeWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QTreeView_PTR().Pointer()
	}
	return nil
}

func (ptr *QTreeWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QTreeView_PTR().SetPointer(p)
	}
}

func PointerFromQTreeWidget(ptr QTreeWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTreeWidget_PTR().Pointer()
	}
	return nil
}

func NewQTreeWidgetFromPointer(ptr unsafe.Pointer) (n *QTreeWidget) {
	n = new(QTreeWidget)
	n.SetPointer(ptr)
	return
}
func NewQTreeWidget(parent QWidget_ITF) *QTreeWidget {
	tmpValue := NewQTreeWidgetFromPointer(C.QTreeWidget_NewQTreeWidget(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QTreeWidget) TakeTopLevelItem(index int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_TakeTopLevelItem(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

//export callbackQTreeWidget_DropMimeData
func callbackQTreeWidget_DropMimeData(ptr unsafe.Pointer, parent unsafe.Pointer, index C.int, data unsafe.Pointer, action C.longlong) C.char {
	if signal := qt.GetSignal(ptr, "dropMimeData"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QTreeWidgetItem, int, *core.QMimeData, core.Qt__DropAction) bool)(signal))(NewQTreeWidgetItemFromPointer(parent), int(int32(index)), core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQTreeWidgetFromPointer(ptr).DropMimeDataDefault(NewQTreeWidgetItemFromPointer(parent), int(int32(index)), core.NewQMimeDataFromPointer(data), core.Qt__DropAction(action)))))
}

func (ptr *QTreeWidget) ConnectDropMimeData(f func(parent *QTreeWidgetItem, index int, data *core.QMimeData, action core.Qt__DropAction) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dropMimeData"); signal != nil {
			f := func(parent *QTreeWidgetItem, index int, data *core.QMimeData, action core.Qt__DropAction) bool {
				(*(*func(*QTreeWidgetItem, int, *core.QMimeData, core.Qt__DropAction) bool)(signal))(parent, index, data, action)
				return f(parent, index, data, action)
			}
			qt.ConnectSignal(ptr.Pointer(), "dropMimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dropMimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectDropMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dropMimeData")
	}
}

func (ptr *QTreeWidget) DropMimeData(parent QTreeWidgetItem_ITF, index int, data core.QMimeData_ITF, action core.Qt__DropAction) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeWidget_DropMimeData(ptr.Pointer(), PointerFromQTreeWidgetItem(parent), C.int(int32(index)), core.PointerFromQMimeData(data), C.longlong(action))) != 0
	}
	return false
}

func (ptr *QTreeWidget) DropMimeDataDefault(parent QTreeWidgetItem_ITF, index int, data core.QMimeData_ITF, action core.Qt__DropAction) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeWidget_DropMimeDataDefault(ptr.Pointer(), PointerFromQTreeWidgetItem(parent), C.int(int32(index)), core.PointerFromQMimeData(data), C.longlong(action))) != 0
	}
	return false
}

func (ptr *QTreeWidget) AddTopLevelItem(item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_AddTopLevelItem(ptr.Pointer(), PointerFromQTreeWidgetItem(item))
	}
}

func (ptr *QTreeWidget) AddTopLevelItems(items []*QTreeWidgetItem) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_AddTopLevelItems(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQTreeWidgetFromPointer(NewQTreeWidgetFromPointer(nil).__addTopLevelItems_items_newList())
			for _, v := range items {
				tmpList.__addTopLevelItems_items_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQTreeWidget_Clear
func callbackQTreeWidget_Clear(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "clear"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeWidgetFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QTreeWidget) ConnectClear(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clear"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clear", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectClear() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clear")
	}
}

func (ptr *QTreeWidget) Clear() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_Clear(ptr.Pointer())
	}
}

func (ptr *QTreeWidget) ClearDefault() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ClearDefault(ptr.Pointer())
	}
}

func (ptr *QTreeWidget) ClosePersistentEditor(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ClosePersistentEditor(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

//export callbackQTreeWidget_CollapseItem
func callbackQTreeWidget_CollapseItem(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "collapseItem"); signal != nil {
		(*(*func(*QTreeWidgetItem))(signal))(NewQTreeWidgetItemFromPointer(item))
	} else {
		NewQTreeWidgetFromPointer(ptr).CollapseItemDefault(NewQTreeWidgetItemFromPointer(item))
	}
}

func (ptr *QTreeWidget) ConnectCollapseItem(f func(item *QTreeWidgetItem)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "collapseItem"); signal != nil {
			f := func(item *QTreeWidgetItem) {
				(*(*func(*QTreeWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "collapseItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "collapseItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectCollapseItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "collapseItem")
	}
}

func (ptr *QTreeWidget) CollapseItem(item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_CollapseItem(ptr.Pointer(), PointerFromQTreeWidgetItem(item))
	}
}

func (ptr *QTreeWidget) CollapseItemDefault(item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_CollapseItemDefault(ptr.Pointer(), PointerFromQTreeWidgetItem(item))
	}
}

//export callbackQTreeWidget_CurrentItemChanged
func callbackQTreeWidget_CurrentItemChanged(ptr unsafe.Pointer, current unsafe.Pointer, previous unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "currentItemChanged"); signal != nil {
		(*(*func(*QTreeWidgetItem, *QTreeWidgetItem))(signal))(NewQTreeWidgetItemFromPointer(current), NewQTreeWidgetItemFromPointer(previous))
	}

}

func (ptr *QTreeWidget) ConnectCurrentItemChanged(f func(current *QTreeWidgetItem, previous *QTreeWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentItemChanged") {
			C.QTreeWidget_ConnectCurrentItemChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentItemChanged"); signal != nil {
			f := func(current *QTreeWidgetItem, previous *QTreeWidgetItem) {
				(*(*func(*QTreeWidgetItem, *QTreeWidgetItem))(signal))(current, previous)
				f(current, previous)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentItemChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentItemChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectCurrentItemChanged() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectCurrentItemChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentItemChanged")
	}
}

func (ptr *QTreeWidget) CurrentItemChanged(current QTreeWidgetItem_ITF, previous QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_CurrentItemChanged(ptr.Pointer(), PointerFromQTreeWidgetItem(current), PointerFromQTreeWidgetItem(previous))
	}
}

func (ptr *QTreeWidget) EditItem(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_EditItem(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

//export callbackQTreeWidget_ExpandItem
func callbackQTreeWidget_ExpandItem(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "expandItem"); signal != nil {
		(*(*func(*QTreeWidgetItem))(signal))(NewQTreeWidgetItemFromPointer(item))
	} else {
		NewQTreeWidgetFromPointer(ptr).ExpandItemDefault(NewQTreeWidgetItemFromPointer(item))
	}
}

func (ptr *QTreeWidget) ConnectExpandItem(f func(item *QTreeWidgetItem)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "expandItem"); signal != nil {
			f := func(item *QTreeWidgetItem) {
				(*(*func(*QTreeWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "expandItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "expandItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectExpandItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "expandItem")
	}
}

func (ptr *QTreeWidget) ExpandItem(item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ExpandItem(ptr.Pointer(), PointerFromQTreeWidgetItem(item))
	}
}

func (ptr *QTreeWidget) ExpandItemDefault(item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ExpandItemDefault(ptr.Pointer(), PointerFromQTreeWidgetItem(item))
	}
}

func (ptr *QTreeWidget) InsertTopLevelItem(index int, item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_InsertTopLevelItem(ptr.Pointer(), C.int(int32(index)), PointerFromQTreeWidgetItem(item))
	}
}

func (ptr *QTreeWidget) InsertTopLevelItems(index int, items []*QTreeWidgetItem) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_InsertTopLevelItems(ptr.Pointer(), C.int(int32(index)), func() unsafe.Pointer {
			tmpList := NewQTreeWidgetFromPointer(NewQTreeWidgetFromPointer(nil).__insertTopLevelItems_items_newList())
			for _, v := range items {
				tmpList.__insertTopLevelItems_items_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQTreeWidget_ItemActivated
func callbackQTreeWidget_ItemActivated(ptr unsafe.Pointer, item unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "itemActivated"); signal != nil {
		(*(*func(*QTreeWidgetItem, int))(signal))(NewQTreeWidgetItemFromPointer(item), int(int32(column)))
	}

}

func (ptr *QTreeWidget) ConnectItemActivated(f func(item *QTreeWidgetItem, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemActivated") {
			C.QTreeWidget_ConnectItemActivated(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemActivated"); signal != nil {
			f := func(item *QTreeWidgetItem, column int) {
				(*(*func(*QTreeWidgetItem, int))(signal))(item, column)
				f(item, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemActivated", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemActivated", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectItemActivated() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectItemActivated(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemActivated")
	}
}

func (ptr *QTreeWidget) ItemActivated(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ItemActivated(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

//export callbackQTreeWidget_ItemChanged
func callbackQTreeWidget_ItemChanged(ptr unsafe.Pointer, item unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "itemChanged"); signal != nil {
		(*(*func(*QTreeWidgetItem, int))(signal))(NewQTreeWidgetItemFromPointer(item), int(int32(column)))
	}

}

func (ptr *QTreeWidget) ConnectItemChanged(f func(item *QTreeWidgetItem, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemChanged") {
			C.QTreeWidget_ConnectItemChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemChanged"); signal != nil {
			f := func(item *QTreeWidgetItem, column int) {
				(*(*func(*QTreeWidgetItem, int))(signal))(item, column)
				f(item, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectItemChanged() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectItemChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemChanged")
	}
}

func (ptr *QTreeWidget) ItemChanged(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ItemChanged(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

//export callbackQTreeWidget_ItemClicked
func callbackQTreeWidget_ItemClicked(ptr unsafe.Pointer, item unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "itemClicked"); signal != nil {
		(*(*func(*QTreeWidgetItem, int))(signal))(NewQTreeWidgetItemFromPointer(item), int(int32(column)))
	}

}

func (ptr *QTreeWidget) ConnectItemClicked(f func(item *QTreeWidgetItem, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemClicked") {
			C.QTreeWidget_ConnectItemClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemClicked"); signal != nil {
			f := func(item *QTreeWidgetItem, column int) {
				(*(*func(*QTreeWidgetItem, int))(signal))(item, column)
				f(item, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectItemClicked() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectItemClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemClicked")
	}
}

func (ptr *QTreeWidget) ItemClicked(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ItemClicked(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

//export callbackQTreeWidget_ItemCollapsed
func callbackQTreeWidget_ItemCollapsed(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemCollapsed"); signal != nil {
		(*(*func(*QTreeWidgetItem))(signal))(NewQTreeWidgetItemFromPointer(item))
	}

}

func (ptr *QTreeWidget) ConnectItemCollapsed(f func(item *QTreeWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemCollapsed") {
			C.QTreeWidget_ConnectItemCollapsed(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemCollapsed"); signal != nil {
			f := func(item *QTreeWidgetItem) {
				(*(*func(*QTreeWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemCollapsed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemCollapsed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectItemCollapsed() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectItemCollapsed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemCollapsed")
	}
}

func (ptr *QTreeWidget) ItemCollapsed(item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ItemCollapsed(ptr.Pointer(), PointerFromQTreeWidgetItem(item))
	}
}

//export callbackQTreeWidget_ItemDoubleClicked
func callbackQTreeWidget_ItemDoubleClicked(ptr unsafe.Pointer, item unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "itemDoubleClicked"); signal != nil {
		(*(*func(*QTreeWidgetItem, int))(signal))(NewQTreeWidgetItemFromPointer(item), int(int32(column)))
	}

}

func (ptr *QTreeWidget) ConnectItemDoubleClicked(f func(item *QTreeWidgetItem, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemDoubleClicked") {
			C.QTreeWidget_ConnectItemDoubleClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemDoubleClicked"); signal != nil {
			f := func(item *QTreeWidgetItem, column int) {
				(*(*func(*QTreeWidgetItem, int))(signal))(item, column)
				f(item, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemDoubleClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemDoubleClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectItemDoubleClicked() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectItemDoubleClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemDoubleClicked")
	}
}

func (ptr *QTreeWidget) ItemDoubleClicked(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ItemDoubleClicked(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

//export callbackQTreeWidget_ItemEntered
func callbackQTreeWidget_ItemEntered(ptr unsafe.Pointer, item unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "itemEntered"); signal != nil {
		(*(*func(*QTreeWidgetItem, int))(signal))(NewQTreeWidgetItemFromPointer(item), int(int32(column)))
	}

}

func (ptr *QTreeWidget) ConnectItemEntered(f func(item *QTreeWidgetItem, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemEntered") {
			C.QTreeWidget_ConnectItemEntered(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemEntered"); signal != nil {
			f := func(item *QTreeWidgetItem, column int) {
				(*(*func(*QTreeWidgetItem, int))(signal))(item, column)
				f(item, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemEntered", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemEntered", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectItemEntered() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectItemEntered(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemEntered")
	}
}

func (ptr *QTreeWidget) ItemEntered(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ItemEntered(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

//export callbackQTreeWidget_ItemExpanded
func callbackQTreeWidget_ItemExpanded(ptr unsafe.Pointer, item unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemExpanded"); signal != nil {
		(*(*func(*QTreeWidgetItem))(signal))(NewQTreeWidgetItemFromPointer(item))
	}

}

func (ptr *QTreeWidget) ConnectItemExpanded(f func(item *QTreeWidgetItem)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemExpanded") {
			C.QTreeWidget_ConnectItemExpanded(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemExpanded"); signal != nil {
			f := func(item *QTreeWidgetItem) {
				(*(*func(*QTreeWidgetItem))(signal))(item)
				f(item)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemExpanded", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemExpanded", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectItemExpanded() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectItemExpanded(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemExpanded")
	}
}

func (ptr *QTreeWidget) ItemExpanded(item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ItemExpanded(ptr.Pointer(), PointerFromQTreeWidgetItem(item))
	}
}

//export callbackQTreeWidget_ItemPressed
func callbackQTreeWidget_ItemPressed(ptr unsafe.Pointer, item unsafe.Pointer, column C.int) {
	if signal := qt.GetSignal(ptr, "itemPressed"); signal != nil {
		(*(*func(*QTreeWidgetItem, int))(signal))(NewQTreeWidgetItemFromPointer(item), int(int32(column)))
	}

}

func (ptr *QTreeWidget) ConnectItemPressed(f func(item *QTreeWidgetItem, column int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemPressed") {
			C.QTreeWidget_ConnectItemPressed(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemPressed"); signal != nil {
			f := func(item *QTreeWidgetItem, column int) {
				(*(*func(*QTreeWidgetItem, int))(signal))(item, column)
				f(item, column)
			}
			qt.ConnectSignal(ptr.Pointer(), "itemPressed", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemPressed", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectItemPressed() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectItemPressed(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemPressed")
	}
}

func (ptr *QTreeWidget) ItemPressed(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ItemPressed(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

//export callbackQTreeWidget_ItemSelectionChanged
func callbackQTreeWidget_ItemSelectionChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "itemSelectionChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QTreeWidget) ConnectItemSelectionChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "itemSelectionChanged") {
			C.QTreeWidget_ConnectItemSelectionChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "itemSelectionChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "itemSelectionChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "itemSelectionChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectItemSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DisconnectItemSelectionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "itemSelectionChanged")
	}
}

func (ptr *QTreeWidget) ItemSelectionChanged() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ItemSelectionChanged(ptr.Pointer())
	}
}

func (ptr *QTreeWidget) OpenPersistentEditor(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_OpenPersistentEditor(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

func (ptr *QTreeWidget) RemoveItemWidget(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_RemoveItemWidget(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

//export callbackQTreeWidget_ScrollToItem
func callbackQTreeWidget_ScrollToItem(ptr unsafe.Pointer, item unsafe.Pointer, hint C.longlong) {
	if signal := qt.GetSignal(ptr, "scrollToItem"); signal != nil {
		(*(*func(*QTreeWidgetItem, QAbstractItemView__ScrollHint))(signal))(NewQTreeWidgetItemFromPointer(item), QAbstractItemView__ScrollHint(hint))
	} else {
		NewQTreeWidgetFromPointer(ptr).ScrollToItemDefault(NewQTreeWidgetItemFromPointer(item), QAbstractItemView__ScrollHint(hint))
	}
}

func (ptr *QTreeWidget) ConnectScrollToItem(f func(item *QTreeWidgetItem, hint QAbstractItemView__ScrollHint)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "scrollToItem"); signal != nil {
			f := func(item *QTreeWidgetItem, hint QAbstractItemView__ScrollHint) {
				(*(*func(*QTreeWidgetItem, QAbstractItemView__ScrollHint))(signal))(item, hint)
				f(item, hint)
			}
			qt.ConnectSignal(ptr.Pointer(), "scrollToItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "scrollToItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectScrollToItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "scrollToItem")
	}
}

func (ptr *QTreeWidget) ScrollToItem(item QTreeWidgetItem_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ScrollToItem(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.longlong(hint))
	}
}

func (ptr *QTreeWidget) ScrollToItemDefault(item QTreeWidgetItem_ITF, hint QAbstractItemView__ScrollHint) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_ScrollToItemDefault(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.longlong(hint))
	}
}

func (ptr *QTreeWidget) SetColumnCount(columns int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_SetColumnCount(ptr.Pointer(), C.int(int32(columns)))
	}
}

func (ptr *QTreeWidget) SetCurrentItem(item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_SetCurrentItem(ptr.Pointer(), PointerFromQTreeWidgetItem(item))
	}
}

func (ptr *QTreeWidget) SetCurrentItem2(item QTreeWidgetItem_ITF, column int) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_SetCurrentItem2(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))
	}
}

func (ptr *QTreeWidget) SetCurrentItem3(item QTreeWidgetItem_ITF, column int, command core.QItemSelectionModel__SelectionFlag) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_SetCurrentItem3(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)), C.longlong(command))
	}
}

func (ptr *QTreeWidget) SetFirstItemColumnSpanned(item QTreeWidgetItem_ITF, span bool) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_SetFirstItemColumnSpanned(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.char(int8(qt.GoBoolToInt(span))))
	}
}

func (ptr *QTreeWidget) SetHeaderItem(item QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_SetHeaderItem(ptr.Pointer(), PointerFromQTreeWidgetItem(item))
	}
}

func (ptr *QTreeWidget) SetHeaderLabel(label string) {
	if ptr.Pointer() != nil {
		var labelC *C.char
		if label != "" {
			labelC = C.CString(label)
			defer C.free(unsafe.Pointer(labelC))
		}
		C.QTreeWidget_SetHeaderLabel(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))})
	}
}

func (ptr *QTreeWidget) SetHeaderLabels(labels []string) {
	if ptr.Pointer() != nil {
		labelsC := C.CString(strings.Join(labels, "|"))
		defer C.free(unsafe.Pointer(labelsC))
		C.QTreeWidget_SetHeaderLabels(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: labelsC, len: C.longlong(len(strings.Join(labels, "|")))})
	}
}

func (ptr *QTreeWidget) SetItemWidget(item QTreeWidgetItem_ITF, column int, widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_SetItemWidget(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)), PointerFromQWidget(widget))
	}
}

func (ptr *QTreeWidget) SortItems(column int, order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QTreeWidget_SortItems(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
	}
}

//export callbackQTreeWidget_DestroyQTreeWidget
func callbackQTreeWidget_DestroyQTreeWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTreeWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeWidgetFromPointer(ptr).DestroyQTreeWidgetDefault()
	}
}

func (ptr *QTreeWidget) ConnectDestroyQTreeWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTreeWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTreeWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTreeWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectDestroyQTreeWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTreeWidget")
	}
}

func (ptr *QTreeWidget) DestroyQTreeWidget() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DestroyQTreeWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTreeWidget) DestroyQTreeWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QTreeWidget_DestroyQTreeWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTreeWidget) FindItems(text string, flags core.Qt__MatchFlag, column int) []*QTreeWidgetItem {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		return func(l C.struct_QtWidgets_PackedList) []*QTreeWidgetItem {
			out := make([]*QTreeWidgetItem, int(l.len))
			tmpList := NewQTreeWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__findItems_atList(i)
			}
			return out
		}(C.QTreeWidget_FindItems(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, C.longlong(flags), C.int(int32(column))))
	}
	return make([]*QTreeWidgetItem, 0)
}

func (ptr *QTreeWidget) SelectedItems() []*QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QTreeWidgetItem {
			out := make([]*QTreeWidgetItem, int(l.len))
			tmpList := NewQTreeWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__selectedItems_atList(i)
			}
			return out
		}(C.QTreeWidget_SelectedItems(ptr.Pointer()))
	}
	return make([]*QTreeWidgetItem, 0)
}

//export callbackQTreeWidget_MimeData
func callbackQTreeWidget_MimeData(ptr unsafe.Pointer, items C.struct_QtWidgets_PackedList) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "mimeData"); signal != nil {
		return core.PointerFromQMimeData((*(*func([]*QTreeWidgetItem) *core.QMimeData)(signal))(func(l C.struct_QtWidgets_PackedList) []*QTreeWidgetItem {
			out := make([]*QTreeWidgetItem, int(l.len))
			tmpList := NewQTreeWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__mimeData_items_atList(i)
			}
			return out
		}(items)))
	}

	return core.PointerFromQMimeData(NewQTreeWidgetFromPointer(ptr).MimeDataDefault(func(l C.struct_QtWidgets_PackedList) []*QTreeWidgetItem {
		out := make([]*QTreeWidgetItem, int(l.len))
		tmpList := NewQTreeWidgetFromPointer(l.data)
		for i := 0; i < len(out); i++ {
			out[i] = tmpList.__mimeData_items_atList(i)
		}
		return out
	}(items)))
}

func (ptr *QTreeWidget) ConnectMimeData(f func(items []*QTreeWidgetItem) *core.QMimeData) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mimeData"); signal != nil {
			f := func(items []*QTreeWidgetItem) *core.QMimeData {
				(*(*func([]*QTreeWidgetItem) *core.QMimeData)(signal))(items)
				return f(items)
			}
			qt.ConnectSignal(ptr.Pointer(), "mimeData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mimeData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectMimeData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mimeData")
	}
}

func (ptr *QTreeWidget) MimeData(items []*QTreeWidgetItem) *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QTreeWidget_MimeData(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQTreeWidgetFromPointer(NewQTreeWidgetFromPointer(nil).__mimeData_items_newList())
			for _, v := range items {
				tmpList.__mimeData_items_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidget) MimeDataDefault(items []*QTreeWidgetItem) *core.QMimeData {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMimeDataFromPointer(C.QTreeWidget_MimeDataDefault(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQTreeWidgetFromPointer(NewQTreeWidgetFromPointer(nil).__mimeData_items_newList())
			for _, v := range items {
				tmpList.__mimeData_items_setList(v)
			}
			return tmpList.Pointer()
		}()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidget) IndexFromItem(item QTreeWidgetItem_ITF, column int) *core.QModelIndex {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQModelIndexFromPointer(C.QTreeWidget_IndexFromItem(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*core.QModelIndex).DestroyQModelIndex)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidget) VisualItemRect(item QTreeWidgetItem_ITF) *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QTreeWidget_VisualItemRect(ptr.Pointer(), PointerFromQTreeWidgetItem(item)))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQTreeWidget_MimeTypes
func callbackQTreeWidget_MimeTypes(ptr unsafe.Pointer) C.struct_QtWidgets_PackedString {
	if signal := qt.GetSignal(ptr, "mimeTypes"); signal != nil {
		tempVal := (*(*func() []string)(signal))()
		return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
	}
	tempVal := NewQTreeWidgetFromPointer(ptr).MimeTypesDefault()
	return C.struct_QtWidgets_PackedString{data: C.CString(strings.Join(tempVal, "|")), len: C.longlong(len(strings.Join(tempVal, "|")))}
}

func (ptr *QTreeWidget) ConnectMimeTypes(f func() []string) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mimeTypes"); signal != nil {
			f := func() []string {
				(*(*func() []string)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "mimeTypes", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mimeTypes", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectMimeTypes() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mimeTypes")
	}
}

func (ptr *QTreeWidget) MimeTypes() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QTreeWidget_MimeTypes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QTreeWidget) MimeTypesDefault() []string {
	if ptr.Pointer() != nil {
		return strings.Split(cGoUnpackString(C.QTreeWidget_MimeTypesDefault(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QTreeWidget) CurrentItem() *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_CurrentItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTreeWidget) HeaderItem() *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_HeaderItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTreeWidget) InvisibleRootItem() *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_InvisibleRootItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTreeWidget) ItemAbove(item QTreeWidgetItem_ITF) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_ItemAbove(ptr.Pointer(), PointerFromQTreeWidgetItem(item)))
	}
	return nil
}

func (ptr *QTreeWidget) ItemAt(p core.QPoint_ITF) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_ItemAt(ptr.Pointer(), core.PointerFromQPoint(p)))
	}
	return nil
}

func (ptr *QTreeWidget) ItemAt2(x int, y int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_ItemAt2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y))))
	}
	return nil
}

func (ptr *QTreeWidget) ItemBelow(item QTreeWidgetItem_ITF) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_ItemBelow(ptr.Pointer(), PointerFromQTreeWidgetItem(item)))
	}
	return nil
}

func (ptr *QTreeWidget) ItemFromIndex(index core.QModelIndex_ITF) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_ItemFromIndex(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return nil
}

func (ptr *QTreeWidget) TopLevelItem(index int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_TopLevelItem(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QTreeWidget) ItemWidget(item QTreeWidgetItem_ITF, column int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QTreeWidget_ItemWidget(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQTreeWidget_SupportedDropActions
func callbackQTreeWidget_SupportedDropActions(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "supportedDropActions"); signal != nil {
		return C.longlong((*(*func() core.Qt__DropAction)(signal))())
	}

	return C.longlong(NewQTreeWidgetFromPointer(ptr).SupportedDropActionsDefault())
}

func (ptr *QTreeWidget) ConnectSupportedDropActions(f func() core.Qt__DropAction) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "supportedDropActions"); signal != nil {
			f := func() core.Qt__DropAction {
				(*(*func() core.Qt__DropAction)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "supportedDropActions", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "supportedDropActions", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidget) DisconnectSupportedDropActions() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "supportedDropActions")
	}
}

func (ptr *QTreeWidget) SupportedDropActions() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QTreeWidget_SupportedDropActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTreeWidget) SupportedDropActionsDefault() core.Qt__DropAction {
	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QTreeWidget_SupportedDropActionsDefault(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTreeWidget) IsFirstItemColumnSpanned(item QTreeWidgetItem_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeWidget_IsFirstItemColumnSpanned(ptr.Pointer(), PointerFromQTreeWidgetItem(item))) != 0
	}
	return false
}

func (ptr *QTreeWidget) IsPersistentEditorOpen(item QTreeWidgetItem_ITF, column int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeWidget_IsPersistentEditorOpen(ptr.Pointer(), PointerFromQTreeWidgetItem(item), C.int(int32(column)))) != 0
	}
	return false
}

func (ptr *QTreeWidget) ColumnCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidget_ColumnCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeWidget) CurrentColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidget_CurrentColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeWidget) IndexOfTopLevelItem(item QTreeWidgetItem_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidget_IndexOfTopLevelItem(ptr.Pointer(), PointerFromQTreeWidgetItem(item))))
	}
	return 0
}

func (ptr *QTreeWidget) SortColumn() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidget_SortColumn(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeWidget) TopLevelItemCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidget_TopLevelItemCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeWidget) __addTopLevelItems_items_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget___addTopLevelItems_items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidget) __addTopLevelItems_items_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget___addTopLevelItems_items_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidget) __addTopLevelItems_items_newList() unsafe.Pointer {
	return C.QTreeWidget___addTopLevelItems_items_newList(ptr.Pointer())
}

func (ptr *QTreeWidget) __insertTopLevelItems_items_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget___insertTopLevelItems_items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidget) __insertTopLevelItems_items_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget___insertTopLevelItems_items_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidget) __insertTopLevelItems_items_newList() unsafe.Pointer {
	return C.QTreeWidget___insertTopLevelItems_items_newList(ptr.Pointer())
}

func (ptr *QTreeWidget) __findItems_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget___findItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidget) __findItems_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget___findItems_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidget) __findItems_newList() unsafe.Pointer {
	return C.QTreeWidget___findItems_newList(ptr.Pointer())
}

func (ptr *QTreeWidget) __items_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget___items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidget) __items_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget___items_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidget) __items_newList() unsafe.Pointer {
	return C.QTreeWidget___items_newList(ptr.Pointer())
}

func (ptr *QTreeWidget) __selectedItems_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget___selectedItems_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidget) __selectedItems_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget___selectedItems_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidget) __selectedItems_newList() unsafe.Pointer {
	return C.QTreeWidget___selectedItems_newList(ptr.Pointer())
}

func (ptr *QTreeWidget) __mimeData_items_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidget___mimeData_items_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidget) __mimeData_items_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidget___mimeData_items_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidget) __mimeData_items_newList() unsafe.Pointer {
	return C.QTreeWidget___mimeData_items_newList(ptr.Pointer())
}

type QTreeWidgetItem struct {
	ptr unsafe.Pointer
}

type QTreeWidgetItem_ITF interface {
	QTreeWidgetItem_PTR() *QTreeWidgetItem
}

func (ptr *QTreeWidgetItem) QTreeWidgetItem_PTR() *QTreeWidgetItem {
	return ptr
}

func (ptr *QTreeWidgetItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QTreeWidgetItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQTreeWidgetItem(ptr QTreeWidgetItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTreeWidgetItem_PTR().Pointer()
	}
	return nil
}

func NewQTreeWidgetItemFromPointer(ptr unsafe.Pointer) (n *QTreeWidgetItem) {
	n = new(QTreeWidgetItem)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTreeWidgetItem__ChildIndicatorPolicy
//QTreeWidgetItem::ChildIndicatorPolicy
type QTreeWidgetItem__ChildIndicatorPolicy int64

const (
	QTreeWidgetItem__ShowIndicator                  QTreeWidgetItem__ChildIndicatorPolicy = QTreeWidgetItem__ChildIndicatorPolicy(0)
	QTreeWidgetItem__DontShowIndicator              QTreeWidgetItem__ChildIndicatorPolicy = QTreeWidgetItem__ChildIndicatorPolicy(1)
	QTreeWidgetItem__DontShowIndicatorWhenChildless QTreeWidgetItem__ChildIndicatorPolicy = QTreeWidgetItem__ChildIndicatorPolicy(2)
)

//go:generate stringer -type=QTreeWidgetItem__ItemType
//QTreeWidgetItem::ItemType
type QTreeWidgetItem__ItemType int64

const (
	QTreeWidgetItem__Type     QTreeWidgetItem__ItemType = QTreeWidgetItem__ItemType(0)
	QTreeWidgetItem__UserType QTreeWidgetItem__ItemType = QTreeWidgetItem__ItemType(1000)
)

func (ptr *QTreeWidgetItem) TakeChildren() []*QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QTreeWidgetItem {
			out := make([]*QTreeWidgetItem, int(l.len))
			tmpList := NewQTreeWidgetItemFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__takeChildren_atList(i)
			}
			return out
		}(C.QTreeWidgetItem_TakeChildren(ptr.Pointer()))
	}
	return make([]*QTreeWidgetItem, 0)
}

func (ptr *QTreeWidgetItem) TakeChild(index int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_TakeChild(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func NewQTreeWidgetItem5(parent QTreeWidget_ITF, preceding QTreeWidgetItem_ITF, ty int) *QTreeWidgetItem {
	return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_NewQTreeWidgetItem5(PointerFromQTreeWidget(parent), PointerFromQTreeWidgetItem(preceding), C.int(int32(ty))))
}

func NewQTreeWidgetItem4(parent QTreeWidget_ITF, strin []string, ty int) *QTreeWidgetItem {
	strinC := C.CString(strings.Join(strin, "|"))
	defer C.free(unsafe.Pointer(strinC))
	return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_NewQTreeWidgetItem4(PointerFromQTreeWidget(parent), C.struct_QtWidgets_PackedString{data: strinC, len: C.longlong(len(strings.Join(strin, "|")))}, C.int(int32(ty))))
}

func NewQTreeWidgetItem3(parent QTreeWidget_ITF, ty int) *QTreeWidgetItem {
	return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_NewQTreeWidgetItem3(PointerFromQTreeWidget(parent), C.int(int32(ty))))
}

func NewQTreeWidgetItem8(parent QTreeWidgetItem_ITF, preceding QTreeWidgetItem_ITF, ty int) *QTreeWidgetItem {
	return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_NewQTreeWidgetItem8(PointerFromQTreeWidgetItem(parent), PointerFromQTreeWidgetItem(preceding), C.int(int32(ty))))
}

func NewQTreeWidgetItem7(parent QTreeWidgetItem_ITF, strin []string, ty int) *QTreeWidgetItem {
	strinC := C.CString(strings.Join(strin, "|"))
	defer C.free(unsafe.Pointer(strinC))
	return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_NewQTreeWidgetItem7(PointerFromQTreeWidgetItem(parent), C.struct_QtWidgets_PackedString{data: strinC, len: C.longlong(len(strings.Join(strin, "|")))}, C.int(int32(ty))))
}

func NewQTreeWidgetItem6(parent QTreeWidgetItem_ITF, ty int) *QTreeWidgetItem {
	return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_NewQTreeWidgetItem6(PointerFromQTreeWidgetItem(parent), C.int(int32(ty))))
}

func NewQTreeWidgetItem2(strin []string, ty int) *QTreeWidgetItem {
	strinC := C.CString(strings.Join(strin, "|"))
	defer C.free(unsafe.Pointer(strinC))
	return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_NewQTreeWidgetItem2(C.struct_QtWidgets_PackedString{data: strinC, len: C.longlong(len(strings.Join(strin, "|")))}, C.int(int32(ty))))
}

func NewQTreeWidgetItem9(other QTreeWidgetItem_ITF) *QTreeWidgetItem {
	return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_NewQTreeWidgetItem9(PointerFromQTreeWidgetItem(other)))
}

func NewQTreeWidgetItem(ty int) *QTreeWidgetItem {
	return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_NewQTreeWidgetItem(C.int(int32(ty))))
}

func (ptr *QTreeWidgetItem) AddChild(child QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_AddChild(ptr.Pointer(), PointerFromQTreeWidgetItem(child))
	}
}

func (ptr *QTreeWidgetItem) AddChildren(children []*QTreeWidgetItem) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_AddChildren(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQTreeWidgetItemFromPointer(NewQTreeWidgetItemFromPointer(nil).__addChildren_children_newList())
			for _, v := range children {
				tmpList.__addChildren_children_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QTreeWidgetItem) EmitDataChanged() {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_EmitDataChanged(ptr.Pointer())
	}
}

func (ptr *QTreeWidgetItem) InsertChild(index int, child QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_InsertChild(ptr.Pointer(), C.int(int32(index)), PointerFromQTreeWidgetItem(child))
	}
}

func (ptr *QTreeWidgetItem) InsertChildren(index int, children []*QTreeWidgetItem) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_InsertChildren(ptr.Pointer(), C.int(int32(index)), func() unsafe.Pointer {
			tmpList := NewQTreeWidgetItemFromPointer(NewQTreeWidgetItemFromPointer(nil).__insertChildren_children_newList())
			for _, v := range children {
				tmpList.__insertChildren_children_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQTreeWidgetItem_Read
func callbackQTreeWidgetItem_Read(ptr unsafe.Pointer, in unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "read"); signal != nil {
		(*(*func(*core.QDataStream))(signal))(core.NewQDataStreamFromPointer(in))
	} else {
		NewQTreeWidgetItemFromPointer(ptr).ReadDefault(core.NewQDataStreamFromPointer(in))
	}
}

func (ptr *QTreeWidgetItem) ConnectRead(f func(in *core.QDataStream)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "read"); signal != nil {
			f := func(in *core.QDataStream) {
				(*(*func(*core.QDataStream))(signal))(in)
				f(in)
			}
			qt.ConnectSignal(ptr.Pointer(), "read", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "read", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidgetItem) DisconnectRead() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "read")
	}
}

func (ptr *QTreeWidgetItem) Read(in core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_Read(ptr.Pointer(), core.PointerFromQDataStream(in))
	}
}

func (ptr *QTreeWidgetItem) ReadDefault(in core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_ReadDefault(ptr.Pointer(), core.PointerFromQDataStream(in))
	}
}

func (ptr *QTreeWidgetItem) RemoveChild(child QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_RemoveChild(ptr.Pointer(), PointerFromQTreeWidgetItem(child))
	}
}

func (ptr *QTreeWidgetItem) SetBackground(column int, brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetBackground(ptr.Pointer(), C.int(int32(column)), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QTreeWidgetItem) SetCheckState(column int, state core.Qt__CheckState) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetCheckState(ptr.Pointer(), C.int(int32(column)), C.longlong(state))
	}
}

func (ptr *QTreeWidgetItem) SetChildIndicatorPolicy(policy QTreeWidgetItem__ChildIndicatorPolicy) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetChildIndicatorPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

//export callbackQTreeWidgetItem_SetData
func callbackQTreeWidgetItem_SetData(ptr unsafe.Pointer, column C.int, role C.int, value unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setData"); signal != nil {
		(*(*func(int, int, *core.QVariant))(signal))(int(int32(column)), int(int32(role)), core.NewQVariantFromPointer(value))
	} else {
		NewQTreeWidgetItemFromPointer(ptr).SetDataDefault(int(int32(column)), int(int32(role)), core.NewQVariantFromPointer(value))
	}
}

func (ptr *QTreeWidgetItem) ConnectSetData(f func(column int, role int, value *core.QVariant)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setData"); signal != nil {
			f := func(column int, role int, value *core.QVariant) {
				(*(*func(int, int, *core.QVariant))(signal))(column, role, value)
				f(column, role, value)
			}
			qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidgetItem) DisconnectSetData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setData")
	}
}

func (ptr *QTreeWidgetItem) SetData(column int, role int, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetData(ptr.Pointer(), C.int(int32(column)), C.int(int32(role)), core.PointerFromQVariant(value))
	}
}

func (ptr *QTreeWidgetItem) SetDataDefault(column int, role int, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetDataDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(role)), core.PointerFromQVariant(value))
	}
}

func (ptr *QTreeWidgetItem) SetDisabled(disabled bool) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetDisabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(disabled))))
	}
}

func (ptr *QTreeWidgetItem) SetExpanded(expand bool) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetExpanded(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(expand))))
	}
}

func (ptr *QTreeWidgetItem) SetFirstColumnSpanned(span bool) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetFirstColumnSpanned(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(span))))
	}
}

func (ptr *QTreeWidgetItem) SetFlags(flags core.Qt__ItemFlag) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetFlags(ptr.Pointer(), C.longlong(flags))
	}
}

func (ptr *QTreeWidgetItem) SetFont(column int, font gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetFont(ptr.Pointer(), C.int(int32(column)), gui.PointerFromQFont(font))
	}
}

func (ptr *QTreeWidgetItem) SetForeground(column int, brush gui.QBrush_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetForeground(ptr.Pointer(), C.int(int32(column)), gui.PointerFromQBrush(brush))
	}
}

func (ptr *QTreeWidgetItem) SetHidden(hide bool) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetHidden(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hide))))
	}
}

func (ptr *QTreeWidgetItem) SetIcon(column int, icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetIcon(ptr.Pointer(), C.int(int32(column)), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QTreeWidgetItem) SetSelected(sele bool) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetSelected(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(sele))))
	}
}

func (ptr *QTreeWidgetItem) SetSizeHint(column int, size core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetSizeHint(ptr.Pointer(), C.int(int32(column)), core.PointerFromQSize(size))
	}
}

func (ptr *QTreeWidgetItem) SetStatusTip(column int, statusTip string) {
	if ptr.Pointer() != nil {
		var statusTipC *C.char
		if statusTip != "" {
			statusTipC = C.CString(statusTip)
			defer C.free(unsafe.Pointer(statusTipC))
		}
		C.QTreeWidgetItem_SetStatusTip(ptr.Pointer(), C.int(int32(column)), C.struct_QtWidgets_PackedString{data: statusTipC, len: C.longlong(len(statusTip))})
	}
}

func (ptr *QTreeWidgetItem) SetText(column int, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QTreeWidgetItem_SetText(ptr.Pointer(), C.int(int32(column)), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QTreeWidgetItem) SetTextAlignment(column int, alignment int) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SetTextAlignment(ptr.Pointer(), C.int(int32(column)), C.int(int32(alignment)))
	}
}

func (ptr *QTreeWidgetItem) SetToolTip(column int, toolTip string) {
	if ptr.Pointer() != nil {
		var toolTipC *C.char
		if toolTip != "" {
			toolTipC = C.CString(toolTip)
			defer C.free(unsafe.Pointer(toolTipC))
		}
		C.QTreeWidgetItem_SetToolTip(ptr.Pointer(), C.int(int32(column)), C.struct_QtWidgets_PackedString{data: toolTipC, len: C.longlong(len(toolTip))})
	}
}

func (ptr *QTreeWidgetItem) SetWhatsThis(column int, whatsThis string) {
	if ptr.Pointer() != nil {
		var whatsThisC *C.char
		if whatsThis != "" {
			whatsThisC = C.CString(whatsThis)
			defer C.free(unsafe.Pointer(whatsThisC))
		}
		C.QTreeWidgetItem_SetWhatsThis(ptr.Pointer(), C.int(int32(column)), C.struct_QtWidgets_PackedString{data: whatsThisC, len: C.longlong(len(whatsThis))})
	}
}

func (ptr *QTreeWidgetItem) SortChildren(column int, order core.Qt__SortOrder) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_SortChildren(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
	}
}

//export callbackQTreeWidgetItem_DestroyQTreeWidgetItem
func callbackQTreeWidgetItem_DestroyQTreeWidgetItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QTreeWidgetItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQTreeWidgetItemFromPointer(ptr).DestroyQTreeWidgetItemDefault()
	}
}

func (ptr *QTreeWidgetItem) ConnectDestroyQTreeWidgetItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QTreeWidgetItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QTreeWidgetItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QTreeWidgetItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidgetItem) DisconnectDestroyQTreeWidgetItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QTreeWidgetItem")
	}
}

func (ptr *QTreeWidgetItem) DestroyQTreeWidgetItem() {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_DestroyQTreeWidgetItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTreeWidgetItem) DestroyQTreeWidgetItemDefault() {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_DestroyQTreeWidgetItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QTreeWidgetItem) Background(column int) *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QTreeWidgetItem_Background(ptr.Pointer(), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidgetItem) Foreground(column int) *gui.QBrush {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQBrushFromPointer(C.QTreeWidgetItem_Foreground(ptr.Pointer(), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*gui.QBrush).DestroyQBrush)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidgetItem) Font(column int) *gui.QFont {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontFromPointer(C.QTreeWidgetItem_Font(ptr.Pointer(), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*gui.QFont).DestroyQFont)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidgetItem) Icon(column int) *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QTreeWidgetItem_Icon(ptr.Pointer(), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidgetItem) SizeHint(column int) *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QTreeWidgetItem_SizeHint(ptr.Pointer(), C.int(int32(column))))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidgetItem) StatusTip(column int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTreeWidgetItem_StatusTip(ptr.Pointer(), C.int(int32(column))))
	}
	return ""
}

func (ptr *QTreeWidgetItem) Text(column int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTreeWidgetItem_Text(ptr.Pointer(), C.int(int32(column))))
	}
	return ""
}

func (ptr *QTreeWidgetItem) ToolTip(column int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTreeWidgetItem_ToolTip(ptr.Pointer(), C.int(int32(column))))
	}
	return ""
}

func (ptr *QTreeWidgetItem) WhatsThis(column int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QTreeWidgetItem_WhatsThis(ptr.Pointer(), C.int(int32(column))))
	}
	return ""
}

func (ptr *QTreeWidgetItem) TreeWidget() *QTreeWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQTreeWidgetFromPointer(C.QTreeWidgetItem_TreeWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidgetItem) Child(index int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_Child(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

//export callbackQTreeWidgetItem_Clone
func callbackQTreeWidgetItem_Clone(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "clone"); signal != nil {
		return PointerFromQTreeWidgetItem((*(*func() *QTreeWidgetItem)(signal))())
	}

	return PointerFromQTreeWidgetItem(NewQTreeWidgetItemFromPointer(ptr).CloneDefault())
}

func (ptr *QTreeWidgetItem) ConnectClone(f func() *QTreeWidgetItem) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "clone"); signal != nil {
			f := func() *QTreeWidgetItem {
				(*(*func() *QTreeWidgetItem)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "clone", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "clone", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidgetItem) DisconnectClone() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "clone")
	}
}

func (ptr *QTreeWidgetItem) Clone() *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_Clone(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTreeWidgetItem) CloneDefault() *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_CloneDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTreeWidgetItem) Parent() *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem_Parent(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTreeWidgetItem) ChildIndicatorPolicy() QTreeWidgetItem__ChildIndicatorPolicy {
	if ptr.Pointer() != nil {
		return QTreeWidgetItem__ChildIndicatorPolicy(C.QTreeWidgetItem_ChildIndicatorPolicy(ptr.Pointer()))
	}
	return 0
}

//export callbackQTreeWidgetItem_Data
func callbackQTreeWidgetItem_Data(ptr unsafe.Pointer, column C.int, role C.int) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "data"); signal != nil {
		return core.PointerFromQVariant((*(*func(int, int) *core.QVariant)(signal))(int(int32(column)), int(int32(role))))
	}

	return core.PointerFromQVariant(NewQTreeWidgetItemFromPointer(ptr).DataDefault(int(int32(column)), int(int32(role))))
}

func (ptr *QTreeWidgetItem) ConnectData(f func(column int, role int) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "data"); signal != nil {
			f := func(column int, role int) *core.QVariant {
				(*(*func(int, int) *core.QVariant)(signal))(column, role)
				return f(column, role)
			}
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "data", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidgetItem) DisconnectData() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "data")
	}
}

func (ptr *QTreeWidgetItem) Data(column int, role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QTreeWidgetItem_Data(ptr.Pointer(), C.int(int32(column)), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidgetItem) DataDefault(column int, role int) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QTreeWidgetItem_DataDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(role))))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QTreeWidgetItem) CheckState(column int) core.Qt__CheckState {
	if ptr.Pointer() != nil {
		return core.Qt__CheckState(C.QTreeWidgetItem_CheckState(ptr.Pointer(), C.int(int32(column))))
	}
	return 0
}

func (ptr *QTreeWidgetItem) Flags() core.Qt__ItemFlag {
	if ptr.Pointer() != nil {
		return core.Qt__ItemFlag(C.QTreeWidgetItem_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTreeWidgetItem) IsDisabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeWidgetItem_IsDisabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeWidgetItem) IsExpanded() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeWidgetItem_IsExpanded(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeWidgetItem) IsFirstColumnSpanned() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeWidgetItem_IsFirstColumnSpanned(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeWidgetItem) IsHidden() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeWidgetItem_IsHidden(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeWidgetItem) IsSelected() bool {
	if ptr.Pointer() != nil {
		return int8(C.QTreeWidgetItem_IsSelected(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QTreeWidgetItem) ChildCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidgetItem_ChildCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeWidgetItem) ColumnCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidgetItem_ColumnCount(ptr.Pointer())))
	}
	return 0
}

func (ptr *QTreeWidgetItem) IndexOfChild(child QTreeWidgetItem_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidgetItem_IndexOfChild(ptr.Pointer(), PointerFromQTreeWidgetItem(child))))
	}
	return 0
}

func (ptr *QTreeWidgetItem) TextAlignment(column int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidgetItem_TextAlignment(ptr.Pointer(), C.int(int32(column)))))
	}
	return 0
}

func (ptr *QTreeWidgetItem) Type() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QTreeWidgetItem_Type(ptr.Pointer())))
	}
	return 0
}

//export callbackQTreeWidgetItem_Write
func callbackQTreeWidgetItem_Write(ptr unsafe.Pointer, out unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "write"); signal != nil {
		(*(*func(*core.QDataStream))(signal))(core.NewQDataStreamFromPointer(out))
	} else {
		NewQTreeWidgetItemFromPointer(ptr).WriteDefault(core.NewQDataStreamFromPointer(out))
	}
}

func (ptr *QTreeWidgetItem) ConnectWrite(f func(out *core.QDataStream)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "write"); signal != nil {
			f := func(out *core.QDataStream) {
				(*(*func(*core.QDataStream))(signal))(out)
				f(out)
			}
			qt.ConnectSignal(ptr.Pointer(), "write", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "write", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QTreeWidgetItem) DisconnectWrite() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "write")
	}
}

func (ptr *QTreeWidgetItem) Write(out core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_Write(ptr.Pointer(), core.PointerFromQDataStream(out))
	}
}

func (ptr *QTreeWidgetItem) WriteDefault(out core.QDataStream_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem_WriteDefault(ptr.Pointer(), core.PointerFromQDataStream(out))
	}
}

func (ptr *QTreeWidgetItem) __takeChildren_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem___takeChildren_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidgetItem) __takeChildren_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem___takeChildren_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidgetItem) __takeChildren_newList() unsafe.Pointer {
	return C.QTreeWidgetItem___takeChildren_newList(ptr.Pointer())
}

func (ptr *QTreeWidgetItem) __addChildren_children_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem___addChildren_children_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidgetItem) __addChildren_children_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem___addChildren_children_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidgetItem) __addChildren_children_newList() unsafe.Pointer {
	return C.QTreeWidgetItem___addChildren_children_newList(ptr.Pointer())
}

func (ptr *QTreeWidgetItem) __insertChildren_children_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem___insertChildren_children_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidgetItem) __insertChildren_children_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem___insertChildren_children_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidgetItem) __insertChildren_children_newList() unsafe.Pointer {
	return C.QTreeWidgetItem___insertChildren_children_newList(ptr.Pointer())
}

func (ptr *QTreeWidgetItem) __children_atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem___children_atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidgetItem) __children_setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem___children_setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidgetItem) __children_newList() unsafe.Pointer {
	return C.QTreeWidgetItem___children_newList(ptr.Pointer())
}

func (ptr *QTreeWidgetItem) __setChildren__atList(i int) *QTreeWidgetItem {
	if ptr.Pointer() != nil {
		return NewQTreeWidgetItemFromPointer(C.QTreeWidgetItem___setChildren__atList(ptr.Pointer(), C.int(int32(i))))
	}
	return nil
}

func (ptr *QTreeWidgetItem) __setChildren__setList(i QTreeWidgetItem_ITF) {
	if ptr.Pointer() != nil {
		C.QTreeWidgetItem___setChildren__setList(ptr.Pointer(), PointerFromQTreeWidgetItem(i))
	}
}

func (ptr *QTreeWidgetItem) __setChildren__newList() unsafe.Pointer {
	return C.QTreeWidgetItem___setChildren__newList(ptr.Pointer())
}

type QTreeWidgetItemIterator struct {
	ptr unsafe.Pointer
}

type QTreeWidgetItemIterator_ITF interface {
	QTreeWidgetItemIterator_PTR() *QTreeWidgetItemIterator
}

func (ptr *QTreeWidgetItemIterator) QTreeWidgetItemIterator_PTR() *QTreeWidgetItemIterator {
	return ptr
}

func (ptr *QTreeWidgetItemIterator) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QTreeWidgetItemIterator) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQTreeWidgetItemIterator(ptr QTreeWidgetItemIterator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTreeWidgetItemIterator_PTR().Pointer()
	}
	return nil
}

func NewQTreeWidgetItemIteratorFromPointer(ptr unsafe.Pointer) (n *QTreeWidgetItemIterator) {
	n = new(QTreeWidgetItemIterator)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QTreeWidgetItemIterator__IteratorFlag
//QTreeWidgetItemIterator::IteratorFlag
type QTreeWidgetItemIterator__IteratorFlag int64

const (
	QTreeWidgetItemIterator__All           QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000000)
	QTreeWidgetItemIterator__Hidden        QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000001)
	QTreeWidgetItemIterator__NotHidden     QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000002)
	QTreeWidgetItemIterator__Selected      QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000004)
	QTreeWidgetItemIterator__Unselected    QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000008)
	QTreeWidgetItemIterator__Selectable    QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000010)
	QTreeWidgetItemIterator__NotSelectable QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000020)
	QTreeWidgetItemIterator__DragEnabled   QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000040)
	QTreeWidgetItemIterator__DragDisabled  QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000080)
	QTreeWidgetItemIterator__DropEnabled   QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000100)
	QTreeWidgetItemIterator__DropDisabled  QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000200)
	QTreeWidgetItemIterator__HasChildren   QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000400)
	QTreeWidgetItemIterator__NoChildren    QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00000800)
	QTreeWidgetItemIterator__Checked       QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00001000)
	QTreeWidgetItemIterator__NotChecked    QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00002000)
	QTreeWidgetItemIterator__Enabled       QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00004000)
	QTreeWidgetItemIterator__Disabled      QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00008000)
	QTreeWidgetItemIterator__Editable      QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00010000)
	QTreeWidgetItemIterator__NotEditable   QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x00020000)
	QTreeWidgetItemIterator__UserFlag      QTreeWidgetItemIterator__IteratorFlag = QTreeWidgetItemIterator__IteratorFlag(0x01000000)
)

type QUndoCommand struct {
	ptr unsafe.Pointer
}

type QUndoCommand_ITF interface {
	QUndoCommand_PTR() *QUndoCommand
}

func (ptr *QUndoCommand) QUndoCommand_PTR() *QUndoCommand {
	return ptr
}

func (ptr *QUndoCommand) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QUndoCommand) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQUndoCommand(ptr QUndoCommand_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUndoCommand_PTR().Pointer()
	}
	return nil
}

func NewQUndoCommandFromPointer(ptr unsafe.Pointer) (n *QUndoCommand) {
	n = new(QUndoCommand)
	n.SetPointer(ptr)
	return
}
func NewQUndoCommand(parent QUndoCommand_ITF) *QUndoCommand {
	return NewQUndoCommandFromPointer(C.QUndoCommand_NewQUndoCommand(PointerFromQUndoCommand(parent)))
}

func NewQUndoCommand2(text string, parent QUndoCommand_ITF) *QUndoCommand {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	return NewQUndoCommandFromPointer(C.QUndoCommand_NewQUndoCommand2(C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQUndoCommand(parent)))
}

//export callbackQUndoCommand_MergeWith
func callbackQUndoCommand_MergeWith(ptr unsafe.Pointer, command unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "mergeWith"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*QUndoCommand) bool)(signal))(NewQUndoCommandFromPointer(command)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQUndoCommandFromPointer(ptr).MergeWithDefault(NewQUndoCommandFromPointer(command)))))
}

func (ptr *QUndoCommand) ConnectMergeWith(f func(command *QUndoCommand) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mergeWith"); signal != nil {
			f := func(command *QUndoCommand) bool {
				(*(*func(*QUndoCommand) bool)(signal))(command)
				return f(command)
			}
			qt.ConnectSignal(ptr.Pointer(), "mergeWith", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mergeWith", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoCommand) DisconnectMergeWith() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mergeWith")
	}
}

func (ptr *QUndoCommand) MergeWith(command QUndoCommand_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoCommand_MergeWith(ptr.Pointer(), PointerFromQUndoCommand(command))) != 0
	}
	return false
}

func (ptr *QUndoCommand) MergeWithDefault(command QUndoCommand_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoCommand_MergeWithDefault(ptr.Pointer(), PointerFromQUndoCommand(command))) != 0
	}
	return false
}

//export callbackQUndoCommand_Redo
func callbackQUndoCommand_Redo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "redo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoCommandFromPointer(ptr).RedoDefault()
	}
}

func (ptr *QUndoCommand) ConnectRedo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "redo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoCommand) DisconnectRedo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "redo")
	}
}

func (ptr *QUndoCommand) Redo() {
	if ptr.Pointer() != nil {
		C.QUndoCommand_Redo(ptr.Pointer())
	}
}

func (ptr *QUndoCommand) RedoDefault() {
	if ptr.Pointer() != nil {
		C.QUndoCommand_RedoDefault(ptr.Pointer())
	}
}

func (ptr *QUndoCommand) SetObsolete(obsolete bool) {
	if ptr.Pointer() != nil {
		C.QUndoCommand_SetObsolete(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(obsolete))))
	}
}

func (ptr *QUndoCommand) SetText(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QUndoCommand_SetText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQUndoCommand_Undo
func callbackQUndoCommand_Undo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "undo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoCommandFromPointer(ptr).UndoDefault()
	}
}

func (ptr *QUndoCommand) ConnectUndo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "undo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoCommand) DisconnectUndo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "undo")
	}
}

func (ptr *QUndoCommand) Undo() {
	if ptr.Pointer() != nil {
		C.QUndoCommand_Undo(ptr.Pointer())
	}
}

func (ptr *QUndoCommand) UndoDefault() {
	if ptr.Pointer() != nil {
		C.QUndoCommand_UndoDefault(ptr.Pointer())
	}
}

//export callbackQUndoCommand_DestroyQUndoCommand
func callbackQUndoCommand_DestroyQUndoCommand(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QUndoCommand"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoCommandFromPointer(ptr).DestroyQUndoCommandDefault()
	}
}

func (ptr *QUndoCommand) ConnectDestroyQUndoCommand(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QUndoCommand"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QUndoCommand", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QUndoCommand", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoCommand) DisconnectDestroyQUndoCommand() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QUndoCommand")
	}
}

func (ptr *QUndoCommand) DestroyQUndoCommand() {
	if ptr.Pointer() != nil {
		C.QUndoCommand_DestroyQUndoCommand(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QUndoCommand) DestroyQUndoCommandDefault() {
	if ptr.Pointer() != nil {
		C.QUndoCommand_DestroyQUndoCommandDefault(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QUndoCommand) ActionText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUndoCommand_ActionText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUndoCommand) Text() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUndoCommand_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUndoCommand) IsObsolete() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoCommand_IsObsolete(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUndoCommand) Child(index int) *QUndoCommand {
	if ptr.Pointer() != nil {
		return NewQUndoCommandFromPointer(C.QUndoCommand_Child(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QUndoCommand) ChildCount() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QUndoCommand_ChildCount(ptr.Pointer())))
	}
	return 0
}

//export callbackQUndoCommand_Id
func callbackQUndoCommand_Id(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "id"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQUndoCommandFromPointer(ptr).IdDefault()))
}

func (ptr *QUndoCommand) ConnectId(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "id"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "id", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "id", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoCommand) DisconnectId() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "id")
	}
}

func (ptr *QUndoCommand) Id() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QUndoCommand_Id(ptr.Pointer())))
	}
	return 0
}

func (ptr *QUndoCommand) IdDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QUndoCommand_IdDefault(ptr.Pointer())))
	}
	return 0
}

type QUndoGroup struct {
	core.QObject
}

type QUndoGroup_ITF interface {
	core.QObject_ITF
	QUndoGroup_PTR() *QUndoGroup
}

func (ptr *QUndoGroup) QUndoGroup_PTR() *QUndoGroup {
	return ptr
}

func (ptr *QUndoGroup) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QUndoGroup) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQUndoGroup(ptr QUndoGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUndoGroup_PTR().Pointer()
	}
	return nil
}

func NewQUndoGroupFromPointer(ptr unsafe.Pointer) (n *QUndoGroup) {
	n = new(QUndoGroup)
	n.SetPointer(ptr)
	return
}
func QUndoGroup_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QUndoGroup_QUndoGroup_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QUndoGroup) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QUndoGroup_QUndoGroup_Tr(sC, cC, C.int(int32(n))))
}

func NewQUndoGroup(parent core.QObject_ITF) *QUndoGroup {
	tmpValue := NewQUndoGroupFromPointer(C.QUndoGroup_NewQUndoGroup(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQUndoGroup_ActiveStackChanged
func callbackQUndoGroup_ActiveStackChanged(ptr unsafe.Pointer, stack unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "activeStackChanged"); signal != nil {
		(*(*func(*QUndoStack))(signal))(NewQUndoStackFromPointer(stack))
	}

}

func (ptr *QUndoGroup) ConnectActiveStackChanged(f func(stack *QUndoStack)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "activeStackChanged") {
			C.QUndoGroup_ConnectActiveStackChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "activeStackChanged"); signal != nil {
			f := func(stack *QUndoStack) {
				(*(*func(*QUndoStack))(signal))(stack)
				f(stack)
			}
			qt.ConnectSignal(ptr.Pointer(), "activeStackChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "activeStackChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectActiveStackChanged() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DisconnectActiveStackChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "activeStackChanged")
	}
}

func (ptr *QUndoGroup) ActiveStackChanged(stack QUndoStack_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_ActiveStackChanged(ptr.Pointer(), PointerFromQUndoStack(stack))
	}
}

func (ptr *QUndoGroup) AddStack(stack QUndoStack_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_AddStack(ptr.Pointer(), PointerFromQUndoStack(stack))
	}
}

//export callbackQUndoGroup_CanRedoChanged
func callbackQUndoGroup_CanRedoChanged(ptr unsafe.Pointer, canRedo C.char) {
	if signal := qt.GetSignal(ptr, "canRedoChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(canRedo) != 0)
	}

}

func (ptr *QUndoGroup) ConnectCanRedoChanged(f func(canRedo bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "canRedoChanged") {
			C.QUndoGroup_ConnectCanRedoChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "canRedoChanged"); signal != nil {
			f := func(canRedo bool) {
				(*(*func(bool))(signal))(canRedo)
				f(canRedo)
			}
			qt.ConnectSignal(ptr.Pointer(), "canRedoChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canRedoChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectCanRedoChanged() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DisconnectCanRedoChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "canRedoChanged")
	}
}

func (ptr *QUndoGroup) CanRedoChanged(canRedo bool) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_CanRedoChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(canRedo))))
	}
}

//export callbackQUndoGroup_CanUndoChanged
func callbackQUndoGroup_CanUndoChanged(ptr unsafe.Pointer, canUndo C.char) {
	if signal := qt.GetSignal(ptr, "canUndoChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(canUndo) != 0)
	}

}

func (ptr *QUndoGroup) ConnectCanUndoChanged(f func(canUndo bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "canUndoChanged") {
			C.QUndoGroup_ConnectCanUndoChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "canUndoChanged"); signal != nil {
			f := func(canUndo bool) {
				(*(*func(bool))(signal))(canUndo)
				f(canUndo)
			}
			qt.ConnectSignal(ptr.Pointer(), "canUndoChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canUndoChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectCanUndoChanged() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DisconnectCanUndoChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "canUndoChanged")
	}
}

func (ptr *QUndoGroup) CanUndoChanged(canUndo bool) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_CanUndoChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(canUndo))))
	}
}

//export callbackQUndoGroup_CleanChanged
func callbackQUndoGroup_CleanChanged(ptr unsafe.Pointer, clean C.char) {
	if signal := qt.GetSignal(ptr, "cleanChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(clean) != 0)
	}

}

func (ptr *QUndoGroup) ConnectCleanChanged(f func(clean bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cleanChanged") {
			C.QUndoGroup_ConnectCleanChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cleanChanged"); signal != nil {
			f := func(clean bool) {
				(*(*func(bool))(signal))(clean)
				f(clean)
			}
			qt.ConnectSignal(ptr.Pointer(), "cleanChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cleanChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectCleanChanged() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DisconnectCleanChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cleanChanged")
	}
}

func (ptr *QUndoGroup) CleanChanged(clean bool) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_CleanChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(clean))))
	}
}

//export callbackQUndoGroup_IndexChanged
func callbackQUndoGroup_IndexChanged(ptr unsafe.Pointer, idx C.int) {
	if signal := qt.GetSignal(ptr, "indexChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(idx)))
	}

}

func (ptr *QUndoGroup) ConnectIndexChanged(f func(idx int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "indexChanged") {
			C.QUndoGroup_ConnectIndexChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "indexChanged"); signal != nil {
			f := func(idx int) {
				(*(*func(int))(signal))(idx)
				f(idx)
			}
			qt.ConnectSignal(ptr.Pointer(), "indexChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "indexChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectIndexChanged() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DisconnectIndexChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "indexChanged")
	}
}

func (ptr *QUndoGroup) IndexChanged(idx int) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_IndexChanged(ptr.Pointer(), C.int(int32(idx)))
	}
}

//export callbackQUndoGroup_Redo
func callbackQUndoGroup_Redo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "redo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoGroupFromPointer(ptr).RedoDefault()
	}
}

func (ptr *QUndoGroup) ConnectRedo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "redo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectRedo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "redo")
	}
}

func (ptr *QUndoGroup) Redo() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_Redo(ptr.Pointer())
	}
}

func (ptr *QUndoGroup) RedoDefault() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_RedoDefault(ptr.Pointer())
	}
}

//export callbackQUndoGroup_RedoTextChanged
func callbackQUndoGroup_RedoTextChanged(ptr unsafe.Pointer, redoText C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "redoTextChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(redoText))
	}

}

func (ptr *QUndoGroup) ConnectRedoTextChanged(f func(redoText string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "redoTextChanged") {
			C.QUndoGroup_ConnectRedoTextChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "redoTextChanged"); signal != nil {
			f := func(redoText string) {
				(*(*func(string))(signal))(redoText)
				f(redoText)
			}
			qt.ConnectSignal(ptr.Pointer(), "redoTextChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redoTextChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectRedoTextChanged() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DisconnectRedoTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "redoTextChanged")
	}
}

func (ptr *QUndoGroup) RedoTextChanged(redoText string) {
	if ptr.Pointer() != nil {
		var redoTextC *C.char
		if redoText != "" {
			redoTextC = C.CString(redoText)
			defer C.free(unsafe.Pointer(redoTextC))
		}
		C.QUndoGroup_RedoTextChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: redoTextC, len: C.longlong(len(redoText))})
	}
}

func (ptr *QUndoGroup) RemoveStack(stack QUndoStack_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_RemoveStack(ptr.Pointer(), PointerFromQUndoStack(stack))
	}
}

//export callbackQUndoGroup_SetActiveStack
func callbackQUndoGroup_SetActiveStack(ptr unsafe.Pointer, stack unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setActiveStack"); signal != nil {
		(*(*func(*QUndoStack))(signal))(NewQUndoStackFromPointer(stack))
	} else {
		NewQUndoGroupFromPointer(ptr).SetActiveStackDefault(NewQUndoStackFromPointer(stack))
	}
}

func (ptr *QUndoGroup) ConnectSetActiveStack(f func(stack *QUndoStack)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setActiveStack"); signal != nil {
			f := func(stack *QUndoStack) {
				(*(*func(*QUndoStack))(signal))(stack)
				f(stack)
			}
			qt.ConnectSignal(ptr.Pointer(), "setActiveStack", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setActiveStack", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectSetActiveStack() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setActiveStack")
	}
}

func (ptr *QUndoGroup) SetActiveStack(stack QUndoStack_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_SetActiveStack(ptr.Pointer(), PointerFromQUndoStack(stack))
	}
}

func (ptr *QUndoGroup) SetActiveStackDefault(stack QUndoStack_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_SetActiveStackDefault(ptr.Pointer(), PointerFromQUndoStack(stack))
	}
}

//export callbackQUndoGroup_Undo
func callbackQUndoGroup_Undo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "undo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoGroupFromPointer(ptr).UndoDefault()
	}
}

func (ptr *QUndoGroup) ConnectUndo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "undo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectUndo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "undo")
	}
}

func (ptr *QUndoGroup) Undo() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_Undo(ptr.Pointer())
	}
}

func (ptr *QUndoGroup) UndoDefault() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_UndoDefault(ptr.Pointer())
	}
}

//export callbackQUndoGroup_UndoTextChanged
func callbackQUndoGroup_UndoTextChanged(ptr unsafe.Pointer, undoText C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "undoTextChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(undoText))
	}

}

func (ptr *QUndoGroup) ConnectUndoTextChanged(f func(undoText string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "undoTextChanged") {
			C.QUndoGroup_ConnectUndoTextChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "undoTextChanged"); signal != nil {
			f := func(undoText string) {
				(*(*func(string))(signal))(undoText)
				f(undoText)
			}
			qt.ConnectSignal(ptr.Pointer(), "undoTextChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undoTextChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectUndoTextChanged() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DisconnectUndoTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "undoTextChanged")
	}
}

func (ptr *QUndoGroup) UndoTextChanged(undoText string) {
	if ptr.Pointer() != nil {
		var undoTextC *C.char
		if undoText != "" {
			undoTextC = C.CString(undoText)
			defer C.free(unsafe.Pointer(undoTextC))
		}
		C.QUndoGroup_UndoTextChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: undoTextC, len: C.longlong(len(undoText))})
	}
}

//export callbackQUndoGroup_DestroyQUndoGroup
func callbackQUndoGroup_DestroyQUndoGroup(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QUndoGroup"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoGroupFromPointer(ptr).DestroyQUndoGroupDefault()
	}
}

func (ptr *QUndoGroup) ConnectDestroyQUndoGroup(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QUndoGroup"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QUndoGroup", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QUndoGroup", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoGroup) DisconnectDestroyQUndoGroup() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QUndoGroup")
	}
}

func (ptr *QUndoGroup) DestroyQUndoGroup() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DestroyQUndoGroup(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QUndoGroup) DestroyQUndoGroupDefault() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DestroyQUndoGroupDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QUndoGroup) CreateRedoAction(parent core.QObject_ITF, prefix string) *QAction {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		tmpValue := NewQActionFromPointer(C.QUndoGroup_CreateRedoAction(ptr.Pointer(), core.PointerFromQObject(parent), C.struct_QtWidgets_PackedString{data: prefixC, len: C.longlong(len(prefix))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoGroup) CreateUndoAction(parent core.QObject_ITF, prefix string) *QAction {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		tmpValue := NewQActionFromPointer(C.QUndoGroup_CreateUndoAction(ptr.Pointer(), core.PointerFromQObject(parent), C.struct_QtWidgets_PackedString{data: prefixC, len: C.longlong(len(prefix))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoGroup) Stacks() []*QUndoStack {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QUndoStack {
			out := make([]*QUndoStack, int(l.len))
			tmpList := NewQUndoGroupFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__stacks_atList(i)
			}
			return out
		}(C.QUndoGroup_Stacks(ptr.Pointer()))
	}
	return make([]*QUndoStack, 0)
}

func (ptr *QUndoGroup) RedoText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUndoGroup_RedoText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUndoGroup) UndoText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUndoGroup_UndoText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUndoGroup) ActiveStack() *QUndoStack {
	if ptr.Pointer() != nil {
		tmpValue := NewQUndoStackFromPointer(C.QUndoGroup_ActiveStack(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoGroup) CanRedo() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoGroup_CanRedo(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUndoGroup) CanUndo() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoGroup_CanUndo(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUndoGroup) IsClean() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoGroup_IsClean(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQUndoGroup_MetaObject
func callbackQUndoGroup_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQUndoGroupFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QUndoGroup) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QUndoGroup_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QUndoGroup) __stacks_atList(i int) *QUndoStack {
	if ptr.Pointer() != nil {
		tmpValue := NewQUndoStackFromPointer(C.QUndoGroup___stacks_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoGroup) __stacks_setList(i QUndoStack_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup___stacks_setList(ptr.Pointer(), PointerFromQUndoStack(i))
	}
}

func (ptr *QUndoGroup) __stacks_newList() unsafe.Pointer {
	return C.QUndoGroup___stacks_newList(ptr.Pointer())
}

func (ptr *QUndoGroup) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QUndoGroup___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QUndoGroup) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QUndoGroup) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QUndoGroup___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QUndoGroup) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QUndoGroup___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoGroup) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QUndoGroup) __findChildren_newList2() unsafe.Pointer {
	return C.QUndoGroup___findChildren_newList2(ptr.Pointer())
}

func (ptr *QUndoGroup) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QUndoGroup___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoGroup) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QUndoGroup) __findChildren_newList3() unsafe.Pointer {
	return C.QUndoGroup___findChildren_newList3(ptr.Pointer())
}

func (ptr *QUndoGroup) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QUndoGroup___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoGroup) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QUndoGroup) __findChildren_newList() unsafe.Pointer {
	return C.QUndoGroup___findChildren_newList(ptr.Pointer())
}

func (ptr *QUndoGroup) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QUndoGroup___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoGroup) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QUndoGroup) __children_newList() unsafe.Pointer {
	return C.QUndoGroup___children_newList(ptr.Pointer())
}

//export callbackQUndoGroup_Event
func callbackQUndoGroup_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQUndoGroupFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QUndoGroup) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoGroup_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQUndoGroup_EventFilter
func callbackQUndoGroup_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQUndoGroupFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QUndoGroup) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoGroup_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQUndoGroup_ChildEvent
func callbackQUndoGroup_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQUndoGroupFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QUndoGroup) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQUndoGroup_ConnectNotify
func callbackQUndoGroup_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQUndoGroupFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QUndoGroup) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQUndoGroup_CustomEvent
func callbackQUndoGroup_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQUndoGroupFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QUndoGroup) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQUndoGroup_DeleteLater
func callbackQUndoGroup_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoGroupFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QUndoGroup) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQUndoGroup_Destroyed
func callbackQUndoGroup_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQUndoGroup_DisconnectNotify
func callbackQUndoGroup_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQUndoGroupFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QUndoGroup) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQUndoGroup_ObjectNameChanged
func callbackQUndoGroup_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQUndoGroup_TimerEvent
func callbackQUndoGroup_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQUndoGroupFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QUndoGroup) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoGroup_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QUndoStack struct {
	core.QObject
}

type QUndoStack_ITF interface {
	core.QObject_ITF
	QUndoStack_PTR() *QUndoStack
}

func (ptr *QUndoStack) QUndoStack_PTR() *QUndoStack {
	return ptr
}

func (ptr *QUndoStack) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QUndoStack) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromQUndoStack(ptr QUndoStack_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUndoStack_PTR().Pointer()
	}
	return nil
}

func NewQUndoStackFromPointer(ptr unsafe.Pointer) (n *QUndoStack) {
	n = new(QUndoStack)
	n.SetPointer(ptr)
	return
}
func QUndoStack_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QUndoStack_QUndoStack_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QUndoStack) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QUndoStack_QUndoStack_Tr(sC, cC, C.int(int32(n))))
}

func NewQUndoStack(parent core.QObject_ITF) *QUndoStack {
	tmpValue := NewQUndoStackFromPointer(C.QUndoStack_NewQUndoStack(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QUndoStack) BeginMacro(text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QUndoStack_BeginMacro(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

//export callbackQUndoStack_CanRedoChanged
func callbackQUndoStack_CanRedoChanged(ptr unsafe.Pointer, canRedo C.char) {
	if signal := qt.GetSignal(ptr, "canRedoChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(canRedo) != 0)
	}

}

func (ptr *QUndoStack) ConnectCanRedoChanged(f func(canRedo bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "canRedoChanged") {
			C.QUndoStack_ConnectCanRedoChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "canRedoChanged"); signal != nil {
			f := func(canRedo bool) {
				(*(*func(bool))(signal))(canRedo)
				f(canRedo)
			}
			qt.ConnectSignal(ptr.Pointer(), "canRedoChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canRedoChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectCanRedoChanged() {
	if ptr.Pointer() != nil {
		C.QUndoStack_DisconnectCanRedoChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "canRedoChanged")
	}
}

func (ptr *QUndoStack) CanRedoChanged(canRedo bool) {
	if ptr.Pointer() != nil {
		C.QUndoStack_CanRedoChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(canRedo))))
	}
}

//export callbackQUndoStack_CanUndoChanged
func callbackQUndoStack_CanUndoChanged(ptr unsafe.Pointer, canUndo C.char) {
	if signal := qt.GetSignal(ptr, "canUndoChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(canUndo) != 0)
	}

}

func (ptr *QUndoStack) ConnectCanUndoChanged(f func(canUndo bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "canUndoChanged") {
			C.QUndoStack_ConnectCanUndoChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "canUndoChanged"); signal != nil {
			f := func(canUndo bool) {
				(*(*func(bool))(signal))(canUndo)
				f(canUndo)
			}
			qt.ConnectSignal(ptr.Pointer(), "canUndoChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "canUndoChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectCanUndoChanged() {
	if ptr.Pointer() != nil {
		C.QUndoStack_DisconnectCanUndoChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "canUndoChanged")
	}
}

func (ptr *QUndoStack) CanUndoChanged(canUndo bool) {
	if ptr.Pointer() != nil {
		C.QUndoStack_CanUndoChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(canUndo))))
	}
}

//export callbackQUndoStack_CleanChanged
func callbackQUndoStack_CleanChanged(ptr unsafe.Pointer, clean C.char) {
	if signal := qt.GetSignal(ptr, "cleanChanged"); signal != nil {
		(*(*func(bool))(signal))(int8(clean) != 0)
	}

}

func (ptr *QUndoStack) ConnectCleanChanged(f func(clean bool)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "cleanChanged") {
			C.QUndoStack_ConnectCleanChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "cleanChanged"); signal != nil {
			f := func(clean bool) {
				(*(*func(bool))(signal))(clean)
				f(clean)
			}
			qt.ConnectSignal(ptr.Pointer(), "cleanChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cleanChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectCleanChanged() {
	if ptr.Pointer() != nil {
		C.QUndoStack_DisconnectCleanChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "cleanChanged")
	}
}

func (ptr *QUndoStack) CleanChanged(clean bool) {
	if ptr.Pointer() != nil {
		C.QUndoStack_CleanChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(clean))))
	}
}

func (ptr *QUndoStack) Clear() {
	if ptr.Pointer() != nil {
		C.QUndoStack_Clear(ptr.Pointer())
	}
}

func (ptr *QUndoStack) EndMacro() {
	if ptr.Pointer() != nil {
		C.QUndoStack_EndMacro(ptr.Pointer())
	}
}

//export callbackQUndoStack_IndexChanged
func callbackQUndoStack_IndexChanged(ptr unsafe.Pointer, idx C.int) {
	if signal := qt.GetSignal(ptr, "indexChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(idx)))
	}

}

func (ptr *QUndoStack) ConnectIndexChanged(f func(idx int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "indexChanged") {
			C.QUndoStack_ConnectIndexChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "indexChanged"); signal != nil {
			f := func(idx int) {
				(*(*func(int))(signal))(idx)
				f(idx)
			}
			qt.ConnectSignal(ptr.Pointer(), "indexChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "indexChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectIndexChanged() {
	if ptr.Pointer() != nil {
		C.QUndoStack_DisconnectIndexChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "indexChanged")
	}
}

func (ptr *QUndoStack) IndexChanged(idx int) {
	if ptr.Pointer() != nil {
		C.QUndoStack_IndexChanged(ptr.Pointer(), C.int(int32(idx)))
	}
}

func (ptr *QUndoStack) Push(cmd QUndoCommand_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack_Push(ptr.Pointer(), PointerFromQUndoCommand(cmd))
	}
}

//export callbackQUndoStack_Redo
func callbackQUndoStack_Redo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "redo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoStackFromPointer(ptr).RedoDefault()
	}
}

func (ptr *QUndoStack) ConnectRedo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "redo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectRedo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "redo")
	}
}

func (ptr *QUndoStack) Redo() {
	if ptr.Pointer() != nil {
		C.QUndoStack_Redo(ptr.Pointer())
	}
}

func (ptr *QUndoStack) RedoDefault() {
	if ptr.Pointer() != nil {
		C.QUndoStack_RedoDefault(ptr.Pointer())
	}
}

//export callbackQUndoStack_RedoTextChanged
func callbackQUndoStack_RedoTextChanged(ptr unsafe.Pointer, redoText C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "redoTextChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(redoText))
	}

}

func (ptr *QUndoStack) ConnectRedoTextChanged(f func(redoText string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "redoTextChanged") {
			C.QUndoStack_ConnectRedoTextChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "redoTextChanged"); signal != nil {
			f := func(redoText string) {
				(*(*func(string))(signal))(redoText)
				f(redoText)
			}
			qt.ConnectSignal(ptr.Pointer(), "redoTextChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "redoTextChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectRedoTextChanged() {
	if ptr.Pointer() != nil {
		C.QUndoStack_DisconnectRedoTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "redoTextChanged")
	}
}

func (ptr *QUndoStack) RedoTextChanged(redoText string) {
	if ptr.Pointer() != nil {
		var redoTextC *C.char
		if redoText != "" {
			redoTextC = C.CString(redoText)
			defer C.free(unsafe.Pointer(redoTextC))
		}
		C.QUndoStack_RedoTextChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: redoTextC, len: C.longlong(len(redoText))})
	}
}

//export callbackQUndoStack_ResetClean
func callbackQUndoStack_ResetClean(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resetClean"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoStackFromPointer(ptr).ResetCleanDefault()
	}
}

func (ptr *QUndoStack) ConnectResetClean(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resetClean"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "resetClean", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resetClean", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectResetClean() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resetClean")
	}
}

func (ptr *QUndoStack) ResetClean() {
	if ptr.Pointer() != nil {
		C.QUndoStack_ResetClean(ptr.Pointer())
	}
}

func (ptr *QUndoStack) ResetCleanDefault() {
	if ptr.Pointer() != nil {
		C.QUndoStack_ResetCleanDefault(ptr.Pointer())
	}
}

//export callbackQUndoStack_SetActive
func callbackQUndoStack_SetActive(ptr unsafe.Pointer, active C.char) {
	if signal := qt.GetSignal(ptr, "setActive"); signal != nil {
		(*(*func(bool))(signal))(int8(active) != 0)
	} else {
		NewQUndoStackFromPointer(ptr).SetActiveDefault(int8(active) != 0)
	}
}

func (ptr *QUndoStack) ConnectSetActive(f func(active bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setActive"); signal != nil {
			f := func(active bool) {
				(*(*func(bool))(signal))(active)
				f(active)
			}
			qt.ConnectSignal(ptr.Pointer(), "setActive", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setActive", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectSetActive() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setActive")
	}
}

func (ptr *QUndoStack) SetActive(active bool) {
	if ptr.Pointer() != nil {
		C.QUndoStack_SetActive(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(active))))
	}
}

func (ptr *QUndoStack) SetActiveDefault(active bool) {
	if ptr.Pointer() != nil {
		C.QUndoStack_SetActiveDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(active))))
	}
}

//export callbackQUndoStack_SetClean
func callbackQUndoStack_SetClean(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setClean"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoStackFromPointer(ptr).SetCleanDefault()
	}
}

func (ptr *QUndoStack) ConnectSetClean(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setClean"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "setClean", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setClean", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectSetClean() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setClean")
	}
}

func (ptr *QUndoStack) SetClean() {
	if ptr.Pointer() != nil {
		C.QUndoStack_SetClean(ptr.Pointer())
	}
}

func (ptr *QUndoStack) SetCleanDefault() {
	if ptr.Pointer() != nil {
		C.QUndoStack_SetCleanDefault(ptr.Pointer())
	}
}

//export callbackQUndoStack_SetIndex
func callbackQUndoStack_SetIndex(ptr unsafe.Pointer, idx C.int) {
	if signal := qt.GetSignal(ptr, "setIndex"); signal != nil {
		(*(*func(int))(signal))(int(int32(idx)))
	} else {
		NewQUndoStackFromPointer(ptr).SetIndexDefault(int(int32(idx)))
	}
}

func (ptr *QUndoStack) ConnectSetIndex(f func(idx int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setIndex"); signal != nil {
			f := func(idx int) {
				(*(*func(int))(signal))(idx)
				f(idx)
			}
			qt.ConnectSignal(ptr.Pointer(), "setIndex", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setIndex", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectSetIndex() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setIndex")
	}
}

func (ptr *QUndoStack) SetIndex(idx int) {
	if ptr.Pointer() != nil {
		C.QUndoStack_SetIndex(ptr.Pointer(), C.int(int32(idx)))
	}
}

func (ptr *QUndoStack) SetIndexDefault(idx int) {
	if ptr.Pointer() != nil {
		C.QUndoStack_SetIndexDefault(ptr.Pointer(), C.int(int32(idx)))
	}
}

func (ptr *QUndoStack) SetUndoLimit(limit int) {
	if ptr.Pointer() != nil {
		C.QUndoStack_SetUndoLimit(ptr.Pointer(), C.int(int32(limit)))
	}
}

//export callbackQUndoStack_Undo
func callbackQUndoStack_Undo(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "undo"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoStackFromPointer(ptr).UndoDefault()
	}
}

func (ptr *QUndoStack) ConnectUndo(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "undo"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undo", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectUndo() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "undo")
	}
}

func (ptr *QUndoStack) Undo() {
	if ptr.Pointer() != nil {
		C.QUndoStack_Undo(ptr.Pointer())
	}
}

func (ptr *QUndoStack) UndoDefault() {
	if ptr.Pointer() != nil {
		C.QUndoStack_UndoDefault(ptr.Pointer())
	}
}

//export callbackQUndoStack_UndoTextChanged
func callbackQUndoStack_UndoTextChanged(ptr unsafe.Pointer, undoText C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "undoTextChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(undoText))
	}

}

func (ptr *QUndoStack) ConnectUndoTextChanged(f func(undoText string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "undoTextChanged") {
			C.QUndoStack_ConnectUndoTextChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "undoTextChanged"); signal != nil {
			f := func(undoText string) {
				(*(*func(string))(signal))(undoText)
				f(undoText)
			}
			qt.ConnectSignal(ptr.Pointer(), "undoTextChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "undoTextChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectUndoTextChanged() {
	if ptr.Pointer() != nil {
		C.QUndoStack_DisconnectUndoTextChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "undoTextChanged")
	}
}

func (ptr *QUndoStack) UndoTextChanged(undoText string) {
	if ptr.Pointer() != nil {
		var undoTextC *C.char
		if undoText != "" {
			undoTextC = C.CString(undoText)
			defer C.free(unsafe.Pointer(undoTextC))
		}
		C.QUndoStack_UndoTextChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: undoTextC, len: C.longlong(len(undoText))})
	}
}

//export callbackQUndoStack_DestroyQUndoStack
func callbackQUndoStack_DestroyQUndoStack(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QUndoStack"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoStackFromPointer(ptr).DestroyQUndoStackDefault()
	}
}

func (ptr *QUndoStack) ConnectDestroyQUndoStack(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QUndoStack"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QUndoStack", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QUndoStack", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoStack) DisconnectDestroyQUndoStack() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QUndoStack")
	}
}

func (ptr *QUndoStack) DestroyQUndoStack() {
	if ptr.Pointer() != nil {
		C.QUndoStack_DestroyQUndoStack(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QUndoStack) DestroyQUndoStackDefault() {
	if ptr.Pointer() != nil {
		C.QUndoStack_DestroyQUndoStackDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QUndoStack) CreateRedoAction(parent core.QObject_ITF, prefix string) *QAction {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		tmpValue := NewQActionFromPointer(C.QUndoStack_CreateRedoAction(ptr.Pointer(), core.PointerFromQObject(parent), C.struct_QtWidgets_PackedString{data: prefixC, len: C.longlong(len(prefix))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoStack) CreateUndoAction(parent core.QObject_ITF, prefix string) *QAction {
	if ptr.Pointer() != nil {
		var prefixC *C.char
		if prefix != "" {
			prefixC = C.CString(prefix)
			defer C.free(unsafe.Pointer(prefixC))
		}
		tmpValue := NewQActionFromPointer(C.QUndoStack_CreateUndoAction(ptr.Pointer(), core.PointerFromQObject(parent), C.struct_QtWidgets_PackedString{data: prefixC, len: C.longlong(len(prefix))}))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoStack) RedoText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUndoStack_RedoText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUndoStack) Text(idx int) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUndoStack_Text(ptr.Pointer(), C.int(int32(idx))))
	}
	return ""
}

func (ptr *QUndoStack) UndoText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUndoStack_UndoText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUndoStack) CanRedo() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoStack_CanRedo(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUndoStack) CanUndo() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoStack_CanUndo(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUndoStack) IsActive() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoStack_IsActive(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QUndoStack) IsClean() bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoStack_IsClean(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQUndoStack_MetaObject
func callbackQUndoStack_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQUndoStackFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QUndoStack) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QUndoStack_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QUndoStack) Command(index int) *QUndoCommand {
	if ptr.Pointer() != nil {
		return NewQUndoCommandFromPointer(C.QUndoStack_Command(ptr.Pointer(), C.int(int32(index))))
	}
	return nil
}

func (ptr *QUndoStack) CleanIndex() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QUndoStack_CleanIndex(ptr.Pointer())))
	}
	return 0
}

func (ptr *QUndoStack) Count() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QUndoStack_Count(ptr.Pointer())))
	}
	return 0
}

func (ptr *QUndoStack) Index() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QUndoStack_Index(ptr.Pointer())))
	}
	return 0
}

func (ptr *QUndoStack) UndoLimit() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QUndoStack_UndoLimit(ptr.Pointer())))
	}
	return 0
}

func (ptr *QUndoStack) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QUndoStack___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QUndoStack) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QUndoStack) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QUndoStack___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QUndoStack) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QUndoStack___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoStack) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QUndoStack) __findChildren_newList2() unsafe.Pointer {
	return C.QUndoStack___findChildren_newList2(ptr.Pointer())
}

func (ptr *QUndoStack) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QUndoStack___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoStack) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QUndoStack) __findChildren_newList3() unsafe.Pointer {
	return C.QUndoStack___findChildren_newList3(ptr.Pointer())
}

func (ptr *QUndoStack) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QUndoStack___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoStack) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QUndoStack) __findChildren_newList() unsafe.Pointer {
	return C.QUndoStack___findChildren_newList(ptr.Pointer())
}

func (ptr *QUndoStack) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QUndoStack___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoStack) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QUndoStack) __children_newList() unsafe.Pointer {
	return C.QUndoStack___children_newList(ptr.Pointer())
}

//export callbackQUndoStack_Event
func callbackQUndoStack_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQUndoStackFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}

func (ptr *QUndoStack) EventDefault(e core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoStack_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackQUndoStack_EventFilter
func callbackQUndoStack_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQUndoStackFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QUndoStack) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QUndoStack_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQUndoStack_ChildEvent
func callbackQUndoStack_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQUndoStackFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QUndoStack) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQUndoStack_ConnectNotify
func callbackQUndoStack_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQUndoStackFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QUndoStack) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQUndoStack_CustomEvent
func callbackQUndoStack_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQUndoStackFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QUndoStack) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQUndoStack_DeleteLater
func callbackQUndoStack_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoStackFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QUndoStack) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QUndoStack_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQUndoStack_Destroyed
func callbackQUndoStack_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQUndoStack_DisconnectNotify
func callbackQUndoStack_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQUndoStackFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QUndoStack) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQUndoStack_ObjectNameChanged
func callbackQUndoStack_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQUndoStack_TimerEvent
func callbackQUndoStack_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQUndoStackFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QUndoStack) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoStack_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QUndoView struct {
	QListView
}

type QUndoView_ITF interface {
	QListView_ITF
	QUndoView_PTR() *QUndoView
}

func (ptr *QUndoView) QUndoView_PTR() *QUndoView {
	return ptr
}

func (ptr *QUndoView) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QListView_PTR().Pointer()
	}
	return nil
}

func (ptr *QUndoView) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QListView_PTR().SetPointer(p)
	}
}

func PointerFromQUndoView(ptr QUndoView_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QUndoView_PTR().Pointer()
	}
	return nil
}

func NewQUndoViewFromPointer(ptr unsafe.Pointer) (n *QUndoView) {
	n = new(QUndoView)
	n.SetPointer(ptr)
	return
}
func NewQUndoView3(group QUndoGroup_ITF, parent QWidget_ITF) *QUndoView {
	tmpValue := NewQUndoViewFromPointer(C.QUndoView_NewQUndoView3(PointerFromQUndoGroup(group), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQUndoView2(stack QUndoStack_ITF, parent QWidget_ITF) *QUndoView {
	tmpValue := NewQUndoViewFromPointer(C.QUndoView_NewQUndoView2(PointerFromQUndoStack(stack), PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQUndoView(parent QWidget_ITF) *QUndoView {
	tmpValue := NewQUndoViewFromPointer(C.QUndoView_NewQUndoView(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QUndoView) SetCleanIcon(icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoView_SetCleanIcon(ptr.Pointer(), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QUndoView) SetEmptyLabel(label string) {
	if ptr.Pointer() != nil {
		var labelC *C.char
		if label != "" {
			labelC = C.CString(label)
			defer C.free(unsafe.Pointer(labelC))
		}
		C.QUndoView_SetEmptyLabel(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: labelC, len: C.longlong(len(label))})
	}
}

//export callbackQUndoView_SetGroup
func callbackQUndoView_SetGroup(ptr unsafe.Pointer, group unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setGroup"); signal != nil {
		(*(*func(*QUndoGroup))(signal))(NewQUndoGroupFromPointer(group))
	} else {
		NewQUndoViewFromPointer(ptr).SetGroupDefault(NewQUndoGroupFromPointer(group))
	}
}

func (ptr *QUndoView) ConnectSetGroup(f func(group *QUndoGroup)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setGroup"); signal != nil {
			f := func(group *QUndoGroup) {
				(*(*func(*QUndoGroup))(signal))(group)
				f(group)
			}
			qt.ConnectSignal(ptr.Pointer(), "setGroup", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setGroup", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoView) DisconnectSetGroup() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setGroup")
	}
}

func (ptr *QUndoView) SetGroup(group QUndoGroup_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoView_SetGroup(ptr.Pointer(), PointerFromQUndoGroup(group))
	}
}

func (ptr *QUndoView) SetGroupDefault(group QUndoGroup_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoView_SetGroupDefault(ptr.Pointer(), PointerFromQUndoGroup(group))
	}
}

//export callbackQUndoView_SetStack
func callbackQUndoView_SetStack(ptr unsafe.Pointer, stack unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setStack"); signal != nil {
		(*(*func(*QUndoStack))(signal))(NewQUndoStackFromPointer(stack))
	} else {
		NewQUndoViewFromPointer(ptr).SetStackDefault(NewQUndoStackFromPointer(stack))
	}
}

func (ptr *QUndoView) ConnectSetStack(f func(stack *QUndoStack)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setStack"); signal != nil {
			f := func(stack *QUndoStack) {
				(*(*func(*QUndoStack))(signal))(stack)
				f(stack)
			}
			qt.ConnectSignal(ptr.Pointer(), "setStack", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setStack", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoView) DisconnectSetStack() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setStack")
	}
}

func (ptr *QUndoView) SetStack(stack QUndoStack_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoView_SetStack(ptr.Pointer(), PointerFromQUndoStack(stack))
	}
}

func (ptr *QUndoView) SetStackDefault(stack QUndoStack_ITF) {
	if ptr.Pointer() != nil {
		C.QUndoView_SetStackDefault(ptr.Pointer(), PointerFromQUndoStack(stack))
	}
}

//export callbackQUndoView_DestroyQUndoView
func callbackQUndoView_DestroyQUndoView(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QUndoView"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQUndoViewFromPointer(ptr).DestroyQUndoViewDefault()
	}
}

func (ptr *QUndoView) ConnectDestroyQUndoView(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QUndoView"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QUndoView", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QUndoView", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QUndoView) DisconnectDestroyQUndoView() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QUndoView")
	}
}

func (ptr *QUndoView) DestroyQUndoView() {
	if ptr.Pointer() != nil {
		C.QUndoView_DestroyQUndoView(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QUndoView) DestroyQUndoViewDefault() {
	if ptr.Pointer() != nil {
		C.QUndoView_DestroyQUndoViewDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QUndoView) CleanIcon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QUndoView_CleanIcon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QUndoView) EmptyLabel() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QUndoView_EmptyLabel(ptr.Pointer()))
	}
	return ""
}

func (ptr *QUndoView) Group() *QUndoGroup {
	if ptr.Pointer() != nil {
		tmpValue := NewQUndoGroupFromPointer(C.QUndoView_Group(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QUndoView) Stack() *QUndoStack {
	if ptr.Pointer() != nil {
		tmpValue := NewQUndoStackFromPointer(C.QUndoView_Stack(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

type QVBoxLayout struct {
	QBoxLayout
}

type QVBoxLayout_ITF interface {
	QBoxLayout_ITF
	QVBoxLayout_PTR() *QVBoxLayout
}

func (ptr *QVBoxLayout) QVBoxLayout_PTR() *QVBoxLayout {
	return ptr
}

func (ptr *QVBoxLayout) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QBoxLayout_PTR().Pointer()
	}
	return nil
}

func (ptr *QVBoxLayout) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QBoxLayout_PTR().SetPointer(p)
	}
}

func PointerFromQVBoxLayout(ptr QVBoxLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVBoxLayout_PTR().Pointer()
	}
	return nil
}

func NewQVBoxLayoutFromPointer(ptr unsafe.Pointer) (n *QVBoxLayout) {
	n = new(QVBoxLayout)
	n.SetPointer(ptr)
	return
}
func NewQVBoxLayout() *QVBoxLayout {
	tmpValue := NewQVBoxLayoutFromPointer(C.QVBoxLayout_NewQVBoxLayout())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQVBoxLayout2(parent QWidget_ITF) *QVBoxLayout {
	tmpValue := NewQVBoxLayoutFromPointer(C.QVBoxLayout_NewQVBoxLayout2(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQVBoxLayout_DestroyQVBoxLayout
func callbackQVBoxLayout_DestroyQVBoxLayout(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QVBoxLayout"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQVBoxLayoutFromPointer(ptr).DestroyQVBoxLayoutDefault()
	}
}

func (ptr *QVBoxLayout) ConnectDestroyQVBoxLayout(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QVBoxLayout"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QVBoxLayout", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QVBoxLayout", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QVBoxLayout) DisconnectDestroyQVBoxLayout() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QVBoxLayout")
	}
}

func (ptr *QVBoxLayout) DestroyQVBoxLayout() {
	if ptr.Pointer() != nil {
		C.QVBoxLayout_DestroyQVBoxLayout(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QVBoxLayout) DestroyQVBoxLayoutDefault() {
	if ptr.Pointer() != nil {
		C.QVBoxLayout_DestroyQVBoxLayoutDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

type QWhatsThis struct {
	ptr unsafe.Pointer
}

type QWhatsThis_ITF interface {
	QWhatsThis_PTR() *QWhatsThis
}

func (ptr *QWhatsThis) QWhatsThis_PTR() *QWhatsThis {
	return ptr
}

func (ptr *QWhatsThis) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.ptr
	}
	return nil
}

func (ptr *QWhatsThis) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.ptr = p
	}
}

func PointerFromQWhatsThis(ptr QWhatsThis_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWhatsThis_PTR().Pointer()
	}
	return nil
}

func NewQWhatsThisFromPointer(ptr unsafe.Pointer) (n *QWhatsThis) {
	n = new(QWhatsThis)
	n.SetPointer(ptr)
	return
}

func (ptr *QWhatsThis) DestroyQWhatsThis() {
	if ptr != nil {
		C.free(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func QWhatsThis_CreateAction(parent core.QObject_ITF) *QAction {
	tmpValue := NewQActionFromPointer(C.QWhatsThis_QWhatsThis_CreateAction(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QWhatsThis) CreateAction(parent core.QObject_ITF) *QAction {
	tmpValue := NewQActionFromPointer(C.QWhatsThis_QWhatsThis_CreateAction(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QWhatsThis_InWhatsThisMode() bool {
	return int8(C.QWhatsThis_QWhatsThis_InWhatsThisMode()) != 0
}

func (ptr *QWhatsThis) InWhatsThisMode() bool {
	return int8(C.QWhatsThis_QWhatsThis_InWhatsThisMode()) != 0
}

func QWhatsThis_EnterWhatsThisMode() {
	C.QWhatsThis_QWhatsThis_EnterWhatsThisMode()
}

func (ptr *QWhatsThis) EnterWhatsThisMode() {
	C.QWhatsThis_QWhatsThis_EnterWhatsThisMode()
}

func QWhatsThis_HideText() {
	C.QWhatsThis_QWhatsThis_HideText()
}

func (ptr *QWhatsThis) HideText() {
	C.QWhatsThis_QWhatsThis_HideText()
}

func QWhatsThis_LeaveWhatsThisMode() {
	C.QWhatsThis_QWhatsThis_LeaveWhatsThisMode()
}

func (ptr *QWhatsThis) LeaveWhatsThisMode() {
	C.QWhatsThis_QWhatsThis_LeaveWhatsThisMode()
}

func QWhatsThis_ShowText(pos core.QPoint_ITF, text string, w QWidget_ITF) {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QWhatsThis_QWhatsThis_ShowText(core.PointerFromQPoint(pos), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(w))
}

func (ptr *QWhatsThis) ShowText(pos core.QPoint_ITF, text string, w QWidget_ITF) {
	var textC *C.char
	if text != "" {
		textC = C.CString(text)
		defer C.free(unsafe.Pointer(textC))
	}
	C.QWhatsThis_QWhatsThis_ShowText(core.PointerFromQPoint(pos), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))}, PointerFromQWidget(w))
}

type QWidget struct {
	core.QObject
	gui.QPaintDevice
}

type QWidget_ITF interface {
	core.QObject_ITF
	gui.QPaintDevice_ITF
	QWidget_PTR() *QWidget
}

func (ptr *QWidget) QWidget_PTR() *QWidget {
	return ptr
}

func (ptr *QWidget) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *QWidget) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
		ptr.QPaintDevice_PTR().SetPointer(p)
	}
}

func PointerFromQWidget(ptr QWidget_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func NewQWidgetFromPointer(ptr unsafe.Pointer) (n *QWidget) {
	n = new(QWidget)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QWidget__RenderFlag
//QWidget::RenderFlag
type QWidget__RenderFlag int64

const (
	QWidget__DrawWindowBackground QWidget__RenderFlag = QWidget__RenderFlag(0x1)
	QWidget__DrawChildren         QWidget__RenderFlag = QWidget__RenderFlag(0x2)
	QWidget__IgnoreMask           QWidget__RenderFlag = QWidget__RenderFlag(0x4)
)

func (ptr *QWidget) Grab(rectangle core.QRect_ITF) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QWidget_Grab(ptr.Pointer(), core.PointerFromQRect(rectangle)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func QWidget_Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QWidget_QWidget_Tr(sC, cC, C.int(int32(n))))
}

func (ptr *QWidget) Tr(s string, c string, n int) string {
	var sC *C.char
	if s != "" {
		sC = C.CString(s)
		defer C.free(unsafe.Pointer(sC))
	}
	var cC *C.char
	if c != "" {
		cC = C.CString(c)
		defer C.free(unsafe.Pointer(cC))
	}
	return cGoUnpackString(C.QWidget_QWidget_Tr(sC, cC, C.int(int32(n))))
}

func QWidget_CreateWindowContainer(window gui.QWindow_ITF, parent QWidget_ITF, flags core.Qt__WindowType) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QWidget_QWidget_CreateWindowContainer(gui.PointerFromQWindow(window), PointerFromQWidget(parent), C.longlong(flags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QWidget) CreateWindowContainer(window gui.QWindow_ITF, parent QWidget_ITF, flags core.Qt__WindowType) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QWidget_QWidget_CreateWindowContainer(gui.PointerFromQWindow(window), PointerFromQWidget(parent), C.longlong(flags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QWidget_Find(id uintptr) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QWidget_QWidget_Find(C.uintptr_t(id)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QWidget) Find(id uintptr) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QWidget_QWidget_Find(C.uintptr_t(id)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QWidget_KeyboardGrabber() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QWidget_QWidget_KeyboardGrabber())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QWidget) KeyboardGrabber() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QWidget_QWidget_KeyboardGrabber())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func QWidget_MouseGrabber() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QWidget_QWidget_MouseGrabber())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func (ptr *QWidget) MouseGrabber() *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QWidget_QWidget_MouseGrabber())
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

func NewQWidget(parent QWidget_ITF, ff core.Qt__WindowType) *QWidget {
	tmpValue := NewQWidgetFromPointer(C.QWidget_NewQWidget(PointerFromQWidget(parent), C.longlong(ff)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQWidget_Close
func callbackQWidget_Close(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "close"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWidgetFromPointer(ptr).CloseDefault())))
}

func (ptr *QWidget) ConnectClose(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "close"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "close", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "close", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectClose() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "close")
	}
}

func (ptr *QWidget) Close() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_Close(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) CloseDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_CloseDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQWidget_Event
func callbackQWidget_Event(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWidgetFromPointer(ptr).EventDefault(core.NewQEventFromPointer(event)))))
}

func (ptr *QWidget) ConnectEvent(f func(event *core.QEvent) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "event"); signal != nil {
			f := func(event *core.QEvent) bool {
				(*(*func(*core.QEvent) bool)(signal))(event)
				return f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "event", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "event", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "event")
	}
}

func (ptr *QWidget) Event(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_Event(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QWidget) EventDefault(event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QWidget) FocusNextChild() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_FocusNextChild(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQWidget_FocusNextPrevChild
func callbackQWidget_FocusNextPrevChild(ptr unsafe.Pointer, next C.char) C.char {
	if signal := qt.GetSignal(ptr, "focusNextPrevChild"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(bool) bool)(signal))(int8(next) != 0))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWidgetFromPointer(ptr).FocusNextPrevChildDefault(int8(next) != 0))))
}

func (ptr *QWidget) ConnectFocusNextPrevChild(f func(next bool) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "focusNextPrevChild"); signal != nil {
			f := func(next bool) bool {
				(*(*func(bool) bool)(signal))(next)
				return f(next)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusNextPrevChild", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusNextPrevChild", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectFocusNextPrevChild() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "focusNextPrevChild")
	}
}

func (ptr *QWidget) FocusNextPrevChild(next bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_FocusNextPrevChild(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next))))) != 0
	}
	return false
}

func (ptr *QWidget) FocusNextPrevChildDefault(next bool) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_FocusNextPrevChildDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next))))) != 0
	}
	return false
}

func (ptr *QWidget) FocusPreviousChild() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_FocusPreviousChild(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQWidget_NativeEvent
func callbackQWidget_NativeEvent(ptr unsafe.Pointer, eventType unsafe.Pointer, message unsafe.Pointer, result *C.long) C.char {
	var resultR int
	if result != nil {
		resultR = int(int32(*result))
		defer func() { *result = C.long(int32(resultR)) }()
	}
	if signal := qt.GetSignal(ptr, "nativeEvent"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QByteArray, unsafe.Pointer, *int) bool)(signal))(core.NewQByteArrayFromPointer(eventType), message, &resultR))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWidgetFromPointer(ptr).NativeEventDefault(core.NewQByteArrayFromPointer(eventType), message, &resultR))))
}

func (ptr *QWidget) ConnectNativeEvent(f func(eventType *core.QByteArray, message unsafe.Pointer, result *int) bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "nativeEvent"); signal != nil {
			f := func(eventType *core.QByteArray, message unsafe.Pointer, result *int) bool {
				(*(*func(*core.QByteArray, unsafe.Pointer, *int) bool)(signal))(eventType, message, result)
				return f(eventType, message, result)
			}
			qt.ConnectSignal(ptr.Pointer(), "nativeEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "nativeEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectNativeEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "nativeEvent")
	}
}

func (ptr *QWidget) NativeEvent(eventType core.QByteArray_ITF, message unsafe.Pointer, result *int) bool {
	if ptr.Pointer() != nil {
		var resultC C.long
		if result != nil {
			resultC = C.long(int32(*result))
			defer func() { *result = int(int32(resultC)) }()
		}
		return int8(C.QWidget_NativeEvent(ptr.Pointer(), core.PointerFromQByteArray(eventType), message, &resultC)) != 0
	}
	return false
}

func (ptr *QWidget) NativeEventDefault(eventType core.QByteArray_ITF, message unsafe.Pointer, result *int) bool {
	if ptr.Pointer() != nil {
		var resultC C.long
		if result != nil {
			resultC = C.long(int32(*result))
			defer func() { *result = int(int32(resultC)) }()
		}
		return int8(C.QWidget_NativeEventDefault(ptr.Pointer(), core.PointerFromQByteArray(eventType), message, &resultC)) != 0
	}
	return false
}

func (ptr *QWidget) RestoreGeometry(geometry core.QByteArray_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_RestoreGeometry(ptr.Pointer(), core.PointerFromQByteArray(geometry))) != 0
	}
	return false
}

func (ptr *QWidget) GrabShortcut(key gui.QKeySequence_ITF, context core.Qt__ShortcutContext) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_GrabShortcut(ptr.Pointer(), gui.PointerFromQKeySequence(key), C.longlong(context))))
	}
	return 0
}

//export callbackQWidget_ActionEvent
func callbackQWidget_ActionEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "actionEvent"); signal != nil {
		(*(*func(*gui.QActionEvent))(signal))(gui.NewQActionEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).ActionEventDefault(gui.NewQActionEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectActionEvent(f func(event *gui.QActionEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "actionEvent"); signal != nil {
			f := func(event *gui.QActionEvent) {
				(*(*func(*gui.QActionEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "actionEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "actionEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectActionEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "actionEvent")
	}
}

func (ptr *QWidget) ActionEvent(event gui.QActionEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ActionEvent(ptr.Pointer(), gui.PointerFromQActionEvent(event))
	}
}

func (ptr *QWidget) ActionEventDefault(event gui.QActionEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ActionEventDefault(ptr.Pointer(), gui.PointerFromQActionEvent(event))
	}
}

func (ptr *QWidget) ActivateWindow() {
	if ptr.Pointer() != nil {
		C.QWidget_ActivateWindow(ptr.Pointer())
	}
}

func (ptr *QWidget) AddAction(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_AddAction(ptr.Pointer(), PointerFromQAction(action))
	}
}

func (ptr *QWidget) AddActions(actions []*QAction) {
	if ptr.Pointer() != nil {
		C.QWidget_AddActions(ptr.Pointer(), func() unsafe.Pointer {
			tmpList := NewQWidgetFromPointer(NewQWidgetFromPointer(nil).__addActions_actions_newList())
			for _, v := range actions {
				tmpList.__addActions_actions_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

func (ptr *QWidget) AdjustSize() {
	if ptr.Pointer() != nil {
		C.QWidget_AdjustSize(ptr.Pointer())
	}
}

//export callbackQWidget_ChangeEvent
func callbackQWidget_ChangeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "changeEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).ChangeEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectChangeEvent(f func(event *core.QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "changeEvent"); signal != nil {
			f := func(event *core.QEvent) {
				(*(*func(*core.QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "changeEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "changeEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectChangeEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "changeEvent")
	}
}

func (ptr *QWidget) ChangeEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ChangeEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QWidget) ChangeEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ChangeEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QWidget) ClearFocus() {
	if ptr.Pointer() != nil {
		C.QWidget_ClearFocus(ptr.Pointer())
	}
}

func (ptr *QWidget) ClearMask() {
	if ptr.Pointer() != nil {
		C.QWidget_ClearMask(ptr.Pointer())
	}
}

//export callbackQWidget_CloseEvent
func callbackQWidget_CloseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "closeEvent"); signal != nil {
		(*(*func(*gui.QCloseEvent))(signal))(gui.NewQCloseEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).CloseEventDefault(gui.NewQCloseEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectCloseEvent(f func(event *gui.QCloseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "closeEvent"); signal != nil {
			f := func(event *gui.QCloseEvent) {
				(*(*func(*gui.QCloseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "closeEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "closeEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectCloseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "closeEvent")
	}
}

func (ptr *QWidget) CloseEvent(event gui.QCloseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_CloseEvent(ptr.Pointer(), gui.PointerFromQCloseEvent(event))
	}
}

func (ptr *QWidget) CloseEventDefault(event gui.QCloseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_CloseEventDefault(ptr.Pointer(), gui.PointerFromQCloseEvent(event))
	}
}

//export callbackQWidget_ContextMenuEvent
func callbackQWidget_ContextMenuEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "contextMenuEvent"); signal != nil {
		(*(*func(*gui.QContextMenuEvent))(signal))(gui.NewQContextMenuEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).ContextMenuEventDefault(gui.NewQContextMenuEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectContextMenuEvent(f func(event *gui.QContextMenuEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "contextMenuEvent"); signal != nil {
			f := func(event *gui.QContextMenuEvent) {
				(*(*func(*gui.QContextMenuEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "contextMenuEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "contextMenuEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectContextMenuEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "contextMenuEvent")
	}
}

func (ptr *QWidget) ContextMenuEvent(event gui.QContextMenuEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ContextMenuEvent(ptr.Pointer(), gui.PointerFromQContextMenuEvent(event))
	}
}

func (ptr *QWidget) ContextMenuEventDefault(event gui.QContextMenuEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ContextMenuEventDefault(ptr.Pointer(), gui.PointerFromQContextMenuEvent(event))
	}
}

func (ptr *QWidget) Create(window uintptr, initializeWindow bool, destroyOldWindow bool) {
	if ptr.Pointer() != nil {
		C.QWidget_Create(ptr.Pointer(), C.uintptr_t(window), C.char(int8(qt.GoBoolToInt(initializeWindow))), C.char(int8(qt.GoBoolToInt(destroyOldWindow))))
	}
}

//export callbackQWidget_CustomContextMenuRequested
func callbackQWidget_CustomContextMenuRequested(ptr unsafe.Pointer, pos unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customContextMenuRequested"); signal != nil {
		(*(*func(*core.QPoint))(signal))(core.NewQPointFromPointer(pos))
	}

}

func (ptr *QWidget) ConnectCustomContextMenuRequested(f func(pos *core.QPoint)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "customContextMenuRequested") {
			C.QWidget_ConnectCustomContextMenuRequested(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "customContextMenuRequested"); signal != nil {
			f := func(pos *core.QPoint) {
				(*(*func(*core.QPoint))(signal))(pos)
				f(pos)
			}
			qt.ConnectSignal(ptr.Pointer(), "customContextMenuRequested", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "customContextMenuRequested", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectCustomContextMenuRequested() {
	if ptr.Pointer() != nil {
		C.QWidget_DisconnectCustomContextMenuRequested(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "customContextMenuRequested")
	}
}

func (ptr *QWidget) CustomContextMenuRequested(pos core.QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_CustomContextMenuRequested(ptr.Pointer(), core.PointerFromQPoint(pos))
	}
}

func (ptr *QWidget) Destroy(destroyWindow bool, destroySubWindows bool) {
	if ptr.Pointer() != nil {
		C.QWidget_Destroy(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(destroyWindow))), C.char(int8(qt.GoBoolToInt(destroySubWindows))))
	}
}

//export callbackQWidget_DragEnterEvent
func callbackQWidget_DragEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dragEnterEvent"); signal != nil {
		(*(*func(*gui.QDragEnterEvent))(signal))(gui.NewQDragEnterEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).DragEnterEventDefault(gui.NewQDragEnterEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectDragEnterEvent(f func(event *gui.QDragEnterEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dragEnterEvent"); signal != nil {
			f := func(event *gui.QDragEnterEvent) {
				(*(*func(*gui.QDragEnterEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dragEnterEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dragEnterEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectDragEnterEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dragEnterEvent")
	}
}

func (ptr *QWidget) DragEnterEvent(event gui.QDragEnterEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DragEnterEvent(ptr.Pointer(), gui.PointerFromQDragEnterEvent(event))
	}
}

func (ptr *QWidget) DragEnterEventDefault(event gui.QDragEnterEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DragEnterEventDefault(ptr.Pointer(), gui.PointerFromQDragEnterEvent(event))
	}
}

//export callbackQWidget_DragLeaveEvent
func callbackQWidget_DragLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dragLeaveEvent"); signal != nil {
		(*(*func(*gui.QDragLeaveEvent))(signal))(gui.NewQDragLeaveEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).DragLeaveEventDefault(gui.NewQDragLeaveEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectDragLeaveEvent(f func(event *gui.QDragLeaveEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dragLeaveEvent"); signal != nil {
			f := func(event *gui.QDragLeaveEvent) {
				(*(*func(*gui.QDragLeaveEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dragLeaveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dragLeaveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectDragLeaveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dragLeaveEvent")
	}
}

func (ptr *QWidget) DragLeaveEvent(event gui.QDragLeaveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DragLeaveEvent(ptr.Pointer(), gui.PointerFromQDragLeaveEvent(event))
	}
}

func (ptr *QWidget) DragLeaveEventDefault(event gui.QDragLeaveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DragLeaveEventDefault(ptr.Pointer(), gui.PointerFromQDragLeaveEvent(event))
	}
}

//export callbackQWidget_DragMoveEvent
func callbackQWidget_DragMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dragMoveEvent"); signal != nil {
		(*(*func(*gui.QDragMoveEvent))(signal))(gui.NewQDragMoveEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).DragMoveEventDefault(gui.NewQDragMoveEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectDragMoveEvent(f func(event *gui.QDragMoveEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dragMoveEvent"); signal != nil {
			f := func(event *gui.QDragMoveEvent) {
				(*(*func(*gui.QDragMoveEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dragMoveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dragMoveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectDragMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dragMoveEvent")
	}
}

func (ptr *QWidget) DragMoveEvent(event gui.QDragMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DragMoveEvent(ptr.Pointer(), gui.PointerFromQDragMoveEvent(event))
	}
}

func (ptr *QWidget) DragMoveEventDefault(event gui.QDragMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DragMoveEventDefault(ptr.Pointer(), gui.PointerFromQDragMoveEvent(event))
	}
}

//export callbackQWidget_DropEvent
func callbackQWidget_DropEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "dropEvent"); signal != nil {
		(*(*func(*gui.QDropEvent))(signal))(gui.NewQDropEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).DropEventDefault(gui.NewQDropEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectDropEvent(f func(event *gui.QDropEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "dropEvent"); signal != nil {
			f := func(event *gui.QDropEvent) {
				(*(*func(*gui.QDropEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "dropEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "dropEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectDropEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "dropEvent")
	}
}

func (ptr *QWidget) DropEvent(event gui.QDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DropEvent(ptr.Pointer(), gui.PointerFromQDropEvent(event))
	}
}

func (ptr *QWidget) DropEventDefault(event gui.QDropEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DropEventDefault(ptr.Pointer(), gui.PointerFromQDropEvent(event))
	}
}

//export callbackQWidget_EnterEvent
func callbackQWidget_EnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "enterEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).EnterEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectEnterEvent(f func(event *core.QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "enterEvent"); signal != nil {
			f := func(event *core.QEvent) {
				(*(*func(*core.QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "enterEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "enterEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectEnterEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "enterEvent")
	}
}

func (ptr *QWidget) EnterEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_EnterEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QWidget) EnterEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_EnterEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQWidget_FocusInEvent
func callbackQWidget_FocusInEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "focusInEvent"); signal != nil {
		(*(*func(*gui.QFocusEvent))(signal))(gui.NewQFocusEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).FocusInEventDefault(gui.NewQFocusEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectFocusInEvent(f func(event *gui.QFocusEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "focusInEvent"); signal != nil {
			f := func(event *gui.QFocusEvent) {
				(*(*func(*gui.QFocusEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusInEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusInEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectFocusInEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "focusInEvent")
	}
}

func (ptr *QWidget) FocusInEvent(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_FocusInEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

func (ptr *QWidget) FocusInEventDefault(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_FocusInEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

//export callbackQWidget_FocusOutEvent
func callbackQWidget_FocusOutEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "focusOutEvent"); signal != nil {
		(*(*func(*gui.QFocusEvent))(signal))(gui.NewQFocusEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).FocusOutEventDefault(gui.NewQFocusEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectFocusOutEvent(f func(event *gui.QFocusEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "focusOutEvent"); signal != nil {
			f := func(event *gui.QFocusEvent) {
				(*(*func(*gui.QFocusEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "focusOutEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "focusOutEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectFocusOutEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "focusOutEvent")
	}
}

func (ptr *QWidget) FocusOutEvent(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_FocusOutEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

func (ptr *QWidget) FocusOutEventDefault(event gui.QFocusEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_FocusOutEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
	}
}

func (ptr *QWidget) GrabGesture(gesture core.Qt__GestureType, flags core.Qt__GestureFlag) {
	if ptr.Pointer() != nil {
		C.QWidget_GrabGesture(ptr.Pointer(), C.longlong(gesture), C.longlong(flags))
	}
}

func (ptr *QWidget) GrabKeyboard() {
	if ptr.Pointer() != nil {
		C.QWidget_GrabKeyboard(ptr.Pointer())
	}
}

func (ptr *QWidget) GrabMouse() {
	if ptr.Pointer() != nil {
		C.QWidget_GrabMouse(ptr.Pointer())
	}
}

func (ptr *QWidget) GrabMouse2(cursor gui.QCursor_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_GrabMouse2(ptr.Pointer(), gui.PointerFromQCursor(cursor))
	}
}

//export callbackQWidget_Hide
func callbackQWidget_Hide(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hide"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).HideDefault()
	}
}

func (ptr *QWidget) ConnectHide(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hide"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "hide", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hide", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectHide() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hide")
	}
}

func (ptr *QWidget) Hide() {
	if ptr.Pointer() != nil {
		C.QWidget_Hide(ptr.Pointer())
	}
}

func (ptr *QWidget) HideDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_HideDefault(ptr.Pointer())
	}
}

//export callbackQWidget_HideEvent
func callbackQWidget_HideEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "hideEvent"); signal != nil {
		(*(*func(*gui.QHideEvent))(signal))(gui.NewQHideEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).HideEventDefault(gui.NewQHideEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectHideEvent(f func(event *gui.QHideEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hideEvent"); signal != nil {
			f := func(event *gui.QHideEvent) {
				(*(*func(*gui.QHideEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "hideEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hideEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectHideEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hideEvent")
	}
}

func (ptr *QWidget) HideEvent(event gui.QHideEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_HideEvent(ptr.Pointer(), gui.PointerFromQHideEvent(event))
	}
}

func (ptr *QWidget) HideEventDefault(event gui.QHideEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_HideEventDefault(ptr.Pointer(), gui.PointerFromQHideEvent(event))
	}
}

//export callbackQWidget_InputMethodEvent
func callbackQWidget_InputMethodEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "inputMethodEvent"); signal != nil {
		(*(*func(*gui.QInputMethodEvent))(signal))(gui.NewQInputMethodEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).InputMethodEventDefault(gui.NewQInputMethodEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectInputMethodEvent(f func(event *gui.QInputMethodEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "inputMethodEvent"); signal != nil {
			f := func(event *gui.QInputMethodEvent) {
				(*(*func(*gui.QInputMethodEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "inputMethodEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "inputMethodEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectInputMethodEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "inputMethodEvent")
	}
}

func (ptr *QWidget) InputMethodEvent(event gui.QInputMethodEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_InputMethodEvent(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
	}
}

func (ptr *QWidget) InputMethodEventDefault(event gui.QInputMethodEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_InputMethodEventDefault(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
	}
}

func (ptr *QWidget) InsertAction(before QAction_ITF, action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_InsertAction(ptr.Pointer(), PointerFromQAction(before), PointerFromQAction(action))
	}
}

func (ptr *QWidget) InsertActions(before QAction_ITF, actions []*QAction) {
	if ptr.Pointer() != nil {
		C.QWidget_InsertActions(ptr.Pointer(), PointerFromQAction(before), func() unsafe.Pointer {
			tmpList := NewQWidgetFromPointer(NewQWidgetFromPointer(nil).__insertActions_actions_newList())
			for _, v := range actions {
				tmpList.__insertActions_actions_setList(v)
			}
			return tmpList.Pointer()
		}())
	}
}

//export callbackQWidget_KeyPressEvent
func callbackQWidget_KeyPressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "keyPressEvent"); signal != nil {
		(*(*func(*gui.QKeyEvent))(signal))(gui.NewQKeyEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).KeyPressEventDefault(gui.NewQKeyEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectKeyPressEvent(f func(event *gui.QKeyEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "keyPressEvent"); signal != nil {
			f := func(event *gui.QKeyEvent) {
				(*(*func(*gui.QKeyEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "keyPressEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "keyPressEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectKeyPressEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "keyPressEvent")
	}
}

func (ptr *QWidget) KeyPressEvent(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_KeyPressEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

func (ptr *QWidget) KeyPressEventDefault(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_KeyPressEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

//export callbackQWidget_KeyReleaseEvent
func callbackQWidget_KeyReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "keyReleaseEvent"); signal != nil {
		(*(*func(*gui.QKeyEvent))(signal))(gui.NewQKeyEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).KeyReleaseEventDefault(gui.NewQKeyEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectKeyReleaseEvent(f func(event *gui.QKeyEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "keyReleaseEvent"); signal != nil {
			f := func(event *gui.QKeyEvent) {
				(*(*func(*gui.QKeyEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "keyReleaseEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "keyReleaseEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectKeyReleaseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "keyReleaseEvent")
	}
}

func (ptr *QWidget) KeyReleaseEvent(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_KeyReleaseEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

func (ptr *QWidget) KeyReleaseEventDefault(event gui.QKeyEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_KeyReleaseEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
	}
}

//export callbackQWidget_LeaveEvent
func callbackQWidget_LeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "leaveEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).LeaveEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectLeaveEvent(f func(event *core.QEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "leaveEvent"); signal != nil {
			f := func(event *core.QEvent) {
				(*(*func(*core.QEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "leaveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "leaveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectLeaveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "leaveEvent")
	}
}

func (ptr *QWidget) LeaveEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_LeaveEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QWidget) LeaveEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_LeaveEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQWidget_Lower
func callbackQWidget_Lower(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "lower"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).LowerDefault()
	}
}

func (ptr *QWidget) ConnectLower(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "lower"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "lower", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "lower", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectLower() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "lower")
	}
}

func (ptr *QWidget) Lower() {
	if ptr.Pointer() != nil {
		C.QWidget_Lower(ptr.Pointer())
	}
}

func (ptr *QWidget) LowerDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_LowerDefault(ptr.Pointer())
	}
}

//export callbackQWidget_MouseDoubleClickEvent
func callbackQWidget_MouseDoubleClickEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mouseDoubleClickEvent"); signal != nil {
		(*(*func(*gui.QMouseEvent))(signal))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).MouseDoubleClickEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectMouseDoubleClickEvent(f func(event *gui.QMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mouseDoubleClickEvent"); signal != nil {
			f := func(event *gui.QMouseEvent) {
				(*(*func(*gui.QMouseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "mouseDoubleClickEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mouseDoubleClickEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectMouseDoubleClickEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mouseDoubleClickEvent")
	}
}

func (ptr *QWidget) MouseDoubleClickEvent(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MouseDoubleClickEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

func (ptr *QWidget) MouseDoubleClickEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MouseDoubleClickEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQWidget_MouseMoveEvent
func callbackQWidget_MouseMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mouseMoveEvent"); signal != nil {
		(*(*func(*gui.QMouseEvent))(signal))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).MouseMoveEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectMouseMoveEvent(f func(event *gui.QMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mouseMoveEvent"); signal != nil {
			f := func(event *gui.QMouseEvent) {
				(*(*func(*gui.QMouseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "mouseMoveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mouseMoveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectMouseMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mouseMoveEvent")
	}
}

func (ptr *QWidget) MouseMoveEvent(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MouseMoveEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

func (ptr *QWidget) MouseMoveEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MouseMoveEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQWidget_MousePressEvent
func callbackQWidget_MousePressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mousePressEvent"); signal != nil {
		(*(*func(*gui.QMouseEvent))(signal))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).MousePressEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectMousePressEvent(f func(event *gui.QMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mousePressEvent"); signal != nil {
			f := func(event *gui.QMouseEvent) {
				(*(*func(*gui.QMouseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "mousePressEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mousePressEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectMousePressEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mousePressEvent")
	}
}

func (ptr *QWidget) MousePressEvent(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MousePressEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

func (ptr *QWidget) MousePressEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MousePressEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

//export callbackQWidget_MouseReleaseEvent
func callbackQWidget_MouseReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "mouseReleaseEvent"); signal != nil {
		(*(*func(*gui.QMouseEvent))(signal))(gui.NewQMouseEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).MouseReleaseEventDefault(gui.NewQMouseEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectMouseReleaseEvent(f func(event *gui.QMouseEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "mouseReleaseEvent"); signal != nil {
			f := func(event *gui.QMouseEvent) {
				(*(*func(*gui.QMouseEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "mouseReleaseEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "mouseReleaseEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectMouseReleaseEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "mouseReleaseEvent")
	}
}

func (ptr *QWidget) MouseReleaseEvent(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MouseReleaseEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

func (ptr *QWidget) MouseReleaseEventDefault(event gui.QMouseEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MouseReleaseEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
	}
}

func (ptr *QWidget) Move(vqp core.QPoint_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_Move(ptr.Pointer(), core.PointerFromQPoint(vqp))
	}
}

func (ptr *QWidget) Move2(x int, y int) {
	if ptr.Pointer() != nil {
		C.QWidget_Move2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)))
	}
}

//export callbackQWidget_MoveEvent
func callbackQWidget_MoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "moveEvent"); signal != nil {
		(*(*func(*gui.QMoveEvent))(signal))(gui.NewQMoveEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).MoveEventDefault(gui.NewQMoveEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectMoveEvent(f func(event *gui.QMoveEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "moveEvent"); signal != nil {
			f := func(event *gui.QMoveEvent) {
				(*(*func(*gui.QMoveEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "moveEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "moveEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectMoveEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "moveEvent")
	}
}

func (ptr *QWidget) MoveEvent(event gui.QMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MoveEvent(ptr.Pointer(), gui.PointerFromQMoveEvent(event))
	}
}

func (ptr *QWidget) MoveEventDefault(event gui.QMoveEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_MoveEventDefault(ptr.Pointer(), gui.PointerFromQMoveEvent(event))
	}
}

func (ptr *QWidget) OverrideWindowFlags(flags core.Qt__WindowType) {
	if ptr.Pointer() != nil {
		C.QWidget_OverrideWindowFlags(ptr.Pointer(), C.longlong(flags))
	}
}

//export callbackQWidget_PaintEvent
func callbackQWidget_PaintEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "paintEvent"); signal != nil {
		(*(*func(*gui.QPaintEvent))(signal))(gui.NewQPaintEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).PaintEventDefault(gui.NewQPaintEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectPaintEvent(f func(event *gui.QPaintEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paintEvent"); signal != nil {
			f := func(event *gui.QPaintEvent) {
				(*(*func(*gui.QPaintEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectPaintEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paintEvent")
	}
}

func (ptr *QWidget) PaintEvent(event gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_PaintEvent(ptr.Pointer(), gui.PointerFromQPaintEvent(event))
	}
}

func (ptr *QWidget) PaintEventDefault(event gui.QPaintEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_PaintEventDefault(ptr.Pointer(), gui.PointerFromQPaintEvent(event))
	}
}

//export callbackQWidget_Raise
func callbackQWidget_Raise(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "raise"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).RaiseDefault()
	}
}

func (ptr *QWidget) ConnectRaise(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "raise"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "raise", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "raise", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectRaise() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "raise")
	}
}

func (ptr *QWidget) Raise() {
	if ptr.Pointer() != nil {
		C.QWidget_Raise(ptr.Pointer())
	}
}

func (ptr *QWidget) RaiseDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_RaiseDefault(ptr.Pointer())
	}
}

func (ptr *QWidget) ReleaseKeyboard() {
	if ptr.Pointer() != nil {
		C.QWidget_ReleaseKeyboard(ptr.Pointer())
	}
}

func (ptr *QWidget) ReleaseMouse() {
	if ptr.Pointer() != nil {
		C.QWidget_ReleaseMouse(ptr.Pointer())
	}
}

func (ptr *QWidget) ReleaseShortcut(id int) {
	if ptr.Pointer() != nil {
		C.QWidget_ReleaseShortcut(ptr.Pointer(), C.int(int32(id)))
	}
}

func (ptr *QWidget) RemoveAction(action QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_RemoveAction(ptr.Pointer(), PointerFromQAction(action))
	}
}

func (ptr *QWidget) Render(target gui.QPaintDevice_ITF, targetOffset core.QPoint_ITF, sourceRegion gui.QRegion_ITF, renderFlags QWidget__RenderFlag) {
	if ptr.Pointer() != nil {
		C.QWidget_Render(ptr.Pointer(), gui.PointerFromQPaintDevice(target), core.PointerFromQPoint(targetOffset), gui.PointerFromQRegion(sourceRegion), C.longlong(renderFlags))
	}
}

func (ptr *QWidget) Render2(painter gui.QPainter_ITF, targetOffset core.QPoint_ITF, sourceRegion gui.QRegion_ITF, renderFlags QWidget__RenderFlag) {
	if ptr.Pointer() != nil {
		C.QWidget_Render2(ptr.Pointer(), gui.PointerFromQPainter(painter), core.PointerFromQPoint(targetOffset), gui.PointerFromQRegion(sourceRegion), C.longlong(renderFlags))
	}
}

//export callbackQWidget_Repaint
func callbackQWidget_Repaint(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "repaint"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).RepaintDefault()
	}
}

func (ptr *QWidget) ConnectRepaint(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "repaint"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "repaint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "repaint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectRepaint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "repaint")
	}
}

func (ptr *QWidget) Repaint() {
	if ptr.Pointer() != nil {
		C.QWidget_Repaint(ptr.Pointer())
	}
}

func (ptr *QWidget) RepaintDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_RepaintDefault(ptr.Pointer())
	}
}

func (ptr *QWidget) Repaint3(rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_Repaint3(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QWidget) Repaint4(rgn gui.QRegion_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_Repaint4(ptr.Pointer(), gui.PointerFromQRegion(rgn))
	}
}

func (ptr *QWidget) Repaint2(x int, y int, w int, h int) {
	if ptr.Pointer() != nil {
		C.QWidget_Repaint2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)), C.int(int32(w)), C.int(int32(h)))
	}
}

func (ptr *QWidget) Resize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_Resize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QWidget) Resize2(w int, h int) {
	if ptr.Pointer() != nil {
		C.QWidget_Resize2(ptr.Pointer(), C.int(int32(w)), C.int(int32(h)))
	}
}

//export callbackQWidget_ResizeEvent
func callbackQWidget_ResizeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "resizeEvent"); signal != nil {
		(*(*func(*gui.QResizeEvent))(signal))(gui.NewQResizeEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).ResizeEventDefault(gui.NewQResizeEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectResizeEvent(f func(event *gui.QResizeEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "resizeEvent"); signal != nil {
			f := func(event *gui.QResizeEvent) {
				(*(*func(*gui.QResizeEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "resizeEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "resizeEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectResizeEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "resizeEvent")
	}
}

func (ptr *QWidget) ResizeEvent(event gui.QResizeEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ResizeEvent(ptr.Pointer(), gui.PointerFromQResizeEvent(event))
	}
}

func (ptr *QWidget) ResizeEventDefault(event gui.QResizeEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ResizeEventDefault(ptr.Pointer(), gui.PointerFromQResizeEvent(event))
	}
}

func (ptr *QWidget) Scroll(dx int, dy int) {
	if ptr.Pointer() != nil {
		C.QWidget_Scroll(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy)))
	}
}

func (ptr *QWidget) Scroll2(dx int, dy int, r core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_Scroll2(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy)), core.PointerFromQRect(r))
	}
}

func (ptr *QWidget) SetAcceptDrops(on bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetAcceptDrops(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QWidget) SetAccessibleDescription(description string) {
	if ptr.Pointer() != nil {
		var descriptionC *C.char
		if description != "" {
			descriptionC = C.CString(description)
			defer C.free(unsafe.Pointer(descriptionC))
		}
		C.QWidget_SetAccessibleDescription(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: descriptionC, len: C.longlong(len(description))})
	}
}

func (ptr *QWidget) SetAccessibleName(name string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QWidget_SetAccessibleName(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))})
	}
}

func (ptr *QWidget) SetAttribute(attribute core.Qt__WidgetAttribute, on bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetAttribute(ptr.Pointer(), C.longlong(attribute), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QWidget) SetAutoFillBackground(enabled bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetAutoFillBackground(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
	}
}

func (ptr *QWidget) SetBackgroundRole(role gui.QPalette__ColorRole) {
	if ptr.Pointer() != nil {
		C.QWidget_SetBackgroundRole(ptr.Pointer(), C.longlong(role))
	}
}

func (ptr *QWidget) SetBaseSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetBaseSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QWidget) SetBaseSize2(basew int, baseh int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetBaseSize2(ptr.Pointer(), C.int(int32(basew)), C.int(int32(baseh)))
	}
}

func (ptr *QWidget) SetContentsMargins2(margins core.QMargins_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetContentsMargins2(ptr.Pointer(), core.PointerFromQMargins(margins))
	}
}

func (ptr *QWidget) SetContentsMargins(left int, top int, right int, bottom int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetContentsMargins(ptr.Pointer(), C.int(int32(left)), C.int(int32(top)), C.int(int32(right)), C.int(int32(bottom)))
	}
}

func (ptr *QWidget) SetContextMenuPolicy(policy core.Qt__ContextMenuPolicy) {
	if ptr.Pointer() != nil {
		C.QWidget_SetContextMenuPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QWidget) SetCursor(vqc gui.QCursor_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetCursor(ptr.Pointer(), gui.PointerFromQCursor(vqc))
	}
}

//export callbackQWidget_SetDisabled
func callbackQWidget_SetDisabled(ptr unsafe.Pointer, disable C.char) {
	if signal := qt.GetSignal(ptr, "setDisabled"); signal != nil {
		(*(*func(bool))(signal))(int8(disable) != 0)
	} else {
		NewQWidgetFromPointer(ptr).SetDisabledDefault(int8(disable) != 0)
	}
}

func (ptr *QWidget) ConnectSetDisabled(f func(disable bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setDisabled"); signal != nil {
			f := func(disable bool) {
				(*(*func(bool))(signal))(disable)
				f(disable)
			}
			qt.ConnectSignal(ptr.Pointer(), "setDisabled", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setDisabled", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectSetDisabled() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setDisabled")
	}
}

func (ptr *QWidget) SetDisabled(disable bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetDisabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(disable))))
	}
}

func (ptr *QWidget) SetDisabledDefault(disable bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetDisabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(disable))))
	}
}

func (ptr *QWidget) SetEditFocus(enable bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetEditFocus(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQWidget_SetEnabled
func callbackQWidget_SetEnabled(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setEnabled"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQWidgetFromPointer(ptr).SetEnabledDefault(int8(vbo) != 0)
	}
}

func (ptr *QWidget) ConnectSetEnabled(f func(vbo bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setEnabled"); signal != nil {
			f := func(vbo bool) {
				(*(*func(bool))(signal))(vbo)
				f(vbo)
			}
			qt.ConnectSignal(ptr.Pointer(), "setEnabled", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setEnabled", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectSetEnabled() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setEnabled")
	}
}

func (ptr *QWidget) SetEnabled(vbo bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QWidget) SetEnabledDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QWidget) SetFixedHeight(h int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetFixedHeight(ptr.Pointer(), C.int(int32(h)))
	}
}

func (ptr *QWidget) SetFixedSize(s core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetFixedSize(ptr.Pointer(), core.PointerFromQSize(s))
	}
}

func (ptr *QWidget) SetFixedSize2(w int, h int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetFixedSize2(ptr.Pointer(), C.int(int32(w)), C.int(int32(h)))
	}
}

func (ptr *QWidget) SetFixedWidth(w int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetFixedWidth(ptr.Pointer(), C.int(int32(w)))
	}
}

//export callbackQWidget_SetFocus2
func callbackQWidget_SetFocus2(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setFocus2"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).SetFocus2Default()
	}
}

func (ptr *QWidget) ConnectSetFocus2(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setFocus2"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "setFocus2", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setFocus2", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectSetFocus2() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setFocus2")
	}
}

func (ptr *QWidget) SetFocus2() {
	if ptr.Pointer() != nil {
		C.QWidget_SetFocus2(ptr.Pointer())
	}
}

func (ptr *QWidget) SetFocus2Default() {
	if ptr.Pointer() != nil {
		C.QWidget_SetFocus2Default(ptr.Pointer())
	}
}

func (ptr *QWidget) SetFocus(reason core.Qt__FocusReason) {
	if ptr.Pointer() != nil {
		C.QWidget_SetFocus(ptr.Pointer(), C.longlong(reason))
	}
}

func (ptr *QWidget) SetFocusPolicy(policy core.Qt__FocusPolicy) {
	if ptr.Pointer() != nil {
		C.QWidget_SetFocusPolicy(ptr.Pointer(), C.longlong(policy))
	}
}

func (ptr *QWidget) SetFocusProxy(w QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetFocusProxy(ptr.Pointer(), PointerFromQWidget(w))
	}
}

func (ptr *QWidget) SetFont(vqf gui.QFont_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetFont(ptr.Pointer(), gui.PointerFromQFont(vqf))
	}
}

func (ptr *QWidget) SetForegroundRole(role gui.QPalette__ColorRole) {
	if ptr.Pointer() != nil {
		C.QWidget_SetForegroundRole(ptr.Pointer(), C.longlong(role))
	}
}

func (ptr *QWidget) SetGeometry(vqr core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetGeometry(ptr.Pointer(), core.PointerFromQRect(vqr))
	}
}

func (ptr *QWidget) SetGeometry2(x int, y int, w int, h int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetGeometry2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)), C.int(int32(w)), C.int(int32(h)))
	}
}

func (ptr *QWidget) SetGraphicsEffect(effect QGraphicsEffect_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetGraphicsEffect(ptr.Pointer(), PointerFromQGraphicsEffect(effect))
	}
}

//export callbackQWidget_SetHidden
func callbackQWidget_SetHidden(ptr unsafe.Pointer, hidden C.char) {
	if signal := qt.GetSignal(ptr, "setHidden"); signal != nil {
		(*(*func(bool))(signal))(int8(hidden) != 0)
	} else {
		NewQWidgetFromPointer(ptr).SetHiddenDefault(int8(hidden) != 0)
	}
}

func (ptr *QWidget) ConnectSetHidden(f func(hidden bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setHidden"); signal != nil {
			f := func(hidden bool) {
				(*(*func(bool))(signal))(hidden)
				f(hidden)
			}
			qt.ConnectSignal(ptr.Pointer(), "setHidden", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setHidden", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectSetHidden() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setHidden")
	}
}

func (ptr *QWidget) SetHidden(hidden bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetHidden(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hidden))))
	}
}

func (ptr *QWidget) SetHiddenDefault(hidden bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetHiddenDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hidden))))
	}
}

func (ptr *QWidget) SetInputMethodHints(hints core.Qt__InputMethodHint) {
	if ptr.Pointer() != nil {
		C.QWidget_SetInputMethodHints(ptr.Pointer(), C.longlong(hints))
	}
}

func (ptr *QWidget) SetLayout(layout QLayout_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetLayout(ptr.Pointer(), PointerFromQLayout(layout))
	}
}

func (ptr *QWidget) SetLayoutDirection(direction core.Qt__LayoutDirection) {
	if ptr.Pointer() != nil {
		C.QWidget_SetLayoutDirection(ptr.Pointer(), C.longlong(direction))
	}
}

func (ptr *QWidget) SetLocale(locale core.QLocale_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetLocale(ptr.Pointer(), core.PointerFromQLocale(locale))
	}
}

func (ptr *QWidget) SetMask(bitmap gui.QBitmap_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMask(ptr.Pointer(), gui.PointerFromQBitmap(bitmap))
	}
}

func (ptr *QWidget) SetMask2(region gui.QRegion_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMask2(ptr.Pointer(), gui.PointerFromQRegion(region))
	}
}

func (ptr *QWidget) SetMaximumHeight(maxh int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMaximumHeight(ptr.Pointer(), C.int(int32(maxh)))
	}
}

func (ptr *QWidget) SetMaximumSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMaximumSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QWidget) SetMaximumSize2(maxw int, maxh int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMaximumSize2(ptr.Pointer(), C.int(int32(maxw)), C.int(int32(maxh)))
	}
}

func (ptr *QWidget) SetMaximumWidth(maxw int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMaximumWidth(ptr.Pointer(), C.int(int32(maxw)))
	}
}

func (ptr *QWidget) SetMinimumHeight(minh int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMinimumHeight(ptr.Pointer(), C.int(int32(minh)))
	}
}

func (ptr *QWidget) SetMinimumSize(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMinimumSize(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QWidget) SetMinimumSize2(minw int, minh int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMinimumSize2(ptr.Pointer(), C.int(int32(minw)), C.int(int32(minh)))
	}
}

func (ptr *QWidget) SetMinimumWidth(minw int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMinimumWidth(ptr.Pointer(), C.int(int32(minw)))
	}
}

func (ptr *QWidget) SetMouseTracking(enable bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetMouseTracking(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QWidget) SetPalette(vqp gui.QPalette_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetPalette(ptr.Pointer(), gui.PointerFromQPalette(vqp))
	}
}

func (ptr *QWidget) SetParent(parent QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetParent(ptr.Pointer(), PointerFromQWidget(parent))
	}
}

func (ptr *QWidget) SetParent2(parent QWidget_ITF, ff core.Qt__WindowType) {
	if ptr.Pointer() != nil {
		C.QWidget_SetParent2(ptr.Pointer(), PointerFromQWidget(parent), C.longlong(ff))
	}
}

func (ptr *QWidget) SetShortcutAutoRepeat(id int, enable bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetShortcutAutoRepeat(ptr.Pointer(), C.int(int32(id)), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QWidget) SetShortcutEnabled(id int, enable bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetShortcutEnabled(ptr.Pointer(), C.int(int32(id)), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QWidget) SetSizeIncrement(vqs core.QSize_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetSizeIncrement(ptr.Pointer(), core.PointerFromQSize(vqs))
	}
}

func (ptr *QWidget) SetSizeIncrement2(w int, h int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetSizeIncrement2(ptr.Pointer(), C.int(int32(w)), C.int(int32(h)))
	}
}

func (ptr *QWidget) SetSizePolicy(vqs QSizePolicy_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetSizePolicy(ptr.Pointer(), PointerFromQSizePolicy(vqs))
	}
}

func (ptr *QWidget) SetSizePolicy2(horizontal QSizePolicy__Policy, vertical QSizePolicy__Policy) {
	if ptr.Pointer() != nil {
		C.QWidget_SetSizePolicy2(ptr.Pointer(), C.longlong(horizontal), C.longlong(vertical))
	}
}

func (ptr *QWidget) SetStatusTip(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QWidget_SetStatusTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QWidget) SetStyle(style QStyle_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetStyle(ptr.Pointer(), PointerFromQStyle(style))
	}
}

//export callbackQWidget_SetStyleSheet
func callbackQWidget_SetStyleSheet(ptr unsafe.Pointer, styleSheet C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setStyleSheet"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(styleSheet))
	} else {
		NewQWidgetFromPointer(ptr).SetStyleSheetDefault(cGoUnpackString(styleSheet))
	}
}

func (ptr *QWidget) ConnectSetStyleSheet(f func(styleSheet string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setStyleSheet"); signal != nil {
			f := func(styleSheet string) {
				(*(*func(string))(signal))(styleSheet)
				f(styleSheet)
			}
			qt.ConnectSignal(ptr.Pointer(), "setStyleSheet", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setStyleSheet", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectSetStyleSheet() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setStyleSheet")
	}
}

func (ptr *QWidget) SetStyleSheet(styleSheet string) {
	if ptr.Pointer() != nil {
		var styleSheetC *C.char
		if styleSheet != "" {
			styleSheetC = C.CString(styleSheet)
			defer C.free(unsafe.Pointer(styleSheetC))
		}
		C.QWidget_SetStyleSheet(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: styleSheetC, len: C.longlong(len(styleSheet))})
	}
}

func (ptr *QWidget) SetStyleSheetDefault(styleSheet string) {
	if ptr.Pointer() != nil {
		var styleSheetC *C.char
		if styleSheet != "" {
			styleSheetC = C.CString(styleSheet)
			defer C.free(unsafe.Pointer(styleSheetC))
		}
		C.QWidget_SetStyleSheetDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: styleSheetC, len: C.longlong(len(styleSheet))})
	}
}

func QWidget_SetTabOrder(first QWidget_ITF, second QWidget_ITF) {
	C.QWidget_QWidget_SetTabOrder(PointerFromQWidget(first), PointerFromQWidget(second))
}

func (ptr *QWidget) SetTabOrder(first QWidget_ITF, second QWidget_ITF) {
	C.QWidget_QWidget_SetTabOrder(PointerFromQWidget(first), PointerFromQWidget(second))
}

func (ptr *QWidget) SetTabletTracking(enable bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetTabletTracking(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

func (ptr *QWidget) SetToolTip(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QWidget_SetToolTip(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QWidget) SetToolTipDuration(msec int) {
	if ptr.Pointer() != nil {
		C.QWidget_SetToolTipDuration(ptr.Pointer(), C.int(int32(msec)))
	}
}

func (ptr *QWidget) SetUpdatesEnabled(enable bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetUpdatesEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enable))))
	}
}

//export callbackQWidget_SetVisible
func callbackQWidget_SetVisible(ptr unsafe.Pointer, visible C.char) {
	if signal := qt.GetSignal(ptr, "setVisible"); signal != nil {
		(*(*func(bool))(signal))(int8(visible) != 0)
	} else {
		NewQWidgetFromPointer(ptr).SetVisibleDefault(int8(visible) != 0)
	}
}

func (ptr *QWidget) ConnectSetVisible(f func(visible bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setVisible"); signal != nil {
			f := func(visible bool) {
				(*(*func(bool))(signal))(visible)
				f(visible)
			}
			qt.ConnectSignal(ptr.Pointer(), "setVisible", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setVisible", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectSetVisible() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setVisible")
	}
}

func (ptr *QWidget) SetVisible(visible bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QWidget) SetVisibleDefault(visible bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
	}
}

func (ptr *QWidget) SetWhatsThis(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QWidget_SetWhatsThis(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QWidget) SetWindowFilePath(filePath string) {
	if ptr.Pointer() != nil {
		var filePathC *C.char
		if filePath != "" {
			filePathC = C.CString(filePath)
			defer C.free(unsafe.Pointer(filePathC))
		}
		C.QWidget_SetWindowFilePath(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: filePathC, len: C.longlong(len(filePath))})
	}
}

func (ptr *QWidget) SetWindowFlag(flag core.Qt__WindowType, on bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetWindowFlag(ptr.Pointer(), C.longlong(flag), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QWidget) SetWindowFlags(ty core.Qt__WindowType) {
	if ptr.Pointer() != nil {
		C.QWidget_SetWindowFlags(ptr.Pointer(), C.longlong(ty))
	}
}

func (ptr *QWidget) SetWindowIcon(icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetWindowIcon(ptr.Pointer(), gui.PointerFromQIcon(icon))
	}
}

func (ptr *QWidget) SetWindowIconText(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QWidget_SetWindowIconText(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QWidget) SetWindowModality(windowModality core.Qt__WindowModality) {
	if ptr.Pointer() != nil {
		C.QWidget_SetWindowModality(ptr.Pointer(), C.longlong(windowModality))
	}
}

//export callbackQWidget_SetWindowModified
func callbackQWidget_SetWindowModified(ptr unsafe.Pointer, vbo C.char) {
	if signal := qt.GetSignal(ptr, "setWindowModified"); signal != nil {
		(*(*func(bool))(signal))(int8(vbo) != 0)
	} else {
		NewQWidgetFromPointer(ptr).SetWindowModifiedDefault(int8(vbo) != 0)
	}
}

func (ptr *QWidget) ConnectSetWindowModified(f func(vbo bool)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setWindowModified"); signal != nil {
			f := func(vbo bool) {
				(*(*func(bool))(signal))(vbo)
				f(vbo)
			}
			qt.ConnectSignal(ptr.Pointer(), "setWindowModified", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setWindowModified", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectSetWindowModified() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setWindowModified")
	}
}

func (ptr *QWidget) SetWindowModified(vbo bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetWindowModified(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QWidget) SetWindowModifiedDefault(vbo bool) {
	if ptr.Pointer() != nil {
		C.QWidget_SetWindowModifiedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
	}
}

func (ptr *QWidget) SetWindowOpacity(level float64) {
	if ptr.Pointer() != nil {
		C.QWidget_SetWindowOpacity(ptr.Pointer(), C.double(level))
	}
}

func (ptr *QWidget) SetWindowRole(role string) {
	if ptr.Pointer() != nil {
		var roleC *C.char
		if role != "" {
			roleC = C.CString(role)
			defer C.free(unsafe.Pointer(roleC))
		}
		C.QWidget_SetWindowRole(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: roleC, len: C.longlong(len(role))})
	}
}

func (ptr *QWidget) SetWindowState(windowState core.Qt__WindowState) {
	if ptr.Pointer() != nil {
		C.QWidget_SetWindowState(ptr.Pointer(), C.longlong(windowState))
	}
}

//export callbackQWidget_SetWindowTitle
func callbackQWidget_SetWindowTitle(ptr unsafe.Pointer, vqs C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "setWindowTitle"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(vqs))
	} else {
		NewQWidgetFromPointer(ptr).SetWindowTitleDefault(cGoUnpackString(vqs))
	}
}

func (ptr *QWidget) ConnectSetWindowTitle(f func(vqs string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setWindowTitle"); signal != nil {
			f := func(vqs string) {
				(*(*func(string))(signal))(vqs)
				f(vqs)
			}
			qt.ConnectSignal(ptr.Pointer(), "setWindowTitle", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setWindowTitle", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectSetWindowTitle() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setWindowTitle")
	}
}

func (ptr *QWidget) SetWindowTitle(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QWidget_SetWindowTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QWidget) SetWindowTitleDefault(vqs string) {
	if ptr.Pointer() != nil {
		var vqsC *C.char
		if vqs != "" {
			vqsC = C.CString(vqs)
			defer C.free(unsafe.Pointer(vqsC))
		}
		C.QWidget_SetWindowTitleDefault(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: vqsC, len: C.longlong(len(vqs))})
	}
}

func (ptr *QWidget) SetupUi(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_SetupUi(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQWidget_Show
func callbackQWidget_Show(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "show"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).ShowDefault()
	}
}

func (ptr *QWidget) ConnectShow(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "show"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "show", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "show", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectShow() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "show")
	}
}

func (ptr *QWidget) Show() {
	if ptr.Pointer() != nil {
		C.QWidget_Show(ptr.Pointer())
	}
}

func (ptr *QWidget) ShowDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_ShowDefault(ptr.Pointer())
	}
}

//export callbackQWidget_ShowEvent
func callbackQWidget_ShowEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showEvent"); signal != nil {
		(*(*func(*gui.QShowEvent))(signal))(gui.NewQShowEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).ShowEventDefault(gui.NewQShowEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectShowEvent(f func(event *gui.QShowEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showEvent"); signal != nil {
			f := func(event *gui.QShowEvent) {
				(*(*func(*gui.QShowEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "showEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectShowEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showEvent")
	}
}

func (ptr *QWidget) ShowEvent(event gui.QShowEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ShowEvent(ptr.Pointer(), gui.PointerFromQShowEvent(event))
	}
}

func (ptr *QWidget) ShowEventDefault(event gui.QShowEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ShowEventDefault(ptr.Pointer(), gui.PointerFromQShowEvent(event))
	}
}

//export callbackQWidget_ShowFullScreen
func callbackQWidget_ShowFullScreen(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showFullScreen"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).ShowFullScreenDefault()
	}
}

func (ptr *QWidget) ConnectShowFullScreen(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showFullScreen"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "showFullScreen", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showFullScreen", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectShowFullScreen() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showFullScreen")
	}
}

func (ptr *QWidget) ShowFullScreen() {
	if ptr.Pointer() != nil {
		C.QWidget_ShowFullScreen(ptr.Pointer())
	}
}

func (ptr *QWidget) ShowFullScreenDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_ShowFullScreenDefault(ptr.Pointer())
	}
}

//export callbackQWidget_ShowMaximized
func callbackQWidget_ShowMaximized(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showMaximized"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).ShowMaximizedDefault()
	}
}

func (ptr *QWidget) ConnectShowMaximized(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMaximized"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "showMaximized", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMaximized", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectShowMaximized() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMaximized")
	}
}

func (ptr *QWidget) ShowMaximized() {
	if ptr.Pointer() != nil {
		C.QWidget_ShowMaximized(ptr.Pointer())
	}
}

func (ptr *QWidget) ShowMaximizedDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_ShowMaximizedDefault(ptr.Pointer())
	}
}

//export callbackQWidget_ShowMinimized
func callbackQWidget_ShowMinimized(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showMinimized"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).ShowMinimizedDefault()
	}
}

func (ptr *QWidget) ConnectShowMinimized(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showMinimized"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "showMinimized", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showMinimized", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectShowMinimized() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showMinimized")
	}
}

func (ptr *QWidget) ShowMinimized() {
	if ptr.Pointer() != nil {
		C.QWidget_ShowMinimized(ptr.Pointer())
	}
}

func (ptr *QWidget) ShowMinimizedDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_ShowMinimizedDefault(ptr.Pointer())
	}
}

//export callbackQWidget_ShowNormal
func callbackQWidget_ShowNormal(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "showNormal"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).ShowNormalDefault()
	}
}

func (ptr *QWidget) ConnectShowNormal(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "showNormal"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "showNormal", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "showNormal", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectShowNormal() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "showNormal")
	}
}

func (ptr *QWidget) ShowNormal() {
	if ptr.Pointer() != nil {
		C.QWidget_ShowNormal(ptr.Pointer())
	}
}

func (ptr *QWidget) ShowNormalDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_ShowNormalDefault(ptr.Pointer())
	}
}

func (ptr *QWidget) StackUnder(w QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_StackUnder(ptr.Pointer(), PointerFromQWidget(w))
	}
}

//export callbackQWidget_TabletEvent
func callbackQWidget_TabletEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "tabletEvent"); signal != nil {
		(*(*func(*gui.QTabletEvent))(signal))(gui.NewQTabletEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).TabletEventDefault(gui.NewQTabletEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectTabletEvent(f func(event *gui.QTabletEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "tabletEvent"); signal != nil {
			f := func(event *gui.QTabletEvent) {
				(*(*func(*gui.QTabletEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "tabletEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "tabletEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectTabletEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "tabletEvent")
	}
}

func (ptr *QWidget) TabletEvent(event gui.QTabletEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_TabletEvent(ptr.Pointer(), gui.PointerFromQTabletEvent(event))
	}
}

func (ptr *QWidget) TabletEventDefault(event gui.QTabletEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_TabletEventDefault(ptr.Pointer(), gui.PointerFromQTabletEvent(event))
	}
}

func (ptr *QWidget) UngrabGesture(gesture core.Qt__GestureType) {
	if ptr.Pointer() != nil {
		C.QWidget_UngrabGesture(ptr.Pointer(), C.longlong(gesture))
	}
}

func (ptr *QWidget) UnsetCursor() {
	if ptr.Pointer() != nil {
		C.QWidget_UnsetCursor(ptr.Pointer())
	}
}

func (ptr *QWidget) UnsetLayoutDirection() {
	if ptr.Pointer() != nil {
		C.QWidget_UnsetLayoutDirection(ptr.Pointer())
	}
}

func (ptr *QWidget) UnsetLocale() {
	if ptr.Pointer() != nil {
		C.QWidget_UnsetLocale(ptr.Pointer())
	}
}

//export callbackQWidget_Update
func callbackQWidget_Update(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "update"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).UpdateDefault()
	}
}

func (ptr *QWidget) ConnectUpdate(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "update"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "update", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "update", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectUpdate() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "update")
	}
}

func (ptr *QWidget) Update() {
	if ptr.Pointer() != nil {
		C.QWidget_Update(ptr.Pointer())
	}
}

func (ptr *QWidget) UpdateDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_UpdateDefault(ptr.Pointer())
	}
}

func (ptr *QWidget) Update3(rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_Update3(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QWidget) Update4(rgn gui.QRegion_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_Update4(ptr.Pointer(), gui.PointerFromQRegion(rgn))
	}
}

func (ptr *QWidget) Update2(x int, y int, w int, h int) {
	if ptr.Pointer() != nil {
		C.QWidget_Update2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)), C.int(int32(w)), C.int(int32(h)))
	}
}

func (ptr *QWidget) UpdateGeometry() {
	if ptr.Pointer() != nil {
		C.QWidget_UpdateGeometry(ptr.Pointer())
	}
}

//export callbackQWidget_UpdateMicroFocus
func callbackQWidget_UpdateMicroFocus(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "updateMicroFocus"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).UpdateMicroFocusDefault()
	}
}

func (ptr *QWidget) ConnectUpdateMicroFocus(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "updateMicroFocus"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "updateMicroFocus", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "updateMicroFocus", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectUpdateMicroFocus() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "updateMicroFocus")
	}
}

func (ptr *QWidget) UpdateMicroFocus() {
	if ptr.Pointer() != nil {
		C.QWidget_UpdateMicroFocus(ptr.Pointer())
	}
}

func (ptr *QWidget) UpdateMicroFocusDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_UpdateMicroFocusDefault(ptr.Pointer())
	}
}

//export callbackQWidget_WheelEvent
func callbackQWidget_WheelEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "wheelEvent"); signal != nil {
		(*(*func(*gui.QWheelEvent))(signal))(gui.NewQWheelEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).WheelEventDefault(gui.NewQWheelEventFromPointer(event))
	}
}

func (ptr *QWidget) ConnectWheelEvent(f func(event *gui.QWheelEvent)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "wheelEvent"); signal != nil {
			f := func(event *gui.QWheelEvent) {
				(*(*func(*gui.QWheelEvent))(signal))(event)
				f(event)
			}
			qt.ConnectSignal(ptr.Pointer(), "wheelEvent", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "wheelEvent", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectWheelEvent() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "wheelEvent")
	}
}

func (ptr *QWidget) WheelEvent(event gui.QWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_WheelEvent(ptr.Pointer(), gui.PointerFromQWheelEvent(event))
	}
}

func (ptr *QWidget) WheelEventDefault(event gui.QWheelEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_WheelEventDefault(ptr.Pointer(), gui.PointerFromQWheelEvent(event))
	}
}

//export callbackQWidget_WindowIconChanged
func callbackQWidget_WindowIconChanged(ptr unsafe.Pointer, icon unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "windowIconChanged"); signal != nil {
		(*(*func(*gui.QIcon))(signal))(gui.NewQIconFromPointer(icon))
	}

}

func (ptr *QWidget) ConnectWindowIconChanged(f func(icon *gui.QIcon)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "windowIconChanged") {
			C.QWidget_ConnectWindowIconChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "windowIconChanged"); signal != nil {
			f := func(icon *gui.QIcon) {
				(*(*func(*gui.QIcon))(signal))(icon)
				f(icon)
			}
			qt.ConnectSignal(ptr.Pointer(), "windowIconChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "windowIconChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectWindowIconChanged() {
	if ptr.Pointer() != nil {
		C.QWidget_DisconnectWindowIconChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "windowIconChanged")
	}
}

func (ptr *QWidget) WindowIconChanged(icon gui.QIcon_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_WindowIconChanged(ptr.Pointer(), gui.PointerFromQIcon(icon))
	}
}

//export callbackQWidget_WindowTitleChanged
func callbackQWidget_WindowTitleChanged(ptr unsafe.Pointer, title C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "windowTitleChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(title))
	}

}

func (ptr *QWidget) ConnectWindowTitleChanged(f func(title string)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "windowTitleChanged") {
			C.QWidget_ConnectWindowTitleChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "windowTitleChanged"); signal != nil {
			f := func(title string) {
				(*(*func(string))(signal))(title)
				f(title)
			}
			qt.ConnectSignal(ptr.Pointer(), "windowTitleChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "windowTitleChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectWindowTitleChanged() {
	if ptr.Pointer() != nil {
		C.QWidget_DisconnectWindowTitleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "windowTitleChanged")
	}
}

func (ptr *QWidget) WindowTitleChanged(title string) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		C.QWidget_WindowTitleChanged(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
	}
}

//export callbackQWidget_DestroyQWidget
func callbackQWidget_DestroyQWidget(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QWidget"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).DestroyQWidgetDefault()
	}
}

func (ptr *QWidget) ConnectDestroyQWidget(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QWidget"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectDestroyQWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QWidget")
	}
}

func (ptr *QWidget) DestroyQWidget() {
	if ptr.Pointer() != nil {
		C.QWidget_DestroyQWidget(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWidget) DestroyQWidgetDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_DestroyQWidgetDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWidget) BackingStore() *gui.QBackingStore {
	if ptr.Pointer() != nil {
		return gui.NewQBackingStoreFromPointer(C.QWidget_BackingStore(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWidget) SaveGeometry() *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QWidget_SaveGeometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) Cursor() *gui.QCursor {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQCursorFromPointer(C.QWidget_Cursor(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QCursor).DestroyQCursor)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) FontInfo() *gui.QFontInfo {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontInfoFromPointer(C.QWidget_FontInfo(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFontInfo).DestroyQFontInfo)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) FontMetrics() *gui.QFontMetrics {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQFontMetricsFromPointer(C.QWidget_FontMetrics(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QFontMetrics).DestroyQFontMetrics)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) GraphicsEffect() *QGraphicsEffect {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsEffectFromPointer(C.QWidget_GraphicsEffect(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) GraphicsProxyWidget() *QGraphicsProxyWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQGraphicsProxyWidgetFromPointer(C.QWidget_GraphicsProxyWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) WindowIcon() *gui.QIcon {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQIconFromPointer(C.QWidget_WindowIcon(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QIcon).DestroyQIcon)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) Layout() *QLayout {
	if ptr.Pointer() != nil {
		tmpValue := NewQLayoutFromPointer(C.QWidget_Layout(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) Actions() []*QAction {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QAction {
			out := make([]*QAction, int(l.len))
			tmpList := NewQWidgetFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__actions_atList(i)
			}
			return out
		}(C.QWidget_Actions(ptr.Pointer()))
	}
	return make([]*QAction, 0)
}

func (ptr *QWidget) Locale() *core.QLocale {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQLocaleFromPointer(C.QWidget_Locale(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QLocale).DestroyQLocale)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) ContentsMargins() *core.QMargins {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQMarginsFromPointer(C.QWidget_ContentsMargins(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QMargins).DestroyQMargins)
		return tmpValue
	}
	return nil
}

//export callbackQWidget_PaintEngine
func callbackQWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "paintEngine"); signal != nil {
		return gui.PointerFromQPaintEngine((*(*func() *gui.QPaintEngine)(signal))())
	}

	return gui.PointerFromQPaintEngine(NewQWidgetFromPointer(ptr).PaintEngineDefault())
}

func (ptr *QWidget) ConnectPaintEngine(f func() *gui.QPaintEngine) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "paintEngine"); signal != nil {
			f := func() *gui.QPaintEngine {
				(*(*func() *gui.QPaintEngine)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "paintEngine", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "paintEngine", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectPaintEngine() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "paintEngine")
	}
}

func (ptr *QWidget) PaintEngine() *gui.QPaintEngine {
	if ptr.Pointer() != nil {
		return gui.NewQPaintEngineFromPointer(C.QWidget_PaintEngine(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWidget) PaintEngineDefault() *gui.QPaintEngine {
	if ptr.Pointer() != nil {
		return gui.NewQPaintEngineFromPointer(C.QWidget_PaintEngineDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWidget) BackgroundRole() gui.QPalette__ColorRole {
	if ptr.Pointer() != nil {
		return gui.QPalette__ColorRole(C.QWidget_BackgroundRole(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) ForegroundRole() gui.QPalette__ColorRole {
	if ptr.Pointer() != nil {
		return gui.QPalette__ColorRole(C.QWidget_ForegroundRole(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) MapFrom(parent QWidget_ITF, pos core.QPoint_ITF) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QWidget_MapFrom(ptr.Pointer(), PointerFromQWidget(parent), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) MapFromGlobal(pos core.QPoint_ITF) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QWidget_MapFromGlobal(ptr.Pointer(), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) MapFromParent(pos core.QPoint_ITF) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QWidget_MapFromParent(ptr.Pointer(), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) MapTo(parent QWidget_ITF, pos core.QPoint_ITF) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QWidget_MapTo(ptr.Pointer(), PointerFromQWidget(parent), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) MapToGlobal(pos core.QPoint_ITF) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QWidget_MapToGlobal(ptr.Pointer(), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) MapToParent(pos core.QPoint_ITF) *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QWidget_MapToParent(ptr.Pointer(), core.PointerFromQPoint(pos)))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) Pos() *core.QPoint {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQPointFromPointer(C.QWidget_Pos(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QPoint).DestroyQPoint)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) ChildrenRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QWidget_ChildrenRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) ContentsRect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QWidget_ContentsRect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) FrameGeometry() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QWidget_FrameGeometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) NormalGeometry() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QWidget_NormalGeometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) Rect() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QWidget_Rect(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) ChildrenRegion() *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QWidget_ChildrenRegion(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) Mask() *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QWidget_Mask(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) VisibleRegion() *gui.QRegion {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQRegionFromPointer(C.QWidget_VisibleRegion(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*gui.QRegion).DestroyQRegion)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) BaseSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_BaseSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) FrameSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_FrameSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) MaximumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_MaximumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) MinimumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_MinimumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQWidget_MinimumSizeHint
func callbackQWidget_MinimumSizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "minimumSizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQWidgetFromPointer(ptr).MinimumSizeHintDefault())
}

func (ptr *QWidget) ConnectMinimumSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "minimumSizeHint"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "minimumSizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "minimumSizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectMinimumSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "minimumSizeHint")
	}
}

func (ptr *QWidget) MinimumSizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_MinimumSizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) MinimumSizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_MinimumSizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) Size() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_Size(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQWidget_SizeHint
func callbackQWidget_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQWidgetFromPointer(ptr).SizeHintDefault())
}

func (ptr *QWidget) ConnectSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QWidget) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) SizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_SizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) SizeIncrement() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidget_SizeIncrement(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) SizePolicy() *QSizePolicy {
	if ptr.Pointer() != nil {
		tmpValue := NewQSizePolicyFromPointer(C.QWidget_SizePolicy(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*QSizePolicy).DestroyQSizePolicy)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) AccessibleDescription() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_AccessibleDescription(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) AccessibleName() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_AccessibleName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) StatusTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_StatusTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) StyleSheet() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_StyleSheet(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) ToolTip() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_ToolTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) WhatsThis() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_WhatsThis(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) WindowFilePath() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_WindowFilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) WindowIconText() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_WindowIconText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) WindowRole() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_WindowRole(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) WindowTitle() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWidget_WindowTitle(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWidget) Style() *QStyle {
	if ptr.Pointer() != nil {
		tmpValue := NewQStyleFromPointer(C.QWidget_Style(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

//export callbackQWidget_InputMethodQuery
func callbackQWidget_InputMethodQuery(ptr unsafe.Pointer, query C.longlong) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "inputMethodQuery"); signal != nil {
		return core.PointerFromQVariant((*(*func(core.Qt__InputMethodQuery) *core.QVariant)(signal))(core.Qt__InputMethodQuery(query)))
	}

	return core.PointerFromQVariant(NewQWidgetFromPointer(ptr).InputMethodQueryDefault(core.Qt__InputMethodQuery(query)))
}

func (ptr *QWidget) ConnectInputMethodQuery(f func(query core.Qt__InputMethodQuery) *core.QVariant) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "inputMethodQuery"); signal != nil {
			f := func(query core.Qt__InputMethodQuery) *core.QVariant {
				(*(*func(core.Qt__InputMethodQuery) *core.QVariant)(signal))(query)
				return f(query)
			}
			qt.ConnectSignal(ptr.Pointer(), "inputMethodQuery", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "inputMethodQuery", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectInputMethodQuery() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "inputMethodQuery")
	}
}

func (ptr *QWidget) InputMethodQuery(query core.Qt__InputMethodQuery) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QWidget_InputMethodQuery(ptr.Pointer(), C.longlong(query)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) InputMethodQueryDefault(query core.Qt__InputMethodQuery) *core.QVariant {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQVariantFromPointer(C.QWidget_InputMethodQueryDefault(ptr.Pointer(), C.longlong(query)))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) ChildAt2(p core.QPoint_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidget_ChildAt2(ptr.Pointer(), core.PointerFromQPoint(p)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) ChildAt(x int, y int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidget_ChildAt(ptr.Pointer(), C.int(int32(x)), C.int(int32(y))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) FocusProxy() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidget_FocusProxy(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) FocusWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidget_FocusWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) NativeParentWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidget_NativeParentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) NextInFocusChain() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidget_NextInFocusChain(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) ParentWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidget_ParentWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) PreviousInFocusChain() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidget_PreviousInFocusChain(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) Window() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidget_Window(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) WindowHandle() *gui.QWindow {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQWindowFromPointer(C.QWidget_WindowHandle(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) ContextMenuPolicy() core.Qt__ContextMenuPolicy {
	if ptr.Pointer() != nil {
		return core.Qt__ContextMenuPolicy(C.QWidget_ContextMenuPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) FocusPolicy() core.Qt__FocusPolicy {
	if ptr.Pointer() != nil {
		return core.Qt__FocusPolicy(C.QWidget_FocusPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) InputMethodHints() core.Qt__InputMethodHint {
	if ptr.Pointer() != nil {
		return core.Qt__InputMethodHint(C.QWidget_InputMethodHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) LayoutDirection() core.Qt__LayoutDirection {
	if ptr.Pointer() != nil {
		return core.Qt__LayoutDirection(C.QWidget_LayoutDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) WindowFlags() core.Qt__WindowType {
	if ptr.Pointer() != nil {
		return core.Qt__WindowType(C.QWidget_WindowFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) WindowModality() core.Qt__WindowModality {
	if ptr.Pointer() != nil {
		return core.Qt__WindowModality(C.QWidget_WindowModality(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) WindowState() core.Qt__WindowState {
	if ptr.Pointer() != nil {
		return core.Qt__WindowState(C.QWidget_WindowState(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) WindowType() core.Qt__WindowType {
	if ptr.Pointer() != nil {
		return core.Qt__WindowType(C.QWidget_WindowType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) EffectiveWinId() uintptr {
	if ptr.Pointer() != nil {
		return uintptr(C.QWidget_EffectiveWinId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) WinId() uintptr {
	if ptr.Pointer() != nil {
		return uintptr(C.QWidget_WinId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) AcceptDrops() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_AcceptDrops(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) AutoFillBackground() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_AutoFillBackground(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) HasEditFocus() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_HasEditFocus(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) HasFocus() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_HasFocus(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQWidget_HasHeightForWidth
func callbackQWidget_HasHeightForWidth(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "hasHeightForWidth"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWidgetFromPointer(ptr).HasHeightForWidthDefault())))
}

func (ptr *QWidget) ConnectHasHeightForWidth(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "hasHeightForWidth"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "hasHeightForWidth", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "hasHeightForWidth", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectHasHeightForWidth() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "hasHeightForWidth")
	}
}

func (ptr *QWidget) HasHeightForWidth() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_HasHeightForWidth(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) HasHeightForWidthDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_HasHeightForWidthDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) HasMouseTracking() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_HasMouseTracking(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) HasTabletTracking() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_HasTabletTracking(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsActiveWindow() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsActiveWindow(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsAncestorOf(child QWidget_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsAncestorOf(ptr.Pointer(), PointerFromQWidget(child))) != 0
	}
	return false
}

func (ptr *QWidget) IsEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsEnabledTo(ancestor QWidget_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsEnabledTo(ptr.Pointer(), PointerFromQWidget(ancestor))) != 0
	}
	return false
}

func (ptr *QWidget) IsFullScreen() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsFullScreen(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsHidden() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsHidden(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsMaximized() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsMaximized(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsMinimized() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsMinimized(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsModal() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsModal(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsVisible() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsVisible(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsVisibleTo(ancestor QWidget_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsVisibleTo(ptr.Pointer(), PointerFromQWidget(ancestor))) != 0
	}
	return false
}

func (ptr *QWidget) IsWindow() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsWindow(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) IsWindowModified() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_IsWindowModified(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) TestAttribute(attribute core.Qt__WidgetAttribute) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_TestAttribute(ptr.Pointer(), C.longlong(attribute))) != 0
	}
	return false
}

func (ptr *QWidget) UnderMouse() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_UnderMouse(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) UpdatesEnabled() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_UpdatesEnabled(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidget) Font() *gui.QFont {
	if ptr.Pointer() != nil {
		return gui.NewQFontFromPointer(C.QWidget_Font(ptr.Pointer()))
	}
	return nil
}

//export callbackQWidget_MetaObject
func callbackQWidget_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
		return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
	}

	return core.PointerFromQMetaObject(NewQWidgetFromPointer(ptr).MetaObjectDefault())
}

func (ptr *QWidget) ConnectMetaObject(f func() *core.QMetaObject) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "metaObject"); signal != nil {
			f := func() *core.QMetaObject {
				(*(*func() *core.QMetaObject)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "metaObject", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "metaObject", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectMetaObject() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "metaObject")
	}
}

func (ptr *QWidget) MetaObject() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QWidget_MetaObject(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWidget) MetaObjectDefault() *core.QMetaObject {
	if ptr.Pointer() != nil {
		return core.NewQMetaObjectFromPointer(C.QWidget_MetaObjectDefault(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWidget) Palette() *gui.QPalette {
	if ptr.Pointer() != nil {
		return gui.NewQPaletteFromPointer(C.QWidget_Palette(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWidget) Geometry() *core.QRect {
	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QWidget_Geometry(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWidget) Height() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_Height(ptr.Pointer())))
	}
	return 0
}

//export callbackQWidget_HeightForWidth
func callbackQWidget_HeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
	if signal := qt.GetSignal(ptr, "heightForWidth"); signal != nil {
		return C.int(int32((*(*func(int) int)(signal))(int(int32(w)))))
	}

	return C.int(int32(NewQWidgetFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
}

func (ptr *QWidget) ConnectHeightForWidth(f func(w int) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "heightForWidth"); signal != nil {
			f := func(w int) int {
				(*(*func(int) int)(signal))(w)
				return f(w)
			}
			qt.ConnectSignal(ptr.Pointer(), "heightForWidth", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "heightForWidth", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectHeightForWidth() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "heightForWidth")
	}
}

func (ptr *QWidget) HeightForWidth(w int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_HeightForWidth(ptr.Pointer(), C.int(int32(w)))))
	}
	return 0
}

func (ptr *QWidget) HeightForWidthDefault(w int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
	}
	return 0
}

func (ptr *QWidget) MaximumHeight() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_MaximumHeight(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWidget) MaximumWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_MaximumWidth(ptr.Pointer())))
	}
	return 0
}

//export callbackQWidget_Metric
func callbackQWidget_Metric(ptr unsafe.Pointer, m C.longlong) C.int {
	if signal := qt.GetSignal(ptr, "metric"); signal != nil {
		return C.int(int32((*(*func(gui.QPaintDevice__PaintDeviceMetric) int)(signal))(gui.QPaintDevice__PaintDeviceMetric(m))))
	}

	return C.int(int32(NewQWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(m))))
}

func (ptr *QWidget) ConnectMetric(f func(m gui.QPaintDevice__PaintDeviceMetric) int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "metric"); signal != nil {
			f := func(m gui.QPaintDevice__PaintDeviceMetric) int {
				(*(*func(gui.QPaintDevice__PaintDeviceMetric) int)(signal))(m)
				return f(m)
			}
			qt.ConnectSignal(ptr.Pointer(), "metric", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "metric", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectMetric() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "metric")
	}
}

func (ptr *QWidget) Metric(m gui.QPaintDevice__PaintDeviceMetric) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_Metric(ptr.Pointer(), C.longlong(m))))
	}
	return 0
}

func (ptr *QWidget) MetricDefault(m gui.QPaintDevice__PaintDeviceMetric) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_MetricDefault(ptr.Pointer(), C.longlong(m))))
	}
	return 0
}

func (ptr *QWidget) MinimumHeight() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_MinimumHeight(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWidget) MinimumWidth() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_MinimumWidth(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWidget) ToolTipDuration() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_ToolTipDuration(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWidget) Width() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_Width(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWidget) X() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_X(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWidget) Y() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWidget_Y(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWidget) WindowOpacity() float64 {
	if ptr.Pointer() != nil {
		return float64(C.QWidget_WindowOpacity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidget) EnsurePolished() {
	if ptr.Pointer() != nil {
		C.QWidget_EnsurePolished(ptr.Pointer())
	}
}

func (ptr *QWidget) GetContentsMargins(left int, top int, right int, bottom int) {
	if ptr.Pointer() != nil {
		C.QWidget_GetContentsMargins(ptr.Pointer(), C.int(int32(left)), C.int(int32(top)), C.int(int32(right)), C.int(int32(bottom)))
	}
}

//export callbackQWidget_InitPainter
func callbackQWidget_InitPainter(ptr unsafe.Pointer, painter unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "initPainter"); signal != nil {
		(*(*func(*gui.QPainter))(signal))(gui.NewQPainterFromPointer(painter))
	} else {
		NewQWidgetFromPointer(ptr).InitPainterDefault(gui.NewQPainterFromPointer(painter))
	}
}

func (ptr *QWidget) ConnectInitPainter(f func(painter *gui.QPainter)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "initPainter"); signal != nil {
			f := func(painter *gui.QPainter) {
				(*(*func(*gui.QPainter))(signal))(painter)
				f(painter)
			}
			qt.ConnectSignal(ptr.Pointer(), "initPainter", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "initPainter", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidget) DisconnectInitPainter() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "initPainter")
	}
}

func (ptr *QWidget) InitPainter(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_InitPainter(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

func (ptr *QWidget) InitPainterDefault(painter gui.QPainter_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_InitPainterDefault(ptr.Pointer(), gui.PointerFromQPainter(painter))
	}
}

func (ptr *QWidget) __addActions_actions_atList(i int) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QWidget___addActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) __addActions_actions_setList(i QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget___addActions_actions_setList(ptr.Pointer(), PointerFromQAction(i))
	}
}

func (ptr *QWidget) __addActions_actions_newList() unsafe.Pointer {
	return C.QWidget___addActions_actions_newList(ptr.Pointer())
}

func (ptr *QWidget) __insertActions_actions_atList(i int) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QWidget___insertActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) __insertActions_actions_setList(i QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget___insertActions_actions_setList(ptr.Pointer(), PointerFromQAction(i))
	}
}

func (ptr *QWidget) __insertActions_actions_newList() unsafe.Pointer {
	return C.QWidget___insertActions_actions_newList(ptr.Pointer())
}

func (ptr *QWidget) __actions_atList(i int) *QAction {
	if ptr.Pointer() != nil {
		tmpValue := NewQActionFromPointer(C.QWidget___actions_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) __actions_setList(i QAction_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget___actions_setList(ptr.Pointer(), PointerFromQAction(i))
	}
}

func (ptr *QWidget) __actions_newList() unsafe.Pointer {
	return C.QWidget___actions_newList(ptr.Pointer())
}

func (ptr *QWidget) __dynamicPropertyNames_atList(i int) *core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQByteArrayFromPointer(C.QWidget___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
	}
}

func (ptr *QWidget) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.QWidget___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *QWidget) __findChildren_atList2(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QWidget___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) __findChildren_setList2(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QWidget) __findChildren_newList2() unsafe.Pointer {
	return C.QWidget___findChildren_newList2(ptr.Pointer())
}

func (ptr *QWidget) __findChildren_atList3(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QWidget___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) __findChildren_setList3(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QWidget) __findChildren_newList3() unsafe.Pointer {
	return C.QWidget___findChildren_newList3(ptr.Pointer())
}

func (ptr *QWidget) __findChildren_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QWidget___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) __findChildren_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QWidget) __findChildren_newList() unsafe.Pointer {
	return C.QWidget___findChildren_newList(ptr.Pointer())
}

func (ptr *QWidget) __children_atList(i int) *core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQObjectFromPointer(C.QWidget___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidget) __children_setList(i core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
	}
}

func (ptr *QWidget) __children_newList() unsafe.Pointer {
	return C.QWidget___children_newList(ptr.Pointer())
}

//export callbackQWidget_EventFilter
func callbackQWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWidgetFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}

func (ptr *QWidget) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

func (ptr *QWidget) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidget_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackQWidget_ChildEvent
func callbackQWidget_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QWidget) ChildEvent(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QWidget) ChildEventDefault(event core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

//export callbackQWidget_ConnectNotify
func callbackQWidget_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQWidgetFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QWidget) ConnectNotify(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

func (ptr *QWidget) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQWidget_CustomEvent
func callbackQWidget_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QWidget) CustomEvent(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QWidget) CustomEventDefault(event core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

//export callbackQWidget_DeleteLater
func callbackQWidget_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *QWidget) DeleteLater() {
	if ptr.Pointer() != nil {
		C.QWidget_DeleteLater(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWidget) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.QWidget_DeleteLaterDefault(ptr.Pointer())
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQWidget_Destroyed
func callbackQWidget_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
	}

}

//export callbackQWidget_DisconnectNotify
func callbackQWidget_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
	} else {
		NewQWidgetFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *QWidget) DisconnectNotify(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

func (ptr *QWidget) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
	}
}

//export callbackQWidget_ObjectNameChanged
func callbackQWidget_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtWidgets_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		(*(*func(string))(signal))(cGoUnpackString(objectName))
	}

}

//export callbackQWidget_TimerEvent
func callbackQWidget_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQWidgetFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QWidget) TimerEvent(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QWidget) TimerEventDefault(event core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.QWidget_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

type QWidgetAction struct {
	QAction
}

type QWidgetAction_ITF interface {
	QAction_ITF
	QWidgetAction_PTR() *QWidgetAction
}

func (ptr *QWidgetAction) QWidgetAction_PTR() *QWidgetAction {
	return ptr
}

func (ptr *QWidgetAction) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QAction_PTR().Pointer()
	}
	return nil
}

func (ptr *QWidgetAction) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QAction_PTR().SetPointer(p)
	}
}

func PointerFromQWidgetAction(ptr QWidgetAction_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidgetAction_PTR().Pointer()
	}
	return nil
}

func NewQWidgetActionFromPointer(ptr unsafe.Pointer) (n *QWidgetAction) {
	n = new(QWidgetAction)
	n.SetPointer(ptr)
	return
}

//export callbackQWidgetAction_CreateWidget
func callbackQWidgetAction_CreateWidget(ptr unsafe.Pointer, parent unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "createWidget"); signal != nil {
		return PointerFromQWidget((*(*func(*QWidget) *QWidget)(signal))(NewQWidgetFromPointer(parent)))
	}

	return PointerFromQWidget(NewQWidgetActionFromPointer(ptr).CreateWidgetDefault(NewQWidgetFromPointer(parent)))
}

func (ptr *QWidgetAction) ConnectCreateWidget(f func(parent *QWidget) *QWidget) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "createWidget"); signal != nil {
			f := func(parent *QWidget) *QWidget {
				(*(*func(*QWidget) *QWidget)(signal))(parent)
				return f(parent)
			}
			qt.ConnectSignal(ptr.Pointer(), "createWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "createWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetAction) DisconnectCreateWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "createWidget")
	}
}

func (ptr *QWidgetAction) CreateWidget(parent QWidget_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidgetAction_CreateWidget(ptr.Pointer(), PointerFromQWidget(parent)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidgetAction) CreateWidgetDefault(parent QWidget_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidgetAction_CreateWidgetDefault(ptr.Pointer(), PointerFromQWidget(parent)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidgetAction) RequestWidget(parent QWidget_ITF) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidgetAction_RequestWidget(ptr.Pointer(), PointerFromQWidget(parent)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func NewQWidgetAction(parent core.QObject_ITF) *QWidgetAction {
	tmpValue := NewQWidgetActionFromPointer(C.QWidgetAction_NewQWidgetAction(core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQWidgetAction_DeleteWidget
func callbackQWidgetAction_DeleteWidget(ptr unsafe.Pointer, widget unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteWidget"); signal != nil {
		(*(*func(*QWidget))(signal))(NewQWidgetFromPointer(widget))
	} else {
		NewQWidgetActionFromPointer(ptr).DeleteWidgetDefault(NewQWidgetFromPointer(widget))
	}
}

func (ptr *QWidgetAction) ConnectDeleteWidget(f func(widget *QWidget)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "deleteWidget"); signal != nil {
			f := func(widget *QWidget) {
				(*(*func(*QWidget))(signal))(widget)
				f(widget)
			}
			qt.ConnectSignal(ptr.Pointer(), "deleteWidget", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "deleteWidget", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetAction) DisconnectDeleteWidget() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "deleteWidget")
	}
}

func (ptr *QWidgetAction) DeleteWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidgetAction_DeleteWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QWidgetAction) DeleteWidgetDefault(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidgetAction_DeleteWidgetDefault(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QWidgetAction) ReleaseWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidgetAction_ReleaseWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QWidgetAction) SetDefaultWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidgetAction_SetDefaultWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

//export callbackQWidgetAction_DestroyQWidgetAction
func callbackQWidgetAction_DestroyQWidgetAction(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QWidgetAction"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetActionFromPointer(ptr).DestroyQWidgetActionDefault()
	}
}

func (ptr *QWidgetAction) ConnectDestroyQWidgetAction(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QWidgetAction"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QWidgetAction", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QWidgetAction", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetAction) DisconnectDestroyQWidgetAction() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QWidgetAction")
	}
}

func (ptr *QWidgetAction) DestroyQWidgetAction() {
	if ptr.Pointer() != nil {
		C.QWidgetAction_DestroyQWidgetAction(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWidgetAction) DestroyQWidgetActionDefault() {
	if ptr.Pointer() != nil {
		C.QWidgetAction_DestroyQWidgetActionDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWidgetAction) CreatedWidgets() []*QWidget {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []*QWidget {
			out := make([]*QWidget, int(l.len))
			tmpList := NewQWidgetActionFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__createdWidgets_atList(i)
			}
			return out
		}(C.QWidgetAction_CreatedWidgets(ptr.Pointer()))
	}
	return make([]*QWidget, 0)
}

func (ptr *QWidgetAction) DefaultWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidgetAction_DefaultWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidgetAction) __createdWidgets_atList(i int) *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidgetAction___createdWidgets_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidgetAction) __createdWidgets_setList(i QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidgetAction___createdWidgets_setList(ptr.Pointer(), PointerFromQWidget(i))
	}
}

func (ptr *QWidgetAction) __createdWidgets_newList() unsafe.Pointer {
	return C.QWidgetAction___createdWidgets_newList(ptr.Pointer())
}

type QWidgetItem struct {
	QLayoutItem
}

type QWidgetItem_ITF interface {
	QLayoutItem_ITF
	QWidgetItem_PTR() *QWidgetItem
}

func (ptr *QWidgetItem) QWidgetItem_PTR() *QWidgetItem {
	return ptr
}

func (ptr *QWidgetItem) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QLayoutItem_PTR().Pointer()
	}
	return nil
}

func (ptr *QWidgetItem) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QLayoutItem_PTR().SetPointer(p)
	}
}

func PointerFromQWidgetItem(ptr QWidgetItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidgetItem_PTR().Pointer()
	}
	return nil
}

func NewQWidgetItemFromPointer(ptr unsafe.Pointer) (n *QWidgetItem) {
	n = new(QWidgetItem)
	n.SetPointer(ptr)
	return
}
func NewQWidgetItem(widget QWidget_ITF) *QWidgetItem {
	return NewQWidgetItemFromPointer(C.QWidgetItem_NewQWidgetItem(PointerFromQWidget(widget)))
}

//export callbackQWidgetItem_SetGeometry
func callbackQWidgetItem_SetGeometry(ptr unsafe.Pointer, rect unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "setGeometry"); signal != nil {
		(*(*func(*core.QRect))(signal))(core.NewQRectFromPointer(rect))
	} else {
		NewQWidgetItemFromPointer(ptr).SetGeometryDefault(core.NewQRectFromPointer(rect))
	}
}

func (ptr *QWidgetItem) ConnectSetGeometry(f func(rect *core.QRect)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "setGeometry"); signal != nil {
			f := func(rect *core.QRect) {
				(*(*func(*core.QRect))(signal))(rect)
				f(rect)
			}
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "setGeometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetItem) DisconnectSetGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "setGeometry")
	}
}

func (ptr *QWidgetItem) SetGeometry(rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QWidgetItem_SetGeometry(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QWidgetItem) SetGeometryDefault(rect core.QRect_ITF) {
	if ptr.Pointer() != nil {
		C.QWidgetItem_SetGeometryDefault(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

//export callbackQWidgetItem_DestroyQWidgetItem
func callbackQWidgetItem_DestroyQWidgetItem(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QWidgetItem"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWidgetItemFromPointer(ptr).DestroyQWidgetItemDefault()
	}
}

func (ptr *QWidgetItem) ConnectDestroyQWidgetItem(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QWidgetItem"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QWidgetItem", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QWidgetItem", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetItem) DisconnectDestroyQWidgetItem() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QWidgetItem")
	}
}

func (ptr *QWidgetItem) DestroyQWidgetItem() {
	if ptr.Pointer() != nil {
		C.QWidgetItem_DestroyQWidgetItem(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWidgetItem) DestroyQWidgetItemDefault() {
	if ptr.Pointer() != nil {
		C.QWidgetItem_DestroyQWidgetItemDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackQWidgetItem_Geometry
func callbackQWidgetItem_Geometry(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "geometry"); signal != nil {
		return core.PointerFromQRect((*(*func() *core.QRect)(signal))())
	}

	return core.PointerFromQRect(NewQWidgetItemFromPointer(ptr).GeometryDefault())
}

func (ptr *QWidgetItem) ConnectGeometry(f func() *core.QRect) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "geometry"); signal != nil {
			f := func() *core.QRect {
				(*(*func() *core.QRect)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "geometry", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "geometry", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetItem) DisconnectGeometry() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "geometry")
	}
}

func (ptr *QWidgetItem) Geometry() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QWidgetItem_Geometry(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

func (ptr *QWidgetItem) GeometryDefault() *core.QRect {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQRectFromPointer(C.QWidgetItem_GeometryDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
		return tmpValue
	}
	return nil
}

//export callbackQWidgetItem_MaximumSize
func callbackQWidgetItem_MaximumSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "maximumSize"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQWidgetItemFromPointer(ptr).MaximumSizeDefault())
}

func (ptr *QWidgetItem) ConnectMaximumSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "maximumSize"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "maximumSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "maximumSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetItem) DisconnectMaximumSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "maximumSize")
	}
}

func (ptr *QWidgetItem) MaximumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidgetItem_MaximumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidgetItem) MaximumSizeDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidgetItem_MaximumSizeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQWidgetItem_MinimumSize
func callbackQWidgetItem_MinimumSize(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "minimumSize"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQWidgetItemFromPointer(ptr).MinimumSizeDefault())
}

func (ptr *QWidgetItem) ConnectMinimumSize(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "minimumSize"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "minimumSize", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "minimumSize", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetItem) DisconnectMinimumSize() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "minimumSize")
	}
}

func (ptr *QWidgetItem) MinimumSize() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidgetItem_MinimumSize(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidgetItem) MinimumSizeDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidgetItem_MinimumSizeDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQWidgetItem_SizeHint
func callbackQWidgetItem_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
		return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
	}

	return core.PointerFromQSize(NewQWidgetItemFromPointer(ptr).SizeHintDefault())
}

func (ptr *QWidgetItem) ConnectSizeHint(f func() *core.QSize) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
			f := func() *core.QSize {
				(*(*func() *core.QSize)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetItem) DisconnectSizeHint() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
	}
}

func (ptr *QWidgetItem) SizeHint() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidgetItem_SizeHint(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

func (ptr *QWidgetItem) SizeHintDefault() *core.QSize {
	if ptr.Pointer() != nil {
		tmpValue := core.NewQSizeFromPointer(C.QWidgetItem_SizeHintDefault(ptr.Pointer()))
		runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
		return tmpValue
	}
	return nil
}

//export callbackQWidgetItem_ExpandingDirections
func callbackQWidgetItem_ExpandingDirections(ptr unsafe.Pointer) C.longlong {
	if signal := qt.GetSignal(ptr, "expandingDirections"); signal != nil {
		return C.longlong((*(*func() core.Qt__Orientation)(signal))())
	}

	return C.longlong(NewQWidgetItemFromPointer(ptr).ExpandingDirectionsDefault())
}

func (ptr *QWidgetItem) ConnectExpandingDirections(f func() core.Qt__Orientation) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "expandingDirections"); signal != nil {
			f := func() core.Qt__Orientation {
				(*(*func() core.Qt__Orientation)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "expandingDirections", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "expandingDirections", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetItem) DisconnectExpandingDirections() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "expandingDirections")
	}
}

func (ptr *QWidgetItem) ExpandingDirections() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QWidgetItem_ExpandingDirections(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWidgetItem) ExpandingDirectionsDefault() core.Qt__Orientation {
	if ptr.Pointer() != nil {
		return core.Qt__Orientation(C.QWidgetItem_ExpandingDirectionsDefault(ptr.Pointer()))
	}
	return 0
}

//export callbackQWidgetItem_IsEmpty
func callbackQWidgetItem_IsEmpty(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isEmpty"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWidgetItemFromPointer(ptr).IsEmptyDefault())))
}

func (ptr *QWidgetItem) ConnectIsEmpty(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isEmpty"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isEmpty", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWidgetItem) DisconnectIsEmpty() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isEmpty")
	}
}

func (ptr *QWidgetItem) IsEmpty() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidgetItem_IsEmpty(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidgetItem) IsEmptyDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWidgetItem_IsEmptyDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWidgetItem) Wid() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWidgetItem_Wid(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWidgetItem) SetWid(vqw QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWidgetItem_SetWid(ptr.Pointer(), PointerFromQWidget(vqw))
	}
}

type QWizard struct {
	QDialog
}

type QWizard_ITF interface {
	QDialog_ITF
	QWizard_PTR() *QWizard
}

func (ptr *QWizard) QWizard_PTR() *QWizard {
	return ptr
}

func (ptr *QWizard) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QDialog_PTR().Pointer()
	}
	return nil
}

func (ptr *QWizard) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QDialog_PTR().SetPointer(p)
	}
}

func PointerFromQWizard(ptr QWizard_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWizard_PTR().Pointer()
	}
	return nil
}

func NewQWizardFromPointer(ptr unsafe.Pointer) (n *QWizard) {
	n = new(QWizard)
	n.SetPointer(ptr)
	return
}

//go:generate stringer -type=QWizard__WizardButton
//QWizard::WizardButton
type QWizard__WizardButton int64

const (
	QWizard__BackButton       QWizard__WizardButton = QWizard__WizardButton(0)
	QWizard__NextButton       QWizard__WizardButton = QWizard__WizardButton(1)
	QWizard__CommitButton     QWizard__WizardButton = QWizard__WizardButton(2)
	QWizard__FinishButton     QWizard__WizardButton = QWizard__WizardButton(3)
	QWizard__CancelButton     QWizard__WizardButton = QWizard__WizardButton(4)
	QWizard__HelpButton       QWizard__WizardButton = QWizard__WizardButton(5)
	QWizard__CustomButton1    QWizard__WizardButton = QWizard__WizardButton(6)
	QWizard__CustomButton2    QWizard__WizardButton = QWizard__WizardButton(7)
	QWizard__CustomButton3    QWizard__WizardButton = QWizard__WizardButton(8)
	QWizard__Stretch          QWizard__WizardButton = QWizard__WizardButton(9)
	QWizard__NoButton         QWizard__WizardButton = QWizard__WizardButton(-1)
	QWizard__NStandardButtons QWizard__WizardButton = QWizard__WizardButton(6)
	QWizard__NButtons         QWizard__WizardButton = QWizard__WizardButton(9)
)

//go:generate stringer -type=QWizard__WizardOption
//QWizard::WizardOption
type QWizard__WizardOption int64

const (
	QWizard__IndependentPages             QWizard__WizardOption = QWizard__WizardOption(0x00000001)
	QWizard__IgnoreSubTitles              QWizard__WizardOption = QWizard__WizardOption(0x00000002)
	QWizard__ExtendedWatermarkPixmap      QWizard__WizardOption = QWizard__WizardOption(0x00000004)
	QWizard__NoDefaultButton              QWizard__WizardOption = QWizard__WizardOption(0x00000008)
	QWizard__NoBackButtonOnStartPage      QWizard__WizardOption = QWizard__WizardOption(0x00000010)
	QWizard__NoBackButtonOnLastPage       QWizard__WizardOption = QWizard__WizardOption(0x00000020)
	QWizard__DisabledBackButtonOnLastPage QWizard__WizardOption = QWizard__WizardOption(0x00000040)
	QWizard__HaveNextButtonOnLastPage     QWizard__WizardOption = QWizard__WizardOption(0x00000080)
	QWizard__HaveFinishButtonOnEarlyPages QWizard__WizardOption = QWizard__WizardOption(0x00000100)
	QWizard__NoCancelButton               QWizard__WizardOption = QWizard__WizardOption(0x00000200)
	QWizard__CancelButtonOnLeft           QWizard__WizardOption = QWizard__WizardOption(0x00000400)
	QWizard__HaveHelpButton               QWizard__WizardOption = QWizard__WizardOption(0x00000800)
	QWizard__HelpButtonOnRight            QWizard__WizardOption = QWizard__WizardOption(0x00001000)
	QWizard__HaveCustomButton1            QWizard__WizardOption = QWizard__WizardOption(0x00002000)
	QWizard__HaveCustomButton2            QWizard__WizardOption = QWizard__WizardOption(0x00004000)
	QWizard__HaveCustomButton3            QWizard__WizardOption = QWizard__WizardOption(0x00008000)
	QWizard__NoCancelButtonOnLastPage     QWizard__WizardOption = QWizard__WizardOption(0x00010000)
)

//go:generate stringer -type=QWizard__WizardPixmap
//QWizard::WizardPixmap
type QWizard__WizardPixmap int64

const (
	QWizard__WatermarkPixmap  QWizard__WizardPixmap = QWizard__WizardPixmap(0)
	QWizard__LogoPixmap       QWizard__WizardPixmap = QWizard__WizardPixmap(1)
	QWizard__BannerPixmap     QWizard__WizardPixmap = QWizard__WizardPixmap(2)
	QWizard__BackgroundPixmap QWizard__WizardPixmap = QWizard__WizardPixmap(3)
	QWizard__NPixmaps         QWizard__WizardPixmap = QWizard__WizardPixmap(4)
)

//go:generate stringer -type=QWizard__WizardStyle
//QWizard::WizardStyle
type QWizard__WizardStyle int64

var (
	QWizard__ClassicStyle QWizard__WizardStyle = QWizard__WizardStyle(0)
	QWizard__ModernStyle  QWizard__WizardStyle = QWizard__WizardStyle(1)
	QWizard__MacStyle     QWizard__WizardStyle = QWizard__WizardStyle(2)
	QWizard__AeroStyle    QWizard__WizardStyle = QWizard__WizardStyle(3)
	QWizard__NStyles      QWizard__WizardStyle = QWizard__WizardStyle(4)
)

func NewQWizard(parent QWidget_ITF, flags core.Qt__WindowType) *QWizard {
	tmpValue := NewQWizardFromPointer(C.QWizard_NewQWizard(PointerFromQWidget(parent), C.longlong(flags)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQWizard_ValidateCurrentPage
func callbackQWizard_ValidateCurrentPage(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "validateCurrentPage"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWizardFromPointer(ptr).ValidateCurrentPageDefault())))
}

func (ptr *QWizard) ConnectValidateCurrentPage(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "validateCurrentPage"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "validateCurrentPage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "validateCurrentPage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectValidateCurrentPage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "validateCurrentPage")
	}
}

func (ptr *QWizard) ValidateCurrentPage() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizard_ValidateCurrentPage(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWizard) ValidateCurrentPageDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizard_ValidateCurrentPageDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWizard) AddPage(page QWizardPage_ITF) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWizard_AddPage(ptr.Pointer(), PointerFromQWizardPage(page))))
	}
	return 0
}

//export callbackQWizard_Back
func callbackQWizard_Back(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "back"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWizardFromPointer(ptr).BackDefault()
	}
}

func (ptr *QWizard) ConnectBack(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "back"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "back", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "back", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectBack() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "back")
	}
}

func (ptr *QWizard) Back() {
	if ptr.Pointer() != nil {
		C.QWizard_Back(ptr.Pointer())
	}
}

func (ptr *QWizard) BackDefault() {
	if ptr.Pointer() != nil {
		C.QWizard_BackDefault(ptr.Pointer())
	}
}

//export callbackQWizard_CleanupPage
func callbackQWizard_CleanupPage(ptr unsafe.Pointer, id C.int) {
	if signal := qt.GetSignal(ptr, "cleanupPage"); signal != nil {
		(*(*func(int))(signal))(int(int32(id)))
	} else {
		NewQWizardFromPointer(ptr).CleanupPageDefault(int(int32(id)))
	}
}

func (ptr *QWizard) ConnectCleanupPage(f func(id int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "cleanupPage"); signal != nil {
			f := func(id int) {
				(*(*func(int))(signal))(id)
				f(id)
			}
			qt.ConnectSignal(ptr.Pointer(), "cleanupPage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cleanupPage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectCleanupPage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "cleanupPage")
	}
}

func (ptr *QWizard) CleanupPage(id int) {
	if ptr.Pointer() != nil {
		C.QWizard_CleanupPage(ptr.Pointer(), C.int(int32(id)))
	}
}

func (ptr *QWizard) CleanupPageDefault(id int) {
	if ptr.Pointer() != nil {
		C.QWizard_CleanupPageDefault(ptr.Pointer(), C.int(int32(id)))
	}
}

//export callbackQWizard_CurrentIdChanged
func callbackQWizard_CurrentIdChanged(ptr unsafe.Pointer, id C.int) {
	if signal := qt.GetSignal(ptr, "currentIdChanged"); signal != nil {
		(*(*func(int))(signal))(int(int32(id)))
	}

}

func (ptr *QWizard) ConnectCurrentIdChanged(f func(id int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "currentIdChanged") {
			C.QWizard_ConnectCurrentIdChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "currentIdChanged"); signal != nil {
			f := func(id int) {
				(*(*func(int))(signal))(id)
				f(id)
			}
			qt.ConnectSignal(ptr.Pointer(), "currentIdChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "currentIdChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectCurrentIdChanged() {
	if ptr.Pointer() != nil {
		C.QWizard_DisconnectCurrentIdChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "currentIdChanged")
	}
}

func (ptr *QWizard) CurrentIdChanged(id int) {
	if ptr.Pointer() != nil {
		C.QWizard_CurrentIdChanged(ptr.Pointer(), C.int(int32(id)))
	}
}

//export callbackQWizard_CustomButtonClicked
func callbackQWizard_CustomButtonClicked(ptr unsafe.Pointer, which C.int) {
	if signal := qt.GetSignal(ptr, "customButtonClicked"); signal != nil {
		(*(*func(int))(signal))(int(int32(which)))
	}

}

func (ptr *QWizard) ConnectCustomButtonClicked(f func(which int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "customButtonClicked") {
			C.QWizard_ConnectCustomButtonClicked(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "customButtonClicked"); signal != nil {
			f := func(which int) {
				(*(*func(int))(signal))(which)
				f(which)
			}
			qt.ConnectSignal(ptr.Pointer(), "customButtonClicked", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "customButtonClicked", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectCustomButtonClicked() {
	if ptr.Pointer() != nil {
		C.QWizard_DisconnectCustomButtonClicked(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "customButtonClicked")
	}
}

func (ptr *QWizard) CustomButtonClicked(which int) {
	if ptr.Pointer() != nil {
		C.QWizard_CustomButtonClicked(ptr.Pointer(), C.int(int32(which)))
	}
}

//export callbackQWizard_Done
func callbackQWizard_Done(ptr unsafe.Pointer, result C.int) {
	if signal := qt.GetSignal(ptr, "done"); signal != nil {
		(*(*func(int))(signal))(int(int32(result)))
	} else {
		NewQWizardFromPointer(ptr).DoneDefault(int(int32(result)))
	}
}

func (ptr *QWizard) ConnectDone(f func(result int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "done"); signal != nil {
			f := func(result int) {
				(*(*func(int))(signal))(result)
				f(result)
			}
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "done", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectDone() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "done")
	}
}

func (ptr *QWizard) Done(result int) {
	if ptr.Pointer() != nil {
		C.QWizard_Done(ptr.Pointer(), C.int(int32(result)))
	}
}

func (ptr *QWizard) DoneDefault(result int) {
	if ptr.Pointer() != nil {
		C.QWizard_DoneDefault(ptr.Pointer(), C.int(int32(result)))
	}
}

//export callbackQWizard_HelpRequested
func callbackQWizard_HelpRequested(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "helpRequested"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QWizard) ConnectHelpRequested(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "helpRequested") {
			C.QWizard_ConnectHelpRequested(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "helpRequested"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "helpRequested", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "helpRequested", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectHelpRequested() {
	if ptr.Pointer() != nil {
		C.QWizard_DisconnectHelpRequested(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "helpRequested")
	}
}

func (ptr *QWizard) HelpRequested() {
	if ptr.Pointer() != nil {
		C.QWizard_HelpRequested(ptr.Pointer())
	}
}

//export callbackQWizard_InitializePage
func callbackQWizard_InitializePage(ptr unsafe.Pointer, id C.int) {
	if signal := qt.GetSignal(ptr, "initializePage"); signal != nil {
		(*(*func(int))(signal))(int(int32(id)))
	} else {
		NewQWizardFromPointer(ptr).InitializePageDefault(int(int32(id)))
	}
}

func (ptr *QWizard) ConnectInitializePage(f func(id int)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "initializePage"); signal != nil {
			f := func(id int) {
				(*(*func(int))(signal))(id)
				f(id)
			}
			qt.ConnectSignal(ptr.Pointer(), "initializePage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "initializePage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectInitializePage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "initializePage")
	}
}

func (ptr *QWizard) InitializePage(id int) {
	if ptr.Pointer() != nil {
		C.QWizard_InitializePage(ptr.Pointer(), C.int(int32(id)))
	}
}

func (ptr *QWizard) InitializePageDefault(id int) {
	if ptr.Pointer() != nil {
		C.QWizard_InitializePageDefault(ptr.Pointer(), C.int(int32(id)))
	}
}

//export callbackQWizard_Next
func callbackQWizard_Next(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "next"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWizardFromPointer(ptr).NextDefault()
	}
}

func (ptr *QWizard) ConnectNext(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "next"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "next", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "next", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectNext() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "next")
	}
}

func (ptr *QWizard) Next() {
	if ptr.Pointer() != nil {
		C.QWizard_Next(ptr.Pointer())
	}
}

func (ptr *QWizard) NextDefault() {
	if ptr.Pointer() != nil {
		C.QWizard_NextDefault(ptr.Pointer())
	}
}

//export callbackQWizard_PageAdded
func callbackQWizard_PageAdded(ptr unsafe.Pointer, id C.int) {
	if signal := qt.GetSignal(ptr, "pageAdded"); signal != nil {
		(*(*func(int))(signal))(int(int32(id)))
	}

}

func (ptr *QWizard) ConnectPageAdded(f func(id int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "pageAdded") {
			C.QWizard_ConnectPageAdded(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "pageAdded"); signal != nil {
			f := func(id int) {
				(*(*func(int))(signal))(id)
				f(id)
			}
			qt.ConnectSignal(ptr.Pointer(), "pageAdded", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "pageAdded", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectPageAdded() {
	if ptr.Pointer() != nil {
		C.QWizard_DisconnectPageAdded(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "pageAdded")
	}
}

func (ptr *QWizard) PageAdded(id int) {
	if ptr.Pointer() != nil {
		C.QWizard_PageAdded(ptr.Pointer(), C.int(int32(id)))
	}
}

//export callbackQWizard_PageRemoved
func callbackQWizard_PageRemoved(ptr unsafe.Pointer, id C.int) {
	if signal := qt.GetSignal(ptr, "pageRemoved"); signal != nil {
		(*(*func(int))(signal))(int(int32(id)))
	}

}

func (ptr *QWizard) ConnectPageRemoved(f func(id int)) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "pageRemoved") {
			C.QWizard_ConnectPageRemoved(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "pageRemoved"); signal != nil {
			f := func(id int) {
				(*(*func(int))(signal))(id)
				f(id)
			}
			qt.ConnectSignal(ptr.Pointer(), "pageRemoved", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "pageRemoved", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectPageRemoved() {
	if ptr.Pointer() != nil {
		C.QWizard_DisconnectPageRemoved(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "pageRemoved")
	}
}

func (ptr *QWizard) PageRemoved(id int) {
	if ptr.Pointer() != nil {
		C.QWizard_PageRemoved(ptr.Pointer(), C.int(int32(id)))
	}
}

func (ptr *QWizard) RemovePage(id int) {
	if ptr.Pointer() != nil {
		C.QWizard_RemovePage(ptr.Pointer(), C.int(int32(id)))
	}
}

//export callbackQWizard_Restart
func callbackQWizard_Restart(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "restart"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWizardFromPointer(ptr).RestartDefault()
	}
}

func (ptr *QWizard) ConnectRestart(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "restart"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "restart", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "restart", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectRestart() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "restart")
	}
}

func (ptr *QWizard) Restart() {
	if ptr.Pointer() != nil {
		C.QWizard_Restart(ptr.Pointer())
	}
}

func (ptr *QWizard) RestartDefault() {
	if ptr.Pointer() != nil {
		C.QWizard_RestartDefault(ptr.Pointer())
	}
}

func (ptr *QWizard) SetButton(which QWizard__WizardButton, button QAbstractButton_ITF) {
	if ptr.Pointer() != nil {
		C.QWizard_SetButton(ptr.Pointer(), C.longlong(which), PointerFromQAbstractButton(button))
	}
}

func (ptr *QWizard) SetButtonText(which QWizard__WizardButton, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QWizard_SetButtonText(ptr.Pointer(), C.longlong(which), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QWizard) SetDefaultProperty(className string, property string, changedSignal string) {
	if ptr.Pointer() != nil {
		var classNameC *C.char
		if className != "" {
			classNameC = C.CString(className)
			defer C.free(unsafe.Pointer(classNameC))
		}
		var propertyC *C.char
		if property != "" {
			propertyC = C.CString(property)
			defer C.free(unsafe.Pointer(propertyC))
		}
		var changedSignalC *C.char
		if changedSignal != "" {
			changedSignalC = C.CString(changedSignal)
			defer C.free(unsafe.Pointer(changedSignalC))
		}
		C.QWizard_SetDefaultProperty(ptr.Pointer(), classNameC, propertyC, changedSignalC)
	}
}

func (ptr *QWizard) SetField(name string, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QWizard_SetField(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQVariant(value))
	}
}

func (ptr *QWizard) SetOption(option QWizard__WizardOption, on bool) {
	if ptr.Pointer() != nil {
		C.QWizard_SetOption(ptr.Pointer(), C.longlong(option), C.char(int8(qt.GoBoolToInt(on))))
	}
}

func (ptr *QWizard) SetOptions(options QWizard__WizardOption) {
	if ptr.Pointer() != nil {
		C.QWizard_SetOptions(ptr.Pointer(), C.longlong(options))
	}
}

func (ptr *QWizard) SetPage(id int, page QWizardPage_ITF) {
	if ptr.Pointer() != nil {
		C.QWizard_SetPage(ptr.Pointer(), C.int(int32(id)), PointerFromQWizardPage(page))
	}
}

func (ptr *QWizard) SetPixmap(which QWizard__WizardPixmap, pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QWizard_SetPixmap(ptr.Pointer(), C.longlong(which), gui.PointerFromQPixmap(pixmap))
	}
}

func (ptr *QWizard) SetSideWidget(widget QWidget_ITF) {
	if ptr.Pointer() != nil {
		C.QWizard_SetSideWidget(ptr.Pointer(), PointerFromQWidget(widget))
	}
}

func (ptr *QWizard) SetStartId(id int) {
	if ptr.Pointer() != nil {
		C.QWizard_SetStartId(ptr.Pointer(), C.int(int32(id)))
	}
}

func (ptr *QWizard) SetSubTitleFormat(format core.Qt__TextFormat) {
	if ptr.Pointer() != nil {
		C.QWizard_SetSubTitleFormat(ptr.Pointer(), C.longlong(format))
	}
}

func (ptr *QWizard) SetTitleFormat(format core.Qt__TextFormat) {
	if ptr.Pointer() != nil {
		C.QWizard_SetTitleFormat(ptr.Pointer(), C.longlong(format))
	}
}

func (ptr *QWizard) SetWizardStyle(style QWizard__WizardStyle) {
	if ptr.Pointer() != nil {
		C.QWizard_SetWizardStyle(ptr.Pointer(), C.longlong(style))
	}
}

//export callbackQWizard_DestroyQWizard
func callbackQWizard_DestroyQWizard(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QWizard"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWizardFromPointer(ptr).DestroyQWizardDefault()
	}
}

func (ptr *QWizard) ConnectDestroyQWizard(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QWizard"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QWizard", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QWizard", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectDestroyQWizard() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QWizard")
	}
}

func (ptr *QWizard) DestroyQWizard() {
	if ptr.Pointer() != nil {
		C.QWizard_DestroyQWizard(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWizard) DestroyQWizardDefault() {
	if ptr.Pointer() != nil {
		C.QWizard_DestroyQWizardDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWizard) Button(which QWizard__WizardButton) *QAbstractButton {
	if ptr.Pointer() != nil {
		tmpValue := NewQAbstractButtonFromPointer(C.QWizard_Button(ptr.Pointer(), C.longlong(which)))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWizard) PageIds() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQWizardFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__pageIds_atList(i)
			}
			return out
		}(C.QWizard_PageIds(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QWizard) VisitedPages() []int {
	if ptr.Pointer() != nil {
		return func(l C.struct_QtWidgets_PackedList) []int {
			out := make([]int, int(l.len))
			tmpList := NewQWizardFromPointer(l.data)
			for i := 0; i < len(out); i++ {
				out[i] = tmpList.__visitedPages_atList(i)
			}
			return out
		}(C.QWizard_VisitedPages(ptr.Pointer()))
	}
	return make([]int, 0)
}

func (ptr *QWizard) Pixmap(which QWizard__WizardPixmap) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QWizard_Pixmap(ptr.Pointer(), C.longlong(which)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func (ptr *QWizard) ButtonText(which QWizard__WizardButton) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWizard_ButtonText(ptr.Pointer(), C.longlong(which)))
	}
	return ""
}

func (ptr *QWizard) Field(name string) *core.QVariant {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		tmpValue := core.NewQVariantFromPointer(C.QWizard_Field(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))}))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QWizard) SideWidget() *QWidget {
	if ptr.Pointer() != nil {
		tmpValue := NewQWidgetFromPointer(C.QWizard_SideWidget(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWizard) Options() QWizard__WizardOption {
	if ptr.Pointer() != nil {
		return QWizard__WizardOption(C.QWizard_Options(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWizard) WizardStyle() QWizard__WizardStyle {
	if ptr.Pointer() != nil {
		return QWizard__WizardStyle(C.QWizard_WizardStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWizard) CurrentPage() *QWizardPage {
	if ptr.Pointer() != nil {
		tmpValue := NewQWizardPageFromPointer(C.QWizard_CurrentPage(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWizard) Page(id int) *QWizardPage {
	if ptr.Pointer() != nil {
		tmpValue := NewQWizardPageFromPointer(C.QWizard_Page(ptr.Pointer(), C.int(int32(id))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWizard) SubTitleFormat() core.Qt__TextFormat {
	if ptr.Pointer() != nil {
		return core.Qt__TextFormat(C.QWizard_SubTitleFormat(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWizard) TitleFormat() core.Qt__TextFormat {
	if ptr.Pointer() != nil {
		return core.Qt__TextFormat(C.QWizard_TitleFormat(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWizard) HasVisitedPage(id int) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizard_HasVisitedPage(ptr.Pointer(), C.int(int32(id)))) != 0
	}
	return false
}

func (ptr *QWizard) TestOption(option QWizard__WizardOption) bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizard_TestOption(ptr.Pointer(), C.longlong(option))) != 0
	}
	return false
}

func (ptr *QWizard) CurrentId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWizard_CurrentId(ptr.Pointer())))
	}
	return 0
}

//export callbackQWizard_NextId
func callbackQWizard_NextId(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "nextId"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQWizardFromPointer(ptr).NextIdDefault()))
}

func (ptr *QWizard) ConnectNextId(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "nextId"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "nextId", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "nextId", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizard) DisconnectNextId() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "nextId")
	}
}

func (ptr *QWizard) NextId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWizard_NextId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWizard) NextIdDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWizard_NextIdDefault(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWizard) StartId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWizard_StartId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWizard) __pageIds_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWizard___pageIds_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QWizard) __pageIds_setList(i int) {
	if ptr.Pointer() != nil {
		C.QWizard___pageIds_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QWizard) __pageIds_newList() unsafe.Pointer {
	return C.QWizard___pageIds_newList(ptr.Pointer())
}

func (ptr *QWizard) __visitedPages_atList(i int) int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWizard___visitedPages_atList(ptr.Pointer(), C.int(int32(i)))))
	}
	return 0
}

func (ptr *QWizard) __visitedPages_setList(i int) {
	if ptr.Pointer() != nil {
		C.QWizard___visitedPages_setList(ptr.Pointer(), C.int(int32(i)))
	}
}

func (ptr *QWizard) __visitedPages_newList() unsafe.Pointer {
	return C.QWizard___visitedPages_newList(ptr.Pointer())
}

type QWizardPage struct {
	QWidget
}

type QWizardPage_ITF interface {
	QWidget_ITF
	QWizardPage_PTR() *QWizardPage
}

func (ptr *QWizardPage) QWizardPage_PTR() *QWizardPage {
	return ptr
}

func (ptr *QWizardPage) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QWidget_PTR().Pointer()
	}
	return nil
}

func (ptr *QWizardPage) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QWidget_PTR().SetPointer(p)
	}
}

func PointerFromQWizardPage(ptr QWizardPage_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWizardPage_PTR().Pointer()
	}
	return nil
}

func NewQWizardPageFromPointer(ptr unsafe.Pointer) (n *QWizardPage) {
	n = new(QWizardPage)
	n.SetPointer(ptr)
	return
}
func NewQWizardPage(parent QWidget_ITF) *QWizardPage {
	tmpValue := NewQWizardPageFromPointer(C.QWizardPage_NewQWizardPage(PointerFromQWidget(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackQWizardPage_ValidatePage
func callbackQWizardPage_ValidatePage(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "validatePage"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWizardPageFromPointer(ptr).ValidatePageDefault())))
}

func (ptr *QWizardPage) ConnectValidatePage(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "validatePage"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "validatePage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "validatePage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizardPage) DisconnectValidatePage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "validatePage")
	}
}

func (ptr *QWizardPage) ValidatePage() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizardPage_ValidatePage(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWizardPage) ValidatePageDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizardPage_ValidatePageDefault(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQWizardPage_CleanupPage
func callbackQWizardPage_CleanupPage(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "cleanupPage"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWizardPageFromPointer(ptr).CleanupPageDefault()
	}
}

func (ptr *QWizardPage) ConnectCleanupPage(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "cleanupPage"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "cleanupPage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "cleanupPage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizardPage) DisconnectCleanupPage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "cleanupPage")
	}
}

func (ptr *QWizardPage) CleanupPage() {
	if ptr.Pointer() != nil {
		C.QWizardPage_CleanupPage(ptr.Pointer())
	}
}

func (ptr *QWizardPage) CleanupPageDefault() {
	if ptr.Pointer() != nil {
		C.QWizardPage_CleanupPageDefault(ptr.Pointer())
	}
}

//export callbackQWizardPage_CompleteChanged
func callbackQWizardPage_CompleteChanged(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "completeChanged"); signal != nil {
		(*(*func())(signal))()
	}

}

func (ptr *QWizardPage) ConnectCompleteChanged(f func()) {
	if ptr.Pointer() != nil {

		if !qt.ExistsSignal(ptr.Pointer(), "completeChanged") {
			C.QWizardPage_ConnectCompleteChanged(ptr.Pointer())
		}

		if signal := qt.LendSignal(ptr.Pointer(), "completeChanged"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "completeChanged", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "completeChanged", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizardPage) DisconnectCompleteChanged() {
	if ptr.Pointer() != nil {
		C.QWizardPage_DisconnectCompleteChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.Pointer(), "completeChanged")
	}
}

func (ptr *QWizardPage) CompleteChanged() {
	if ptr.Pointer() != nil {
		C.QWizardPage_CompleteChanged(ptr.Pointer())
	}
}

//export callbackQWizardPage_InitializePage
func callbackQWizardPage_InitializePage(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "initializePage"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWizardPageFromPointer(ptr).InitializePageDefault()
	}
}

func (ptr *QWizardPage) ConnectInitializePage(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "initializePage"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "initializePage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "initializePage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizardPage) DisconnectInitializePage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "initializePage")
	}
}

func (ptr *QWizardPage) InitializePage() {
	if ptr.Pointer() != nil {
		C.QWizardPage_InitializePage(ptr.Pointer())
	}
}

func (ptr *QWizardPage) InitializePageDefault() {
	if ptr.Pointer() != nil {
		C.QWizardPage_InitializePageDefault(ptr.Pointer())
	}
}

func (ptr *QWizardPage) RegisterField(name string, widget QWidget_ITF, property string, changedSignal string) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		var propertyC *C.char
		if property != "" {
			propertyC = C.CString(property)
			defer C.free(unsafe.Pointer(propertyC))
		}
		var changedSignalC *C.char
		if changedSignal != "" {
			changedSignalC = C.CString(changedSignal)
			defer C.free(unsafe.Pointer(changedSignalC))
		}
		C.QWizardPage_RegisterField(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQWidget(widget), propertyC, changedSignalC)
	}
}

func (ptr *QWizardPage) SetButtonText(which QWizard__WizardButton, text string) {
	if ptr.Pointer() != nil {
		var textC *C.char
		if text != "" {
			textC = C.CString(text)
			defer C.free(unsafe.Pointer(textC))
		}
		C.QWizardPage_SetButtonText(ptr.Pointer(), C.longlong(which), C.struct_QtWidgets_PackedString{data: textC, len: C.longlong(len(text))})
	}
}

func (ptr *QWizardPage) SetCommitPage(commitPage bool) {
	if ptr.Pointer() != nil {
		C.QWizardPage_SetCommitPage(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(commitPage))))
	}
}

func (ptr *QWizardPage) SetField(name string, value core.QVariant_ITF) {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		C.QWizardPage_SetField(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQVariant(value))
	}
}

func (ptr *QWizardPage) SetFinalPage(finalPage bool) {
	if ptr.Pointer() != nil {
		C.QWizardPage_SetFinalPage(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(finalPage))))
	}
}

func (ptr *QWizardPage) SetPixmap(which QWizard__WizardPixmap, pixmap gui.QPixmap_ITF) {
	if ptr.Pointer() != nil {
		C.QWizardPage_SetPixmap(ptr.Pointer(), C.longlong(which), gui.PointerFromQPixmap(pixmap))
	}
}

func (ptr *QWizardPage) SetSubTitle(subTitle string) {
	if ptr.Pointer() != nil {
		var subTitleC *C.char
		if subTitle != "" {
			subTitleC = C.CString(subTitle)
			defer C.free(unsafe.Pointer(subTitleC))
		}
		C.QWizardPage_SetSubTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: subTitleC, len: C.longlong(len(subTitle))})
	}
}

func (ptr *QWizardPage) SetTitle(title string) {
	if ptr.Pointer() != nil {
		var titleC *C.char
		if title != "" {
			titleC = C.CString(title)
			defer C.free(unsafe.Pointer(titleC))
		}
		C.QWizardPage_SetTitle(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: titleC, len: C.longlong(len(title))})
	}
}

//export callbackQWizardPage_DestroyQWizardPage
func callbackQWizardPage_DestroyQWizardPage(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~QWizardPage"); signal != nil {
		(*(*func())(signal))()
	} else {
		NewQWizardPageFromPointer(ptr).DestroyQWizardPageDefault()
	}
}

func (ptr *QWizardPage) ConnectDestroyQWizardPage(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~QWizardPage"); signal != nil {
			f := func() {
				(*(*func())(signal))()
				f()
			}
			qt.ConnectSignal(ptr.Pointer(), "~QWizardPage", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~QWizardPage", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizardPage) DisconnectDestroyQWizardPage() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~QWizardPage")
	}
}

func (ptr *QWizardPage) DestroyQWizardPage() {
	if ptr.Pointer() != nil {
		C.QWizardPage_DestroyQWizardPage(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWizardPage) DestroyQWizardPageDefault() {
	if ptr.Pointer() != nil {
		C.QWizardPage_DestroyQWizardPageDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *QWizardPage) Pixmap(which QWizard__WizardPixmap) *gui.QPixmap {
	if ptr.Pointer() != nil {
		tmpValue := gui.NewQPixmapFromPointer(C.QWizardPage_Pixmap(ptr.Pointer(), C.longlong(which)))
		runtime.SetFinalizer(tmpValue, (*gui.QPixmap).DestroyQPixmap)
		return tmpValue
	}
	return nil
}

func (ptr *QWizardPage) ButtonText(which QWizard__WizardButton) string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWizardPage_ButtonText(ptr.Pointer(), C.longlong(which)))
	}
	return ""
}

func (ptr *QWizardPage) SubTitle() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWizardPage_SubTitle(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWizardPage) Title() string {
	if ptr.Pointer() != nil {
		return cGoUnpackString(C.QWizardPage_Title(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWizardPage) Field(name string) *core.QVariant {
	if ptr.Pointer() != nil {
		var nameC *C.char
		if name != "" {
			nameC = C.CString(name)
			defer C.free(unsafe.Pointer(nameC))
		}
		tmpValue := core.NewQVariantFromPointer(C.QWizardPage_Field(ptr.Pointer(), C.struct_QtWidgets_PackedString{data: nameC, len: C.longlong(len(name))}))
		runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
		return tmpValue
	}
	return nil
}

func (ptr *QWizardPage) Wizard() *QWizard {
	if ptr.Pointer() != nil {
		tmpValue := NewQWizardFromPointer(C.QWizardPage_Wizard(ptr.Pointer()))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *QWizardPage) IsCommitPage() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizardPage_IsCommitPage(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQWizardPage_IsComplete
func callbackQWizardPage_IsComplete(ptr unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "isComplete"); signal != nil {
		return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
	}

	return C.char(int8(qt.GoBoolToInt(NewQWizardPageFromPointer(ptr).IsCompleteDefault())))
}

func (ptr *QWizardPage) ConnectIsComplete(f func() bool) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "isComplete"); signal != nil {
			f := func() bool {
				(*(*func() bool)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "isComplete", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "isComplete", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizardPage) DisconnectIsComplete() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "isComplete")
	}
}

func (ptr *QWizardPage) IsComplete() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizardPage_IsComplete(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWizardPage) IsCompleteDefault() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizardPage_IsCompleteDefault(ptr.Pointer())) != 0
	}
	return false
}

func (ptr *QWizardPage) IsFinalPage() bool {
	if ptr.Pointer() != nil {
		return int8(C.QWizardPage_IsFinalPage(ptr.Pointer())) != 0
	}
	return false
}

//export callbackQWizardPage_NextId
func callbackQWizardPage_NextId(ptr unsafe.Pointer) C.int {
	if signal := qt.GetSignal(ptr, "nextId"); signal != nil {
		return C.int(int32((*(*func() int)(signal))()))
	}

	return C.int(int32(NewQWizardPageFromPointer(ptr).NextIdDefault()))
}

func (ptr *QWizardPage) ConnectNextId(f func() int) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "nextId"); signal != nil {
			f := func() int {
				(*(*func() int)(signal))()
				return f()
			}
			qt.ConnectSignal(ptr.Pointer(), "nextId", unsafe.Pointer(&f))
		} else {
			qt.ConnectSignal(ptr.Pointer(), "nextId", unsafe.Pointer(&f))
		}
	}
}

func (ptr *QWizardPage) DisconnectNextId() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "nextId")
	}
}

func (ptr *QWizardPage) NextId() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWizardPage_NextId(ptr.Pointer())))
	}
	return 0
}

func (ptr *QWizardPage) NextIdDefault() int {
	if ptr.Pointer() != nil {
		return int(int32(C.QWizardPage_NextIdDefault(ptr.Pointer())))
	}
	return 0
}