package gui

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

type QAbstractOpenGLFunctions struct {
	ptr unsafe.Pointer
}

type QAbstractOpenGLFunctions_ITF interface {
	QAbstractOpenGLFunctions_PTR() *QAbstractOpenGLFunctions
}

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

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

func PointerFromQAbstractOpenGLFunctions(ptr QAbstractOpenGLFunctions_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractOpenGLFunctions_PTR().Pointer()
	}
	return nil
}

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

func newQAbstractOpenGLFunctionsFromPointer(ptr unsafe.Pointer) *QAbstractOpenGLFunctions {
	var n = NewQAbstractOpenGLFunctionsFromPointer(ptr)
	return n
}

func (ptr *QAbstractOpenGLFunctions) QAbstractOpenGLFunctions_PTR() *QAbstractOpenGLFunctions {
	return ptr
}

type QAbstractTextDocumentLayout struct {
	core.QObject
}

type QAbstractTextDocumentLayout_ITF interface {
	core.QObject_ITF
	QAbstractTextDocumentLayout_PTR() *QAbstractTextDocumentLayout
}

func PointerFromQAbstractTextDocumentLayout(ptr QAbstractTextDocumentLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAbstractTextDocumentLayout_PTR().Pointer()
	}
	return nil
}

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

func newQAbstractTextDocumentLayoutFromPointer(ptr unsafe.Pointer) *QAbstractTextDocumentLayout {
	var n = NewQAbstractTextDocumentLayoutFromPointer(ptr)
	for len(n.ObjectName()) < len("QAbstractTextDocumentLayout_") {
		n.SetObjectName("QAbstractTextDocumentLayout_" + qt.Identifier())
	}
	return n
}

func (ptr *QAbstractTextDocumentLayout) QAbstractTextDocumentLayout_PTR() *QAbstractTextDocumentLayout {
	return ptr
}

func (ptr *QAbstractTextDocumentLayout) AnchorAt(position core.QPointF_ITF) string {
	defer qt.Recovering("QAbstractTextDocumentLayout::anchorAt")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAbstractTextDocumentLayout_AnchorAt(ptr.Pointer(), core.PointerFromQPointF(position)))
	}
	return ""
}

func (ptr *QAbstractTextDocumentLayout) Document() *QTextDocument {
	defer qt.Recovering("QAbstractTextDocumentLayout::document")

	if ptr.Pointer() != nil {
		return NewQTextDocumentFromPointer(C.QAbstractTextDocumentLayout_Document(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAbstractTextDocumentLayout) HandlerForObject(objectType int) *QTextObjectInterface {
	defer qt.Recovering("QAbstractTextDocumentLayout::handlerForObject")

	if ptr.Pointer() != nil {
		return NewQTextObjectInterfaceFromPointer(C.QAbstractTextDocumentLayout_HandlerForObject(ptr.Pointer(), C.int(objectType)))
	}
	return nil
}

func (ptr *QAbstractTextDocumentLayout) PageCount() int {
	defer qt.Recovering("QAbstractTextDocumentLayout::pageCount")

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

func (ptr *QAbstractTextDocumentLayout) ConnectPageCountChanged(f func(newPages int)) {
	defer qt.Recovering("connect QAbstractTextDocumentLayout::pageCountChanged")

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

func (ptr *QAbstractTextDocumentLayout) DisconnectPageCountChanged() {
	defer qt.Recovering("disconnect QAbstractTextDocumentLayout::pageCountChanged")

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

//export callbackQAbstractTextDocumentLayoutPageCountChanged
func callbackQAbstractTextDocumentLayoutPageCountChanged(ptr unsafe.Pointer, ptrName *C.char, newPages C.int) {
	defer qt.Recovering("callback QAbstractTextDocumentLayout::pageCountChanged")

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

}

func (ptr *QAbstractTextDocumentLayout) PageCountChanged(newPages int) {
	defer qt.Recovering("QAbstractTextDocumentLayout::pageCountChanged")

	if ptr.Pointer() != nil {
		C.QAbstractTextDocumentLayout_PageCountChanged(ptr.Pointer(), C.int(newPages))
	}
}

func (ptr *QAbstractTextDocumentLayout) PaintDevice() *QPaintDevice {
	defer qt.Recovering("QAbstractTextDocumentLayout::paintDevice")

	if ptr.Pointer() != nil {
		return NewQPaintDeviceFromPointer(C.QAbstractTextDocumentLayout_PaintDevice(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAbstractTextDocumentLayout) RegisterHandler(objectType int, component core.QObject_ITF) {
	defer qt.Recovering("QAbstractTextDocumentLayout::registerHandler")

	if ptr.Pointer() != nil {
		C.QAbstractTextDocumentLayout_RegisterHandler(ptr.Pointer(), C.int(objectType), core.PointerFromQObject(component))
	}
}

func (ptr *QAbstractTextDocumentLayout) SetPaintDevice(device QPaintDevice_ITF) {
	defer qt.Recovering("QAbstractTextDocumentLayout::setPaintDevice")

	if ptr.Pointer() != nil {
		C.QAbstractTextDocumentLayout_SetPaintDevice(ptr.Pointer(), PointerFromQPaintDevice(device))
	}
}

func (ptr *QAbstractTextDocumentLayout) UnregisterHandler(objectType int, component core.QObject_ITF) {
	defer qt.Recovering("QAbstractTextDocumentLayout::unregisterHandler")

	if ptr.Pointer() != nil {
		C.QAbstractTextDocumentLayout_UnregisterHandler(ptr.Pointer(), C.int(objectType), core.PointerFromQObject(component))
	}
}

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

type QAccessible struct {
	ptr unsafe.Pointer
}

type QAccessible_ITF interface {
	QAccessible_PTR() *QAccessible
}

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

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

func PointerFromQAccessible(ptr QAccessible_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessible_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleFromPointer(ptr unsafe.Pointer) *QAccessible {
	var n = NewQAccessibleFromPointer(ptr)
	return n
}

func (ptr *QAccessible) QAccessible_PTR() *QAccessible {
	return ptr
}

//QAccessible::Event
type QAccessible__Event int64

var (
	QAccessible__SoundPlayed                     = QAccessible__Event(0x0001)
	QAccessible__Alert                           = QAccessible__Event(0x0002)
	QAccessible__ForegroundChanged               = QAccessible__Event(0x0003)
	QAccessible__MenuStart                       = QAccessible__Event(0x0004)
	QAccessible__MenuEnd                         = QAccessible__Event(0x0005)
	QAccessible__PopupMenuStart                  = QAccessible__Event(0x0006)
	QAccessible__PopupMenuEnd                    = QAccessible__Event(0x0007)
	QAccessible__ContextHelpStart                = QAccessible__Event(0x000C)
	QAccessible__ContextHelpEnd                  = QAccessible__Event(0x000D)
	QAccessible__DragDropStart                   = QAccessible__Event(0x000E)
	QAccessible__DragDropEnd                     = QAccessible__Event(0x000F)
	QAccessible__DialogStart                     = QAccessible__Event(0x0010)
	QAccessible__DialogEnd                       = QAccessible__Event(0x0011)
	QAccessible__ScrollingStart                  = QAccessible__Event(0x0012)
	QAccessible__ScrollingEnd                    = QAccessible__Event(0x0013)
	QAccessible__MenuCommand                     = QAccessible__Event(0x0018)
	QAccessible__ActionChanged                   = QAccessible__Event(0x0101)
	QAccessible__ActiveDescendantChanged         = QAccessible__Event(0x0102)
	QAccessible__AttributeChanged                = QAccessible__Event(0x0103)
	QAccessible__DocumentContentChanged          = QAccessible__Event(0x0104)
	QAccessible__DocumentLoadComplete            = QAccessible__Event(0x0105)
	QAccessible__DocumentLoadStopped             = QAccessible__Event(0x0106)
	QAccessible__DocumentReload                  = QAccessible__Event(0x0107)
	QAccessible__HyperlinkEndIndexChanged        = QAccessible__Event(0x0108)
	QAccessible__HyperlinkNumberOfAnchorsChanged = QAccessible__Event(0x0109)
	QAccessible__HyperlinkSelectedLinkChanged    = QAccessible__Event(0x010A)
	QAccessible__HypertextLinkActivated          = QAccessible__Event(0x010B)
	QAccessible__HypertextLinkSelected           = QAccessible__Event(0x010C)
	QAccessible__HyperlinkStartIndexChanged      = QAccessible__Event(0x010D)
	QAccessible__HypertextChanged                = QAccessible__Event(0x010E)
	QAccessible__HypertextNLinksChanged          = QAccessible__Event(0x010F)
	QAccessible__ObjectAttributeChanged          = QAccessible__Event(0x0110)
	QAccessible__PageChanged                     = QAccessible__Event(0x0111)
	QAccessible__SectionChanged                  = QAccessible__Event(0x0112)
	QAccessible__TableCaptionChanged             = QAccessible__Event(0x0113)
	QAccessible__TableColumnDescriptionChanged   = QAccessible__Event(0x0114)
	QAccessible__TableColumnHeaderChanged        = QAccessible__Event(0x0115)
	QAccessible__TableModelChanged               = QAccessible__Event(0x0116)
	QAccessible__TableRowDescriptionChanged      = QAccessible__Event(0x0117)
	QAccessible__TableRowHeaderChanged           = QAccessible__Event(0x0118)
	QAccessible__TableSummaryChanged             = QAccessible__Event(0x0119)
	QAccessible__TextAttributeChanged            = QAccessible__Event(0x011A)
	QAccessible__TextCaretMoved                  = QAccessible__Event(0x011B)
	QAccessible__TextColumnChanged               = QAccessible__Event(0x011D)
	QAccessible__TextInserted                    = QAccessible__Event(0x011E)
	QAccessible__TextRemoved                     = QAccessible__Event(0x011F)
	QAccessible__TextUpdated                     = QAccessible__Event(0x0120)
	QAccessible__TextSelectionChanged            = QAccessible__Event(0x0121)
	QAccessible__VisibleDataChanged              = QAccessible__Event(0x0122)
	QAccessible__ObjectCreated                   = QAccessible__Event(0x8000)
	QAccessible__ObjectDestroyed                 = QAccessible__Event(0x8001)
	QAccessible__ObjectShow                      = QAccessible__Event(0x8002)
	QAccessible__ObjectHide                      = QAccessible__Event(0x8003)
	QAccessible__ObjectReorder                   = QAccessible__Event(0x8004)
	QAccessible__Focus                           = QAccessible__Event(0x8005)
	QAccessible__Selection                       = QAccessible__Event(0x8006)
	QAccessible__SelectionAdd                    = QAccessible__Event(0x8007)
	QAccessible__SelectionRemove                 = QAccessible__Event(0x8008)
	QAccessible__SelectionWithin                 = QAccessible__Event(0x8009)
	QAccessible__StateChanged                    = QAccessible__Event(0x800A)
	QAccessible__LocationChanged                 = QAccessible__Event(0x800B)
	QAccessible__NameChanged                     = QAccessible__Event(0x800C)
	QAccessible__DescriptionChanged              = QAccessible__Event(0x800D)
	QAccessible__ValueChanged                    = QAccessible__Event(0x800E)
	QAccessible__ParentChanged                   = QAccessible__Event(0x800F)
	QAccessible__HelpChanged                     = QAccessible__Event(0x80A0)
	QAccessible__DefaultActionChanged            = QAccessible__Event(0x80B0)
	QAccessible__AcceleratorChanged              = QAccessible__Event(0x80C0)
	QAccessible__InvalidEvent                    = QAccessible__Event(C.QAccessible_InvalidEvent_Type())
)

//QAccessible::InterfaceType
type QAccessible__InterfaceType int64

const (
	QAccessible__TextInterface         = QAccessible__InterfaceType(0)
	QAccessible__EditableTextInterface = QAccessible__InterfaceType(1)
	QAccessible__ValueInterface        = QAccessible__InterfaceType(2)
	QAccessible__ActionInterface       = QAccessible__InterfaceType(3)
	QAccessible__ImageInterface        = QAccessible__InterfaceType(4)
	QAccessible__TableInterface        = QAccessible__InterfaceType(5)
	QAccessible__TableCellInterface    = QAccessible__InterfaceType(6)
)

//QAccessible::RelationFlag
type QAccessible__RelationFlag int64

const (
	QAccessible__Label        = QAccessible__RelationFlag(0x00000001)
	QAccessible__Labelled     = QAccessible__RelationFlag(0x00000002)
	QAccessible__Controller   = QAccessible__RelationFlag(0x00000004)
	QAccessible__Controlled   = QAccessible__RelationFlag(0x00000008)
	QAccessible__AllRelations = QAccessible__RelationFlag(0xffffffff)
)

//QAccessible::Role
type QAccessible__Role int64

const (
	QAccessible__NoRole               = QAccessible__Role(0x00000000)
	QAccessible__TitleBar             = QAccessible__Role(0x00000001)
	QAccessible__MenuBar              = QAccessible__Role(0x00000002)
	QAccessible__ScrollBar            = QAccessible__Role(0x00000003)
	QAccessible__Grip                 = QAccessible__Role(0x00000004)
	QAccessible__Sound                = QAccessible__Role(0x00000005)
	QAccessible__Cursor               = QAccessible__Role(0x00000006)
	QAccessible__Caret                = QAccessible__Role(0x00000007)
	QAccessible__AlertMessage         = QAccessible__Role(0x00000008)
	QAccessible__Window               = QAccessible__Role(0x00000009)
	QAccessible__Client               = QAccessible__Role(0x0000000A)
	QAccessible__PopupMenu            = QAccessible__Role(0x0000000B)
	QAccessible__MenuItem             = QAccessible__Role(0x0000000C)
	QAccessible__ToolTip              = QAccessible__Role(0x0000000D)
	QAccessible__Application          = QAccessible__Role(0x0000000E)
	QAccessible__Document             = QAccessible__Role(0x0000000F)
	QAccessible__Pane                 = QAccessible__Role(0x00000010)
	QAccessible__Chart                = QAccessible__Role(0x00000011)
	QAccessible__Dialog               = QAccessible__Role(0x00000012)
	QAccessible__Border               = QAccessible__Role(0x00000013)
	QAccessible__Grouping             = QAccessible__Role(0x00000014)
	QAccessible__Separator            = QAccessible__Role(0x00000015)
	QAccessible__ToolBar              = QAccessible__Role(0x00000016)
	QAccessible__StatusBar            = QAccessible__Role(0x00000017)
	QAccessible__Table                = QAccessible__Role(0x00000018)
	QAccessible__ColumnHeader         = QAccessible__Role(0x00000019)
	QAccessible__RowHeader            = QAccessible__Role(0x0000001A)
	QAccessible__Column               = QAccessible__Role(0x0000001B)
	QAccessible__Row                  = QAccessible__Role(0x0000001C)
	QAccessible__Cell                 = QAccessible__Role(0x0000001D)
	QAccessible__Link                 = QAccessible__Role(0x0000001E)
	QAccessible__HelpBalloon          = QAccessible__Role(0x0000001F)
	QAccessible__Assistant            = QAccessible__Role(0x00000020)
	QAccessible__List                 = QAccessible__Role(0x00000021)
	QAccessible__ListItem             = QAccessible__Role(0x00000022)
	QAccessible__Tree                 = QAccessible__Role(0x00000023)
	QAccessible__TreeItem             = QAccessible__Role(0x00000024)
	QAccessible__PageTab              = QAccessible__Role(0x00000025)
	QAccessible__PropertyPage         = QAccessible__Role(0x00000026)
	QAccessible__Indicator            = QAccessible__Role(0x00000027)
	QAccessible__Graphic              = QAccessible__Role(0x00000028)
	QAccessible__StaticText           = QAccessible__Role(0x00000029)
	QAccessible__EditableText         = QAccessible__Role(0x0000002A)
	QAccessible__Button               = QAccessible__Role(0x0000002B)
	QAccessible__CheckBox             = QAccessible__Role(0x0000002C)
	QAccessible__RadioButton          = QAccessible__Role(0x0000002D)
	QAccessible__ComboBox             = QAccessible__Role(0x0000002E)
	QAccessible__ProgressBar          = QAccessible__Role(0x00000030)
	QAccessible__Dial                 = QAccessible__Role(0x00000031)
	QAccessible__HotkeyField          = QAccessible__Role(0x00000032)
	QAccessible__Slider               = QAccessible__Role(0x00000033)
	QAccessible__SpinBox              = QAccessible__Role(0x00000034)
	QAccessible__Canvas               = QAccessible__Role(0x00000035)
	QAccessible__Animation            = QAccessible__Role(0x00000036)
	QAccessible__Equation             = QAccessible__Role(0x00000037)
	QAccessible__ButtonDropDown       = QAccessible__Role(0x00000038)
	QAccessible__ButtonMenu           = QAccessible__Role(0x00000039)
	QAccessible__ButtonDropGrid       = QAccessible__Role(0x0000003A)
	QAccessible__Whitespace           = QAccessible__Role(0x0000003B)
	QAccessible__PageTabList          = QAccessible__Role(0x0000003C)
	QAccessible__Clock                = QAccessible__Role(0x0000003D)
	QAccessible__Splitter             = QAccessible__Role(0x0000003E)
	QAccessible__LayeredPane          = QAccessible__Role(0x00000080)
	QAccessible__Terminal             = QAccessible__Role(0x00000081)
	QAccessible__Desktop              = QAccessible__Role(0x00000082)
	QAccessible__Paragraph            = QAccessible__Role(0x00000083)
	QAccessible__WebDocument          = QAccessible__Role(0x00000084)
	QAccessible__Section              = QAccessible__Role(0x00000085)
	QAccessible__ColorChooser         = QAccessible__Role(0x404)
	QAccessible__Footer               = QAccessible__Role(0x40E)
	QAccessible__Form                 = QAccessible__Role(0x410)
	QAccessible__Heading              = QAccessible__Role(0x414)
	QAccessible__Note                 = QAccessible__Role(0x41B)
	QAccessible__ComplementaryContent = QAccessible__Role(0x42C)
	QAccessible__UserRole             = QAccessible__Role(0x0000ffff)
)

//QAccessible::Text
type QAccessible__Text int64

const (
	QAccessible__Name             = QAccessible__Text(0)
	QAccessible__Description      = QAccessible__Text(1)
	QAccessible__Value            = QAccessible__Text(2)
	QAccessible__Help             = QAccessible__Text(3)
	QAccessible__Accelerator      = QAccessible__Text(4)
	QAccessible__DebugDescription = QAccessible__Text(5)
	QAccessible__UserText         = QAccessible__Text(0x0000ffff)
)

//QAccessible::TextBoundaryType
type QAccessible__TextBoundaryType int64

const (
	QAccessible__CharBoundary      = QAccessible__TextBoundaryType(0)
	QAccessible__WordBoundary      = QAccessible__TextBoundaryType(1)
	QAccessible__SentenceBoundary  = QAccessible__TextBoundaryType(2)
	QAccessible__ParagraphBoundary = QAccessible__TextBoundaryType(3)
	QAccessible__LineBoundary      = QAccessible__TextBoundaryType(4)
	QAccessible__NoBoundary        = QAccessible__TextBoundaryType(5)
)

func QAccessible_IsActive() bool {
	defer qt.Recovering("QAccessible::isActive")

	return C.QAccessible_QAccessible_IsActive() != 0
}

func QAccessible_QueryAccessibleInterface(object core.QObject_ITF) *QAccessibleInterface {
	defer qt.Recovering("QAccessible::queryAccessibleInterface")

	return NewQAccessibleInterfaceFromPointer(C.QAccessible_QAccessible_QueryAccessibleInterface(core.PointerFromQObject(object)))
}

func QAccessible_SetRootObject(object core.QObject_ITF) {
	defer qt.Recovering("QAccessible::setRootObject")

	C.QAccessible_QAccessible_SetRootObject(core.PointerFromQObject(object))
}

func QAccessible_UpdateAccessibility(event QAccessibleEvent_ITF) {
	defer qt.Recovering("QAccessible::updateAccessibility")

	C.QAccessible_QAccessible_UpdateAccessibility(PointerFromQAccessibleEvent(event))
}

type QAccessibleActionInterface struct {
	ptr unsafe.Pointer
}

type QAccessibleActionInterface_ITF interface {
	QAccessibleActionInterface_PTR() *QAccessibleActionInterface
}

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

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

func PointerFromQAccessibleActionInterface(ptr QAccessibleActionInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleActionInterface_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleActionInterfaceFromPointer(ptr unsafe.Pointer) *QAccessibleActionInterface {
	var n = NewQAccessibleActionInterfaceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAccessibleActionInterface_") {
		n.SetObjectNameAbs("QAccessibleActionInterface_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessibleActionInterface) QAccessibleActionInterface_PTR() *QAccessibleActionInterface {
	return ptr
}

func (ptr *QAccessibleActionInterface) LocalizedActionDescription(actionName string) string {
	defer qt.Recovering("QAccessibleActionInterface::localizedActionDescription")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleActionInterface_LocalizedActionDescription(ptr.Pointer(), C.CString(actionName)))
	}
	return ""
}

func (ptr *QAccessibleActionInterface) LocalizedActionName(actionName string) string {
	defer qt.Recovering("QAccessibleActionInterface::localizedActionName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleActionInterface_LocalizedActionName(ptr.Pointer(), C.CString(actionName)))
	}
	return ""
}

func (ptr *QAccessibleActionInterface) ActionNames() []string {
	defer qt.Recovering("QAccessibleActionInterface::actionNames")

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

func QAccessibleActionInterface_DecreaseAction() string {
	defer qt.Recovering("QAccessibleActionInterface::decreaseAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_DecreaseAction())
}

func (ptr *QAccessibleActionInterface) DoAction(actionName string) {
	defer qt.Recovering("QAccessibleActionInterface::doAction")

	if ptr.Pointer() != nil {
		C.QAccessibleActionInterface_DoAction(ptr.Pointer(), C.CString(actionName))
	}
}

func QAccessibleActionInterface_IncreaseAction() string {
	defer qt.Recovering("QAccessibleActionInterface::increaseAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_IncreaseAction())
}

func (ptr *QAccessibleActionInterface) KeyBindingsForAction(actionName string) []string {
	defer qt.Recovering("QAccessibleActionInterface::keyBindingsForAction")

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

func QAccessibleActionInterface_NextPageAction() string {
	defer qt.Recovering("QAccessibleActionInterface::nextPageAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_NextPageAction())
}

func QAccessibleActionInterface_PressAction() string {
	defer qt.Recovering("QAccessibleActionInterface::pressAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_PressAction())
}

func QAccessibleActionInterface_PreviousPageAction() string {
	defer qt.Recovering("QAccessibleActionInterface::previousPageAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_PreviousPageAction())
}

func QAccessibleActionInterface_ScrollDownAction() string {
	defer qt.Recovering("QAccessibleActionInterface::scrollDownAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_ScrollDownAction())
}

func QAccessibleActionInterface_ScrollLeftAction() string {
	defer qt.Recovering("QAccessibleActionInterface::scrollLeftAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_ScrollLeftAction())
}

func QAccessibleActionInterface_ScrollRightAction() string {
	defer qt.Recovering("QAccessibleActionInterface::scrollRightAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_ScrollRightAction())
}

func QAccessibleActionInterface_ScrollUpAction() string {
	defer qt.Recovering("QAccessibleActionInterface::scrollUpAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_ScrollUpAction())
}

func QAccessibleActionInterface_SetFocusAction() string {
	defer qt.Recovering("QAccessibleActionInterface::setFocusAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_SetFocusAction())
}

func QAccessibleActionInterface_ShowMenuAction() string {
	defer qt.Recovering("QAccessibleActionInterface::showMenuAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_ShowMenuAction())
}

func QAccessibleActionInterface_ToggleAction() string {
	defer qt.Recovering("QAccessibleActionInterface::toggleAction")

	return C.GoString(C.QAccessibleActionInterface_QAccessibleActionInterface_ToggleAction())
}

func (ptr *QAccessibleActionInterface) DestroyQAccessibleActionInterface() {
	defer qt.Recovering("QAccessibleActionInterface::~QAccessibleActionInterface")

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

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

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

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

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

type QAccessibleEditableTextInterface struct {
	ptr unsafe.Pointer
}

type QAccessibleEditableTextInterface_ITF interface {
	QAccessibleEditableTextInterface_PTR() *QAccessibleEditableTextInterface
}

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

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

func PointerFromQAccessibleEditableTextInterface(ptr QAccessibleEditableTextInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleEditableTextInterface_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleEditableTextInterfaceFromPointer(ptr unsafe.Pointer) *QAccessibleEditableTextInterface {
	var n = NewQAccessibleEditableTextInterfaceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAccessibleEditableTextInterface_") {
		n.SetObjectNameAbs("QAccessibleEditableTextInterface_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessibleEditableTextInterface) QAccessibleEditableTextInterface_PTR() *QAccessibleEditableTextInterface {
	return ptr
}

func (ptr *QAccessibleEditableTextInterface) DeleteText(startOffset int, endOffset int) {
	defer qt.Recovering("QAccessibleEditableTextInterface::deleteText")

	if ptr.Pointer() != nil {
		C.QAccessibleEditableTextInterface_DeleteText(ptr.Pointer(), C.int(startOffset), C.int(endOffset))
	}
}

func (ptr *QAccessibleEditableTextInterface) InsertText(offset int, text string) {
	defer qt.Recovering("QAccessibleEditableTextInterface::insertText")

	if ptr.Pointer() != nil {
		C.QAccessibleEditableTextInterface_InsertText(ptr.Pointer(), C.int(offset), C.CString(text))
	}
}

func (ptr *QAccessibleEditableTextInterface) ReplaceText(startOffset int, endOffset int, text string) {
	defer qt.Recovering("QAccessibleEditableTextInterface::replaceText")

	if ptr.Pointer() != nil {
		C.QAccessibleEditableTextInterface_ReplaceText(ptr.Pointer(), C.int(startOffset), C.int(endOffset), C.CString(text))
	}
}

func (ptr *QAccessibleEditableTextInterface) DestroyQAccessibleEditableTextInterface() {
	defer qt.Recovering("QAccessibleEditableTextInterface::~QAccessibleEditableTextInterface")

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

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

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

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

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

type QAccessibleEvent struct {
	ptr unsafe.Pointer
}

type QAccessibleEvent_ITF interface {
	QAccessibleEvent_PTR() *QAccessibleEvent
}

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

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

func PointerFromQAccessibleEvent(ptr QAccessibleEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleEvent_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleEventFromPointer(ptr unsafe.Pointer) *QAccessibleEvent {
	var n = NewQAccessibleEventFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAccessibleEvent_") {
		n.SetObjectNameAbs("QAccessibleEvent_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessibleEvent) QAccessibleEvent_PTR() *QAccessibleEvent {
	return ptr
}

func NewQAccessibleEvent2(interfa QAccessibleInterface_ITF, ty QAccessible__Event) *QAccessibleEvent {
	defer qt.Recovering("QAccessibleEvent::QAccessibleEvent")

	return newQAccessibleEventFromPointer(C.QAccessibleEvent_NewQAccessibleEvent2(PointerFromQAccessibleInterface(interfa), C.int(ty)))
}

func NewQAccessibleEvent(object core.QObject_ITF, ty QAccessible__Event) *QAccessibleEvent {
	defer qt.Recovering("QAccessibleEvent::QAccessibleEvent")

	return newQAccessibleEventFromPointer(C.QAccessibleEvent_NewQAccessibleEvent(core.PointerFromQObject(object), C.int(ty)))
}

func (ptr *QAccessibleEvent) AccessibleInterface() *QAccessibleInterface {
	defer qt.Recovering("QAccessibleEvent::accessibleInterface")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleEvent_AccessibleInterface(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleEvent) Child() int {
	defer qt.Recovering("QAccessibleEvent::child")

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

func (ptr *QAccessibleEvent) Object() *core.QObject {
	defer qt.Recovering("QAccessibleEvent::object")

	if ptr.Pointer() != nil {
		return core.NewQObjectFromPointer(C.QAccessibleEvent_Object(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleEvent) SetChild(child int) {
	defer qt.Recovering("QAccessibleEvent::setChild")

	if ptr.Pointer() != nil {
		C.QAccessibleEvent_SetChild(ptr.Pointer(), C.int(child))
	}
}

func (ptr *QAccessibleEvent) Type() QAccessible__Event {
	defer qt.Recovering("QAccessibleEvent::type")

	if ptr.Pointer() != nil {
		return QAccessible__Event(C.QAccessibleEvent_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAccessibleEvent) DestroyQAccessibleEvent() {
	defer qt.Recovering("QAccessibleEvent::~QAccessibleEvent")

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

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

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

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

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

type QAccessibleInterface struct {
	ptr unsafe.Pointer
}

type QAccessibleInterface_ITF interface {
	QAccessibleInterface_PTR() *QAccessibleInterface
}

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

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

func PointerFromQAccessibleInterface(ptr QAccessibleInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleInterface_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleInterfaceFromPointer(ptr unsafe.Pointer) *QAccessibleInterface {
	var n = NewQAccessibleInterfaceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAccessibleInterface_") {
		n.SetObjectNameAbs("QAccessibleInterface_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessibleInterface) QAccessibleInterface_PTR() *QAccessibleInterface {
	return ptr
}

func (ptr *QAccessibleInterface) DestroyQAccessibleInterface() {
	defer qt.Recovering("QAccessibleInterface::~QAccessibleInterface")

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

func (ptr *QAccessibleInterface) ActionInterface() *QAccessibleActionInterface {
	defer qt.Recovering("QAccessibleInterface::actionInterface")

	if ptr.Pointer() != nil {
		return NewQAccessibleActionInterfaceFromPointer(C.QAccessibleInterface_ActionInterface(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) BackgroundColor() *QColor {
	defer qt.Recovering("QAccessibleInterface::backgroundColor")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QAccessibleInterface_BackgroundColor(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) Child(index int) *QAccessibleInterface {
	defer qt.Recovering("QAccessibleInterface::child")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleInterface_Child(ptr.Pointer(), C.int(index)))
	}
	return nil
}

func (ptr *QAccessibleInterface) ChildAt(x int, y int) *QAccessibleInterface {
	defer qt.Recovering("QAccessibleInterface::childAt")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleInterface_ChildAt(ptr.Pointer(), C.int(x), C.int(y)))
	}
	return nil
}

func (ptr *QAccessibleInterface) ChildCount() int {
	defer qt.Recovering("QAccessibleInterface::childCount")

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

func (ptr *QAccessibleInterface) FocusChild() *QAccessibleInterface {
	defer qt.Recovering("QAccessibleInterface::focusChild")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleInterface_FocusChild(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) ForegroundColor() *QColor {
	defer qt.Recovering("QAccessibleInterface::foregroundColor")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QAccessibleInterface_ForegroundColor(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) IndexOfChild(child QAccessibleInterface_ITF) int {
	defer qt.Recovering("QAccessibleInterface::indexOfChild")

	if ptr.Pointer() != nil {
		return int(C.QAccessibleInterface_IndexOfChild(ptr.Pointer(), PointerFromQAccessibleInterface(child)))
	}
	return 0
}

func (ptr *QAccessibleInterface) Interface_cast(ty QAccessible__InterfaceType) unsafe.Pointer {
	defer qt.Recovering("QAccessibleInterface::interface_cast")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QAccessibleInterface_Interface_cast(ptr.Pointer(), C.int(ty)))
	}
	return nil
}

func (ptr *QAccessibleInterface) IsValid() bool {
	defer qt.Recovering("QAccessibleInterface::isValid")

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

func (ptr *QAccessibleInterface) Object() *core.QObject {
	defer qt.Recovering("QAccessibleInterface::object")

	if ptr.Pointer() != nil {
		return core.NewQObjectFromPointer(C.QAccessibleInterface_Object(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) Parent() *QAccessibleInterface {
	defer qt.Recovering("QAccessibleInterface::parent")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleInterface_Parent(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) Rect() *core.QRect {
	defer qt.Recovering("QAccessibleInterface::rect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QAccessibleInterface_Rect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) Role() QAccessible__Role {
	defer qt.Recovering("QAccessibleInterface::role")

	if ptr.Pointer() != nil {
		return QAccessible__Role(C.QAccessibleInterface_Role(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAccessibleInterface) SetText(t QAccessible__Text, text string) {
	defer qt.Recovering("QAccessibleInterface::setText")

	if ptr.Pointer() != nil {
		C.QAccessibleInterface_SetText(ptr.Pointer(), C.int(t), C.CString(text))
	}
}

func (ptr *QAccessibleInterface) TableCellInterface() *QAccessibleTableCellInterface {
	defer qt.Recovering("QAccessibleInterface::tableCellInterface")

	if ptr.Pointer() != nil {
		return NewQAccessibleTableCellInterfaceFromPointer(C.QAccessibleInterface_TableCellInterface(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) TableInterface() *QAccessibleTableInterface {
	defer qt.Recovering("QAccessibleInterface::tableInterface")

	if ptr.Pointer() != nil {
		return NewQAccessibleTableInterfaceFromPointer(C.QAccessibleInterface_TableInterface(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) Text(t QAccessible__Text) string {
	defer qt.Recovering("QAccessibleInterface::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleInterface_Text(ptr.Pointer(), C.int(t)))
	}
	return ""
}

func (ptr *QAccessibleInterface) TextInterface() *QAccessibleTextInterface {
	defer qt.Recovering("QAccessibleInterface::textInterface")

	if ptr.Pointer() != nil {
		return NewQAccessibleTextInterfaceFromPointer(C.QAccessibleInterface_TextInterface(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) ValueInterface() *QAccessibleValueInterface {
	defer qt.Recovering("QAccessibleInterface::valueInterface")

	if ptr.Pointer() != nil {
		return NewQAccessibleValueInterfaceFromPointer(C.QAccessibleInterface_ValueInterface(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleInterface) Window() *QWindow {
	defer qt.Recovering("QAccessibleInterface::window")

	if ptr.Pointer() != nil {
		return NewQWindowFromPointer(C.QAccessibleInterface_Window(ptr.Pointer()))
	}
	return nil
}

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

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

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

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

type QAccessibleObject struct {
	QAccessibleInterface
}

type QAccessibleObject_ITF interface {
	QAccessibleInterface_ITF
	QAccessibleObject_PTR() *QAccessibleObject
}

func PointerFromQAccessibleObject(ptr QAccessibleObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleObject_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleObjectFromPointer(ptr unsafe.Pointer) *QAccessibleObject {
	var n = NewQAccessibleObjectFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAccessibleObject_") {
		n.SetObjectNameAbs("QAccessibleObject_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessibleObject) QAccessibleObject_PTR() *QAccessibleObject {
	return ptr
}

func (ptr *QAccessibleObject) ChildAt(x int, y int) *QAccessibleInterface {
	defer qt.Recovering("QAccessibleObject::childAt")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleObject_ChildAt(ptr.Pointer(), C.int(x), C.int(y)))
	}
	return nil
}

func (ptr *QAccessibleObject) IsValid() bool {
	defer qt.Recovering("QAccessibleObject::isValid")

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

func (ptr *QAccessibleObject) Object() *core.QObject {
	defer qt.Recovering("QAccessibleObject::object")

	if ptr.Pointer() != nil {
		return core.NewQObjectFromPointer(C.QAccessibleObject_Object(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleObject) Rect() *core.QRect {
	defer qt.Recovering("QAccessibleObject::rect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QAccessibleObject_Rect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleObject) ConnectSetText(f func(t QAccessible__Text, text string)) {
	defer qt.Recovering("connect QAccessibleObject::setText")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectNameAbs(), "setText", f)
	}
}

func (ptr *QAccessibleObject) DisconnectSetText() {
	defer qt.Recovering("disconnect QAccessibleObject::setText")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectNameAbs(), "setText")
	}
}

//export callbackQAccessibleObjectSetText
func callbackQAccessibleObjectSetText(ptr unsafe.Pointer, ptrName *C.char, t C.int, text *C.char) {
	defer qt.Recovering("callback QAccessibleObject::setText")

	if signal := qt.GetSignal(C.GoString(ptrName), "setText"); signal != nil {
		signal.(func(QAccessible__Text, string))(QAccessible__Text(t), C.GoString(text))
	} else {
		NewQAccessibleObjectFromPointer(ptr).SetTextDefault(QAccessible__Text(t), C.GoString(text))
	}
}

func (ptr *QAccessibleObject) SetText(t QAccessible__Text, text string) {
	defer qt.Recovering("QAccessibleObject::setText")

	if ptr.Pointer() != nil {
		C.QAccessibleObject_SetText(ptr.Pointer(), C.int(t), C.CString(text))
	}
}

func (ptr *QAccessibleObject) SetTextDefault(t QAccessible__Text, text string) {
	defer qt.Recovering("QAccessibleObject::setText")

	if ptr.Pointer() != nil {
		C.QAccessibleObject_SetTextDefault(ptr.Pointer(), C.int(t), C.CString(text))
	}
}

func (ptr *QAccessibleObject) DestroyQAccessibleObject() {
	defer qt.Recovering("QAccessibleObject::~QAccessibleObject")

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

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

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

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

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

type QAccessiblePlugin struct {
	core.QObject
}

type QAccessiblePlugin_ITF interface {
	core.QObject_ITF
	QAccessiblePlugin_PTR() *QAccessiblePlugin
}

func PointerFromQAccessiblePlugin(ptr QAccessiblePlugin_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessiblePlugin_PTR().Pointer()
	}
	return nil
}

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

func newQAccessiblePluginFromPointer(ptr unsafe.Pointer) *QAccessiblePlugin {
	var n = NewQAccessiblePluginFromPointer(ptr)
	for len(n.ObjectName()) < len("QAccessiblePlugin_") {
		n.SetObjectName("QAccessiblePlugin_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessiblePlugin) QAccessiblePlugin_PTR() *QAccessiblePlugin {
	return ptr
}

type QAccessibleStateChangeEvent struct {
	QAccessibleEvent
}

type QAccessibleStateChangeEvent_ITF interface {
	QAccessibleEvent_ITF
	QAccessibleStateChangeEvent_PTR() *QAccessibleStateChangeEvent
}

func PointerFromQAccessibleStateChangeEvent(ptr QAccessibleStateChangeEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleStateChangeEvent_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleStateChangeEventFromPointer(ptr unsafe.Pointer) *QAccessibleStateChangeEvent {
	var n = NewQAccessibleStateChangeEventFromPointer(ptr)
	return n
}

func (ptr *QAccessibleStateChangeEvent) QAccessibleStateChangeEvent_PTR() *QAccessibleStateChangeEvent {
	return ptr
}

type QAccessibleTableCellInterface struct {
	ptr unsafe.Pointer
}

type QAccessibleTableCellInterface_ITF interface {
	QAccessibleTableCellInterface_PTR() *QAccessibleTableCellInterface
}

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

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

func PointerFromQAccessibleTableCellInterface(ptr QAccessibleTableCellInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleTableCellInterface_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleTableCellInterfaceFromPointer(ptr unsafe.Pointer) *QAccessibleTableCellInterface {
	var n = NewQAccessibleTableCellInterfaceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAccessibleTableCellInterface_") {
		n.SetObjectNameAbs("QAccessibleTableCellInterface_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessibleTableCellInterface) QAccessibleTableCellInterface_PTR() *QAccessibleTableCellInterface {
	return ptr
}

func (ptr *QAccessibleTableCellInterface) ColumnExtent() int {
	defer qt.Recovering("QAccessibleTableCellInterface::columnExtent")

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

func (ptr *QAccessibleTableCellInterface) ColumnIndex() int {
	defer qt.Recovering("QAccessibleTableCellInterface::columnIndex")

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

func (ptr *QAccessibleTableCellInterface) IsSelected() bool {
	defer qt.Recovering("QAccessibleTableCellInterface::isSelected")

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

func (ptr *QAccessibleTableCellInterface) RowExtent() int {
	defer qt.Recovering("QAccessibleTableCellInterface::rowExtent")

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

func (ptr *QAccessibleTableCellInterface) RowIndex() int {
	defer qt.Recovering("QAccessibleTableCellInterface::rowIndex")

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

func (ptr *QAccessibleTableCellInterface) Table() *QAccessibleInterface {
	defer qt.Recovering("QAccessibleTableCellInterface::table")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleTableCellInterface_Table(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleTableCellInterface) DestroyQAccessibleTableCellInterface() {
	defer qt.Recovering("QAccessibleTableCellInterface::~QAccessibleTableCellInterface")

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

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

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

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

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

type QAccessibleTableInterface struct {
	ptr unsafe.Pointer
}

type QAccessibleTableInterface_ITF interface {
	QAccessibleTableInterface_PTR() *QAccessibleTableInterface
}

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

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

func PointerFromQAccessibleTableInterface(ptr QAccessibleTableInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleTableInterface_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleTableInterfaceFromPointer(ptr unsafe.Pointer) *QAccessibleTableInterface {
	var n = NewQAccessibleTableInterfaceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAccessibleTableInterface_") {
		n.SetObjectNameAbs("QAccessibleTableInterface_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessibleTableInterface) QAccessibleTableInterface_PTR() *QAccessibleTableInterface {
	return ptr
}

func (ptr *QAccessibleTableInterface) Caption() *QAccessibleInterface {
	defer qt.Recovering("QAccessibleTableInterface::caption")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleTableInterface_Caption(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleTableInterface) CellAt(row int, column int) *QAccessibleInterface {
	defer qt.Recovering("QAccessibleTableInterface::cellAt")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleTableInterface_CellAt(ptr.Pointer(), C.int(row), C.int(column)))
	}
	return nil
}

func (ptr *QAccessibleTableInterface) ColumnCount() int {
	defer qt.Recovering("QAccessibleTableInterface::columnCount")

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

func (ptr *QAccessibleTableInterface) ColumnDescription(column int) string {
	defer qt.Recovering("QAccessibleTableInterface::columnDescription")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleTableInterface_ColumnDescription(ptr.Pointer(), C.int(column)))
	}
	return ""
}

func (ptr *QAccessibleTableInterface) IsColumnSelected(column int) bool {
	defer qt.Recovering("QAccessibleTableInterface::isColumnSelected")

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

func (ptr *QAccessibleTableInterface) IsRowSelected(row int) bool {
	defer qt.Recovering("QAccessibleTableInterface::isRowSelected")

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

func (ptr *QAccessibleTableInterface) ModelChange(event QAccessibleTableModelChangeEvent_ITF) {
	defer qt.Recovering("QAccessibleTableInterface::modelChange")

	if ptr.Pointer() != nil {
		C.QAccessibleTableInterface_ModelChange(ptr.Pointer(), PointerFromQAccessibleTableModelChangeEvent(event))
	}
}

func (ptr *QAccessibleTableInterface) RowCount() int {
	defer qt.Recovering("QAccessibleTableInterface::rowCount")

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

func (ptr *QAccessibleTableInterface) RowDescription(row int) string {
	defer qt.Recovering("QAccessibleTableInterface::rowDescription")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleTableInterface_RowDescription(ptr.Pointer(), C.int(row)))
	}
	return ""
}

func (ptr *QAccessibleTableInterface) SelectColumn(column int) bool {
	defer qt.Recovering("QAccessibleTableInterface::selectColumn")

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

func (ptr *QAccessibleTableInterface) SelectRow(row int) bool {
	defer qt.Recovering("QAccessibleTableInterface::selectRow")

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

func (ptr *QAccessibleTableInterface) SelectedCellCount() int {
	defer qt.Recovering("QAccessibleTableInterface::selectedCellCount")

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

func (ptr *QAccessibleTableInterface) SelectedColumnCount() int {
	defer qt.Recovering("QAccessibleTableInterface::selectedColumnCount")

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

func (ptr *QAccessibleTableInterface) SelectedRowCount() int {
	defer qt.Recovering("QAccessibleTableInterface::selectedRowCount")

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

func (ptr *QAccessibleTableInterface) Summary() *QAccessibleInterface {
	defer qt.Recovering("QAccessibleTableInterface::summary")

	if ptr.Pointer() != nil {
		return NewQAccessibleInterfaceFromPointer(C.QAccessibleTableInterface_Summary(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleTableInterface) UnselectColumn(column int) bool {
	defer qt.Recovering("QAccessibleTableInterface::unselectColumn")

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

func (ptr *QAccessibleTableInterface) UnselectRow(row int) bool {
	defer qt.Recovering("QAccessibleTableInterface::unselectRow")

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

func (ptr *QAccessibleTableInterface) DestroyQAccessibleTableInterface() {
	defer qt.Recovering("QAccessibleTableInterface::~QAccessibleTableInterface")

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

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

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

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

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

type QAccessibleTableModelChangeEvent struct {
	QAccessibleEvent
}

type QAccessibleTableModelChangeEvent_ITF interface {
	QAccessibleEvent_ITF
	QAccessibleTableModelChangeEvent_PTR() *QAccessibleTableModelChangeEvent
}

func PointerFromQAccessibleTableModelChangeEvent(ptr QAccessibleTableModelChangeEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleTableModelChangeEvent_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleTableModelChangeEventFromPointer(ptr unsafe.Pointer) *QAccessibleTableModelChangeEvent {
	var n = NewQAccessibleTableModelChangeEventFromPointer(ptr)
	return n
}

func (ptr *QAccessibleTableModelChangeEvent) QAccessibleTableModelChangeEvent_PTR() *QAccessibleTableModelChangeEvent {
	return ptr
}

//QAccessibleTableModelChangeEvent::ModelChangeType
type QAccessibleTableModelChangeEvent__ModelChangeType int64

const (
	QAccessibleTableModelChangeEvent__ModelReset      = QAccessibleTableModelChangeEvent__ModelChangeType(0)
	QAccessibleTableModelChangeEvent__DataChanged     = QAccessibleTableModelChangeEvent__ModelChangeType(1)
	QAccessibleTableModelChangeEvent__RowsInserted    = QAccessibleTableModelChangeEvent__ModelChangeType(2)
	QAccessibleTableModelChangeEvent__ColumnsInserted = QAccessibleTableModelChangeEvent__ModelChangeType(3)
	QAccessibleTableModelChangeEvent__RowsRemoved     = QAccessibleTableModelChangeEvent__ModelChangeType(4)
	QAccessibleTableModelChangeEvent__ColumnsRemoved  = QAccessibleTableModelChangeEvent__ModelChangeType(5)
)

func NewQAccessibleTableModelChangeEvent2(iface QAccessibleInterface_ITF, changeType QAccessibleTableModelChangeEvent__ModelChangeType) *QAccessibleTableModelChangeEvent {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::QAccessibleTableModelChangeEvent")

	return newQAccessibleTableModelChangeEventFromPointer(C.QAccessibleTableModelChangeEvent_NewQAccessibleTableModelChangeEvent2(PointerFromQAccessibleInterface(iface), C.int(changeType)))
}

func NewQAccessibleTableModelChangeEvent(object core.QObject_ITF, changeType QAccessibleTableModelChangeEvent__ModelChangeType) *QAccessibleTableModelChangeEvent {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::QAccessibleTableModelChangeEvent")

	return newQAccessibleTableModelChangeEventFromPointer(C.QAccessibleTableModelChangeEvent_NewQAccessibleTableModelChangeEvent(core.PointerFromQObject(object), C.int(changeType)))
}

func (ptr *QAccessibleTableModelChangeEvent) FirstColumn() int {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::firstColumn")

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

func (ptr *QAccessibleTableModelChangeEvent) FirstRow() int {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::firstRow")

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

func (ptr *QAccessibleTableModelChangeEvent) LastColumn() int {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::lastColumn")

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

func (ptr *QAccessibleTableModelChangeEvent) LastRow() int {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::lastRow")

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

func (ptr *QAccessibleTableModelChangeEvent) ModelChangeType() QAccessibleTableModelChangeEvent__ModelChangeType {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::modelChangeType")

	if ptr.Pointer() != nil {
		return QAccessibleTableModelChangeEvent__ModelChangeType(C.QAccessibleTableModelChangeEvent_ModelChangeType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QAccessibleTableModelChangeEvent) SetFirstColumn(column int) {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::setFirstColumn")

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

func (ptr *QAccessibleTableModelChangeEvent) SetFirstRow(row int) {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::setFirstRow")

	if ptr.Pointer() != nil {
		C.QAccessibleTableModelChangeEvent_SetFirstRow(ptr.Pointer(), C.int(row))
	}
}

func (ptr *QAccessibleTableModelChangeEvent) SetLastColumn(column int) {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::setLastColumn")

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

func (ptr *QAccessibleTableModelChangeEvent) SetLastRow(row int) {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::setLastRow")

	if ptr.Pointer() != nil {
		C.QAccessibleTableModelChangeEvent_SetLastRow(ptr.Pointer(), C.int(row))
	}
}

func (ptr *QAccessibleTableModelChangeEvent) SetModelChangeType(changeType QAccessibleTableModelChangeEvent__ModelChangeType) {
	defer qt.Recovering("QAccessibleTableModelChangeEvent::setModelChangeType")

	if ptr.Pointer() != nil {
		C.QAccessibleTableModelChangeEvent_SetModelChangeType(ptr.Pointer(), C.int(changeType))
	}
}

type QAccessibleTextCursorEvent struct {
	QAccessibleEvent
}

type QAccessibleTextCursorEvent_ITF interface {
	QAccessibleEvent_ITF
	QAccessibleTextCursorEvent_PTR() *QAccessibleTextCursorEvent
}

func PointerFromQAccessibleTextCursorEvent(ptr QAccessibleTextCursorEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleTextCursorEvent_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleTextCursorEventFromPointer(ptr unsafe.Pointer) *QAccessibleTextCursorEvent {
	var n = NewQAccessibleTextCursorEventFromPointer(ptr)
	return n
}

func (ptr *QAccessibleTextCursorEvent) QAccessibleTextCursorEvent_PTR() *QAccessibleTextCursorEvent {
	return ptr
}

func NewQAccessibleTextCursorEvent2(iface QAccessibleInterface_ITF, cursorPos int) *QAccessibleTextCursorEvent {
	defer qt.Recovering("QAccessibleTextCursorEvent::QAccessibleTextCursorEvent")

	return newQAccessibleTextCursorEventFromPointer(C.QAccessibleTextCursorEvent_NewQAccessibleTextCursorEvent2(PointerFromQAccessibleInterface(iface), C.int(cursorPos)))
}

func NewQAccessibleTextCursorEvent(object core.QObject_ITF, cursorPos int) *QAccessibleTextCursorEvent {
	defer qt.Recovering("QAccessibleTextCursorEvent::QAccessibleTextCursorEvent")

	return newQAccessibleTextCursorEventFromPointer(C.QAccessibleTextCursorEvent_NewQAccessibleTextCursorEvent(core.PointerFromQObject(object), C.int(cursorPos)))
}

func (ptr *QAccessibleTextCursorEvent) CursorPosition() int {
	defer qt.Recovering("QAccessibleTextCursorEvent::cursorPosition")

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

func (ptr *QAccessibleTextCursorEvent) SetCursorPosition(position int) {
	defer qt.Recovering("QAccessibleTextCursorEvent::setCursorPosition")

	if ptr.Pointer() != nil {
		C.QAccessibleTextCursorEvent_SetCursorPosition(ptr.Pointer(), C.int(position))
	}
}

type QAccessibleTextInsertEvent struct {
	QAccessibleTextCursorEvent
}

type QAccessibleTextInsertEvent_ITF interface {
	QAccessibleTextCursorEvent_ITF
	QAccessibleTextInsertEvent_PTR() *QAccessibleTextInsertEvent
}

func PointerFromQAccessibleTextInsertEvent(ptr QAccessibleTextInsertEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleTextInsertEvent_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleTextInsertEventFromPointer(ptr unsafe.Pointer) *QAccessibleTextInsertEvent {
	var n = NewQAccessibleTextInsertEventFromPointer(ptr)
	return n
}

func (ptr *QAccessibleTextInsertEvent) QAccessibleTextInsertEvent_PTR() *QAccessibleTextInsertEvent {
	return ptr
}

func NewQAccessibleTextInsertEvent2(iface QAccessibleInterface_ITF, position int, text string) *QAccessibleTextInsertEvent {
	defer qt.Recovering("QAccessibleTextInsertEvent::QAccessibleTextInsertEvent")

	return newQAccessibleTextInsertEventFromPointer(C.QAccessibleTextInsertEvent_NewQAccessibleTextInsertEvent2(PointerFromQAccessibleInterface(iface), C.int(position), C.CString(text)))
}

func NewQAccessibleTextInsertEvent(object core.QObject_ITF, position int, text string) *QAccessibleTextInsertEvent {
	defer qt.Recovering("QAccessibleTextInsertEvent::QAccessibleTextInsertEvent")

	return newQAccessibleTextInsertEventFromPointer(C.QAccessibleTextInsertEvent_NewQAccessibleTextInsertEvent(core.PointerFromQObject(object), C.int(position), C.CString(text)))
}

func (ptr *QAccessibleTextInsertEvent) ChangePosition() int {
	defer qt.Recovering("QAccessibleTextInsertEvent::changePosition")

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

func (ptr *QAccessibleTextInsertEvent) TextInserted() string {
	defer qt.Recovering("QAccessibleTextInsertEvent::textInserted")

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

type QAccessibleTextInterface struct {
	ptr unsafe.Pointer
}

type QAccessibleTextInterface_ITF interface {
	QAccessibleTextInterface_PTR() *QAccessibleTextInterface
}

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

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

func PointerFromQAccessibleTextInterface(ptr QAccessibleTextInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleTextInterface_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleTextInterfaceFromPointer(ptr unsafe.Pointer) *QAccessibleTextInterface {
	var n = NewQAccessibleTextInterfaceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAccessibleTextInterface_") {
		n.SetObjectNameAbs("QAccessibleTextInterface_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessibleTextInterface) QAccessibleTextInterface_PTR() *QAccessibleTextInterface {
	return ptr
}

func (ptr *QAccessibleTextInterface) AddSelection(startOffset int, endOffset int) {
	defer qt.Recovering("QAccessibleTextInterface::addSelection")

	if ptr.Pointer() != nil {
		C.QAccessibleTextInterface_AddSelection(ptr.Pointer(), C.int(startOffset), C.int(endOffset))
	}
}

func (ptr *QAccessibleTextInterface) Attributes(offset int, startOffset int, endOffset int) string {
	defer qt.Recovering("QAccessibleTextInterface::attributes")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleTextInterface_Attributes(ptr.Pointer(), C.int(offset), C.int(startOffset), C.int(endOffset)))
	}
	return ""
}

func (ptr *QAccessibleTextInterface) CharacterCount() int {
	defer qt.Recovering("QAccessibleTextInterface::characterCount")

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

func (ptr *QAccessibleTextInterface) CharacterRect(offset int) *core.QRect {
	defer qt.Recovering("QAccessibleTextInterface::characterRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QAccessibleTextInterface_CharacterRect(ptr.Pointer(), C.int(offset)))
	}
	return nil
}

func (ptr *QAccessibleTextInterface) CursorPosition() int {
	defer qt.Recovering("QAccessibleTextInterface::cursorPosition")

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

func (ptr *QAccessibleTextInterface) OffsetAtPoint(point core.QPoint_ITF) int {
	defer qt.Recovering("QAccessibleTextInterface::offsetAtPoint")

	if ptr.Pointer() != nil {
		return int(C.QAccessibleTextInterface_OffsetAtPoint(ptr.Pointer(), core.PointerFromQPoint(point)))
	}
	return 0
}

func (ptr *QAccessibleTextInterface) RemoveSelection(selectionIndex int) {
	defer qt.Recovering("QAccessibleTextInterface::removeSelection")

	if ptr.Pointer() != nil {
		C.QAccessibleTextInterface_RemoveSelection(ptr.Pointer(), C.int(selectionIndex))
	}
}

func (ptr *QAccessibleTextInterface) ScrollToSubstring(startIndex int, endIndex int) {
	defer qt.Recovering("QAccessibleTextInterface::scrollToSubstring")

	if ptr.Pointer() != nil {
		C.QAccessibleTextInterface_ScrollToSubstring(ptr.Pointer(), C.int(startIndex), C.int(endIndex))
	}
}

func (ptr *QAccessibleTextInterface) Selection(selectionIndex int, startOffset int, endOffset int) {
	defer qt.Recovering("QAccessibleTextInterface::selection")

	if ptr.Pointer() != nil {
		C.QAccessibleTextInterface_Selection(ptr.Pointer(), C.int(selectionIndex), C.int(startOffset), C.int(endOffset))
	}
}

func (ptr *QAccessibleTextInterface) SelectionCount() int {
	defer qt.Recovering("QAccessibleTextInterface::selectionCount")

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

func (ptr *QAccessibleTextInterface) SetCursorPosition(position int) {
	defer qt.Recovering("QAccessibleTextInterface::setCursorPosition")

	if ptr.Pointer() != nil {
		C.QAccessibleTextInterface_SetCursorPosition(ptr.Pointer(), C.int(position))
	}
}

func (ptr *QAccessibleTextInterface) SetSelection(selectionIndex int, startOffset int, endOffset int) {
	defer qt.Recovering("QAccessibleTextInterface::setSelection")

	if ptr.Pointer() != nil {
		C.QAccessibleTextInterface_SetSelection(ptr.Pointer(), C.int(selectionIndex), C.int(startOffset), C.int(endOffset))
	}
}

func (ptr *QAccessibleTextInterface) Text(startOffset int, endOffset int) string {
	defer qt.Recovering("QAccessibleTextInterface::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleTextInterface_Text(ptr.Pointer(), C.int(startOffset), C.int(endOffset)))
	}
	return ""
}

func (ptr *QAccessibleTextInterface) TextAfterOffset(offset int, boundaryType QAccessible__TextBoundaryType, startOffset int, endOffset int) string {
	defer qt.Recovering("QAccessibleTextInterface::textAfterOffset")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleTextInterface_TextAfterOffset(ptr.Pointer(), C.int(offset), C.int(boundaryType), C.int(startOffset), C.int(endOffset)))
	}
	return ""
}

func (ptr *QAccessibleTextInterface) TextAtOffset(offset int, boundaryType QAccessible__TextBoundaryType, startOffset int, endOffset int) string {
	defer qt.Recovering("QAccessibleTextInterface::textAtOffset")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleTextInterface_TextAtOffset(ptr.Pointer(), C.int(offset), C.int(boundaryType), C.int(startOffset), C.int(endOffset)))
	}
	return ""
}

func (ptr *QAccessibleTextInterface) TextBeforeOffset(offset int, boundaryType QAccessible__TextBoundaryType, startOffset int, endOffset int) string {
	defer qt.Recovering("QAccessibleTextInterface::textBeforeOffset")

	if ptr.Pointer() != nil {
		return C.GoString(C.QAccessibleTextInterface_TextBeforeOffset(ptr.Pointer(), C.int(offset), C.int(boundaryType), C.int(startOffset), C.int(endOffset)))
	}
	return ""
}

func (ptr *QAccessibleTextInterface) DestroyQAccessibleTextInterface() {
	defer qt.Recovering("QAccessibleTextInterface::~QAccessibleTextInterface")

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

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

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

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

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

type QAccessibleTextRemoveEvent struct {
	QAccessibleTextCursorEvent
}

type QAccessibleTextRemoveEvent_ITF interface {
	QAccessibleTextCursorEvent_ITF
	QAccessibleTextRemoveEvent_PTR() *QAccessibleTextRemoveEvent
}

func PointerFromQAccessibleTextRemoveEvent(ptr QAccessibleTextRemoveEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleTextRemoveEvent_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleTextRemoveEventFromPointer(ptr unsafe.Pointer) *QAccessibleTextRemoveEvent {
	var n = NewQAccessibleTextRemoveEventFromPointer(ptr)
	return n
}

func (ptr *QAccessibleTextRemoveEvent) QAccessibleTextRemoveEvent_PTR() *QAccessibleTextRemoveEvent {
	return ptr
}

func NewQAccessibleTextRemoveEvent2(iface QAccessibleInterface_ITF, position int, text string) *QAccessibleTextRemoveEvent {
	defer qt.Recovering("QAccessibleTextRemoveEvent::QAccessibleTextRemoveEvent")

	return newQAccessibleTextRemoveEventFromPointer(C.QAccessibleTextRemoveEvent_NewQAccessibleTextRemoveEvent2(PointerFromQAccessibleInterface(iface), C.int(position), C.CString(text)))
}

func NewQAccessibleTextRemoveEvent(object core.QObject_ITF, position int, text string) *QAccessibleTextRemoveEvent {
	defer qt.Recovering("QAccessibleTextRemoveEvent::QAccessibleTextRemoveEvent")

	return newQAccessibleTextRemoveEventFromPointer(C.QAccessibleTextRemoveEvent_NewQAccessibleTextRemoveEvent(core.PointerFromQObject(object), C.int(position), C.CString(text)))
}

func (ptr *QAccessibleTextRemoveEvent) ChangePosition() int {
	defer qt.Recovering("QAccessibleTextRemoveEvent::changePosition")

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

func (ptr *QAccessibleTextRemoveEvent) TextRemoved() string {
	defer qt.Recovering("QAccessibleTextRemoveEvent::textRemoved")

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

type QAccessibleTextSelectionEvent struct {
	QAccessibleTextCursorEvent
}

type QAccessibleTextSelectionEvent_ITF interface {
	QAccessibleTextCursorEvent_ITF
	QAccessibleTextSelectionEvent_PTR() *QAccessibleTextSelectionEvent
}

func PointerFromQAccessibleTextSelectionEvent(ptr QAccessibleTextSelectionEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleTextSelectionEvent_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleTextSelectionEventFromPointer(ptr unsafe.Pointer) *QAccessibleTextSelectionEvent {
	var n = NewQAccessibleTextSelectionEventFromPointer(ptr)
	return n
}

func (ptr *QAccessibleTextSelectionEvent) QAccessibleTextSelectionEvent_PTR() *QAccessibleTextSelectionEvent {
	return ptr
}

func NewQAccessibleTextSelectionEvent2(iface QAccessibleInterface_ITF, start int, end int) *QAccessibleTextSelectionEvent {
	defer qt.Recovering("QAccessibleTextSelectionEvent::QAccessibleTextSelectionEvent")

	return newQAccessibleTextSelectionEventFromPointer(C.QAccessibleTextSelectionEvent_NewQAccessibleTextSelectionEvent2(PointerFromQAccessibleInterface(iface), C.int(start), C.int(end)))
}

func NewQAccessibleTextSelectionEvent(object core.QObject_ITF, start int, end int) *QAccessibleTextSelectionEvent {
	defer qt.Recovering("QAccessibleTextSelectionEvent::QAccessibleTextSelectionEvent")

	return newQAccessibleTextSelectionEventFromPointer(C.QAccessibleTextSelectionEvent_NewQAccessibleTextSelectionEvent(core.PointerFromQObject(object), C.int(start), C.int(end)))
}

func (ptr *QAccessibleTextSelectionEvent) SelectionEnd() int {
	defer qt.Recovering("QAccessibleTextSelectionEvent::selectionEnd")

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

func (ptr *QAccessibleTextSelectionEvent) SelectionStart() int {
	defer qt.Recovering("QAccessibleTextSelectionEvent::selectionStart")

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

func (ptr *QAccessibleTextSelectionEvent) SetSelection(start int, end int) {
	defer qt.Recovering("QAccessibleTextSelectionEvent::setSelection")

	if ptr.Pointer() != nil {
		C.QAccessibleTextSelectionEvent_SetSelection(ptr.Pointer(), C.int(start), C.int(end))
	}
}

type QAccessibleTextUpdateEvent struct {
	QAccessibleTextCursorEvent
}

type QAccessibleTextUpdateEvent_ITF interface {
	QAccessibleTextCursorEvent_ITF
	QAccessibleTextUpdateEvent_PTR() *QAccessibleTextUpdateEvent
}

func PointerFromQAccessibleTextUpdateEvent(ptr QAccessibleTextUpdateEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleTextUpdateEvent_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleTextUpdateEventFromPointer(ptr unsafe.Pointer) *QAccessibleTextUpdateEvent {
	var n = NewQAccessibleTextUpdateEventFromPointer(ptr)
	return n
}

func (ptr *QAccessibleTextUpdateEvent) QAccessibleTextUpdateEvent_PTR() *QAccessibleTextUpdateEvent {
	return ptr
}

func NewQAccessibleTextUpdateEvent2(iface QAccessibleInterface_ITF, position int, oldText string, text string) *QAccessibleTextUpdateEvent {
	defer qt.Recovering("QAccessibleTextUpdateEvent::QAccessibleTextUpdateEvent")

	return newQAccessibleTextUpdateEventFromPointer(C.QAccessibleTextUpdateEvent_NewQAccessibleTextUpdateEvent2(PointerFromQAccessibleInterface(iface), C.int(position), C.CString(oldText), C.CString(text)))
}

func NewQAccessibleTextUpdateEvent(object core.QObject_ITF, position int, oldText string, text string) *QAccessibleTextUpdateEvent {
	defer qt.Recovering("QAccessibleTextUpdateEvent::QAccessibleTextUpdateEvent")

	return newQAccessibleTextUpdateEventFromPointer(C.QAccessibleTextUpdateEvent_NewQAccessibleTextUpdateEvent(core.PointerFromQObject(object), C.int(position), C.CString(oldText), C.CString(text)))
}

func (ptr *QAccessibleTextUpdateEvent) ChangePosition() int {
	defer qt.Recovering("QAccessibleTextUpdateEvent::changePosition")

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

func (ptr *QAccessibleTextUpdateEvent) TextInserted() string {
	defer qt.Recovering("QAccessibleTextUpdateEvent::textInserted")

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

func (ptr *QAccessibleTextUpdateEvent) TextRemoved() string {
	defer qt.Recovering("QAccessibleTextUpdateEvent::textRemoved")

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

type QAccessibleValueChangeEvent struct {
	QAccessibleEvent
}

type QAccessibleValueChangeEvent_ITF interface {
	QAccessibleEvent_ITF
	QAccessibleValueChangeEvent_PTR() *QAccessibleValueChangeEvent
}

func PointerFromQAccessibleValueChangeEvent(ptr QAccessibleValueChangeEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleValueChangeEvent_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleValueChangeEventFromPointer(ptr unsafe.Pointer) *QAccessibleValueChangeEvent {
	var n = NewQAccessibleValueChangeEventFromPointer(ptr)
	return n
}

func (ptr *QAccessibleValueChangeEvent) QAccessibleValueChangeEvent_PTR() *QAccessibleValueChangeEvent {
	return ptr
}

func NewQAccessibleValueChangeEvent2(iface QAccessibleInterface_ITF, val core.QVariant_ITF) *QAccessibleValueChangeEvent {
	defer qt.Recovering("QAccessibleValueChangeEvent::QAccessibleValueChangeEvent")

	return newQAccessibleValueChangeEventFromPointer(C.QAccessibleValueChangeEvent_NewQAccessibleValueChangeEvent2(PointerFromQAccessibleInterface(iface), core.PointerFromQVariant(val)))
}

func NewQAccessibleValueChangeEvent(object core.QObject_ITF, value core.QVariant_ITF) *QAccessibleValueChangeEvent {
	defer qt.Recovering("QAccessibleValueChangeEvent::QAccessibleValueChangeEvent")

	return newQAccessibleValueChangeEventFromPointer(C.QAccessibleValueChangeEvent_NewQAccessibleValueChangeEvent(core.PointerFromQObject(object), core.PointerFromQVariant(value)))
}

func (ptr *QAccessibleValueChangeEvent) SetValue(value core.QVariant_ITF) {
	defer qt.Recovering("QAccessibleValueChangeEvent::setValue")

	if ptr.Pointer() != nil {
		C.QAccessibleValueChangeEvent_SetValue(ptr.Pointer(), core.PointerFromQVariant(value))
	}
}

func (ptr *QAccessibleValueChangeEvent) Value() *core.QVariant {
	defer qt.Recovering("QAccessibleValueChangeEvent::value")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QAccessibleValueChangeEvent_Value(ptr.Pointer()))
	}
	return nil
}

type QAccessibleValueInterface struct {
	ptr unsafe.Pointer
}

type QAccessibleValueInterface_ITF interface {
	QAccessibleValueInterface_PTR() *QAccessibleValueInterface
}

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

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

func PointerFromQAccessibleValueInterface(ptr QAccessibleValueInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QAccessibleValueInterface_PTR().Pointer()
	}
	return nil
}

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

func newQAccessibleValueInterfaceFromPointer(ptr unsafe.Pointer) *QAccessibleValueInterface {
	var n = NewQAccessibleValueInterfaceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QAccessibleValueInterface_") {
		n.SetObjectNameAbs("QAccessibleValueInterface_" + qt.Identifier())
	}
	return n
}

func (ptr *QAccessibleValueInterface) QAccessibleValueInterface_PTR() *QAccessibleValueInterface {
	return ptr
}

func (ptr *QAccessibleValueInterface) CurrentValue() *core.QVariant {
	defer qt.Recovering("QAccessibleValueInterface::currentValue")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QAccessibleValueInterface_CurrentValue(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleValueInterface) MaximumValue() *core.QVariant {
	defer qt.Recovering("QAccessibleValueInterface::maximumValue")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QAccessibleValueInterface_MaximumValue(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleValueInterface) MinimumStepSize() *core.QVariant {
	defer qt.Recovering("QAccessibleValueInterface::minimumStepSize")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QAccessibleValueInterface_MinimumStepSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleValueInterface) MinimumValue() *core.QVariant {
	defer qt.Recovering("QAccessibleValueInterface::minimumValue")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QAccessibleValueInterface_MinimumValue(ptr.Pointer()))
	}
	return nil
}

func (ptr *QAccessibleValueInterface) SetCurrentValue(value core.QVariant_ITF) {
	defer qt.Recovering("QAccessibleValueInterface::setCurrentValue")

	if ptr.Pointer() != nil {
		C.QAccessibleValueInterface_SetCurrentValue(ptr.Pointer(), core.PointerFromQVariant(value))
	}
}

func (ptr *QAccessibleValueInterface) DestroyQAccessibleValueInterface() {
	defer qt.Recovering("QAccessibleValueInterface::~QAccessibleValueInterface")

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

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

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

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

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

type QActionEvent struct {
	core.QEvent
}

type QActionEvent_ITF interface {
	core.QEvent_ITF
	QActionEvent_PTR() *QActionEvent
}

func PointerFromQActionEvent(ptr QActionEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QActionEvent_PTR().Pointer()
	}
	return nil
}

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

func newQActionEventFromPointer(ptr unsafe.Pointer) *QActionEvent {
	var n = NewQActionEventFromPointer(ptr)
	return n
}

func (ptr *QActionEvent) QActionEvent_PTR() *QActionEvent {
	return ptr
}

func NewQActionEvent(ty int, action unsafe.Pointer, before unsafe.Pointer) *QActionEvent {
	defer qt.Recovering("QActionEvent::QActionEvent")

	return newQActionEventFromPointer(C.QActionEvent_NewQActionEvent(C.int(ty), action, before))
}

func (ptr *QActionEvent) Action() unsafe.Pointer {
	defer qt.Recovering("QActionEvent::action")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QActionEvent_Action(ptr.Pointer()))
	}
	return nil
}

func (ptr *QActionEvent) Before() unsafe.Pointer {
	defer qt.Recovering("QActionEvent::before")

	if ptr.Pointer() != nil {
		return unsafe.Pointer(C.QActionEvent_Before(ptr.Pointer()))
	}
	return nil
}

type QBackingStore struct {
	ptr unsafe.Pointer
}

type QBackingStore_ITF interface {
	QBackingStore_PTR() *QBackingStore
}

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

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

func PointerFromQBackingStore(ptr QBackingStore_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBackingStore_PTR().Pointer()
	}
	return nil
}

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

func newQBackingStoreFromPointer(ptr unsafe.Pointer) *QBackingStore {
	var n = NewQBackingStoreFromPointer(ptr)
	return n
}

func (ptr *QBackingStore) QBackingStore_PTR() *QBackingStore {
	return ptr
}

func (ptr *QBackingStore) PaintDevice() *QPaintDevice {
	defer qt.Recovering("QBackingStore::paintDevice")

	if ptr.Pointer() != nil {
		return NewQPaintDeviceFromPointer(C.QBackingStore_PaintDevice(ptr.Pointer()))
	}
	return nil
}

func NewQBackingStore(window QWindow_ITF) *QBackingStore {
	defer qt.Recovering("QBackingStore::QBackingStore")

	return newQBackingStoreFromPointer(C.QBackingStore_NewQBackingStore(PointerFromQWindow(window)))
}

func (ptr *QBackingStore) BeginPaint(region QRegion_ITF) {
	defer qt.Recovering("QBackingStore::beginPaint")

	if ptr.Pointer() != nil {
		C.QBackingStore_BeginPaint(ptr.Pointer(), PointerFromQRegion(region))
	}
}

func (ptr *QBackingStore) EndPaint() {
	defer qt.Recovering("QBackingStore::endPaint")

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

func (ptr *QBackingStore) Flush(region QRegion_ITF, win QWindow_ITF, offset core.QPoint_ITF) {
	defer qt.Recovering("QBackingStore::flush")

	if ptr.Pointer() != nil {
		C.QBackingStore_Flush(ptr.Pointer(), PointerFromQRegion(region), PointerFromQWindow(win), core.PointerFromQPoint(offset))
	}
}

func (ptr *QBackingStore) HasStaticContents() bool {
	defer qt.Recovering("QBackingStore::hasStaticContents")

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

func (ptr *QBackingStore) Resize(size core.QSize_ITF) {
	defer qt.Recovering("QBackingStore::resize")

	if ptr.Pointer() != nil {
		C.QBackingStore_Resize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QBackingStore) Scroll(area QRegion_ITF, dx int, dy int) bool {
	defer qt.Recovering("QBackingStore::scroll")

	if ptr.Pointer() != nil {
		return C.QBackingStore_Scroll(ptr.Pointer(), PointerFromQRegion(area), C.int(dx), C.int(dy)) != 0
	}
	return false
}

func (ptr *QBackingStore) SetStaticContents(region QRegion_ITF) {
	defer qt.Recovering("QBackingStore::setStaticContents")

	if ptr.Pointer() != nil {
		C.QBackingStore_SetStaticContents(ptr.Pointer(), PointerFromQRegion(region))
	}
}

func (ptr *QBackingStore) Size() *core.QSize {
	defer qt.Recovering("QBackingStore::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QBackingStore_Size(ptr.Pointer()))
	}
	return nil
}

func (ptr *QBackingStore) StaticContents() *QRegion {
	defer qt.Recovering("QBackingStore::staticContents")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QBackingStore_StaticContents(ptr.Pointer()))
	}
	return nil
}

func (ptr *QBackingStore) Window() *QWindow {
	defer qt.Recovering("QBackingStore::window")

	if ptr.Pointer() != nil {
		return NewQWindowFromPointer(C.QBackingStore_Window(ptr.Pointer()))
	}
	return nil
}

func (ptr *QBackingStore) DestroyQBackingStore() {
	defer qt.Recovering("QBackingStore::~QBackingStore")

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

type QBitmap struct {
	QPixmap
}

type QBitmap_ITF interface {
	QPixmap_ITF
	QBitmap_PTR() *QBitmap
}

func PointerFromQBitmap(ptr QBitmap_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBitmap_PTR().Pointer()
	}
	return nil
}

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

func newQBitmapFromPointer(ptr unsafe.Pointer) *QBitmap {
	var n = NewQBitmapFromPointer(ptr)
	return n
}

func (ptr *QBitmap) QBitmap_PTR() *QBitmap {
	return ptr
}

func NewQBitmap3(width int, height int) *QBitmap {
	defer qt.Recovering("QBitmap::QBitmap")

	return newQBitmapFromPointer(C.QBitmap_NewQBitmap3(C.int(width), C.int(height)))
}

func NewQBitmap() *QBitmap {
	defer qt.Recovering("QBitmap::QBitmap")

	return newQBitmapFromPointer(C.QBitmap_NewQBitmap())
}

func NewQBitmap2(pixmap QPixmap_ITF) *QBitmap {
	defer qt.Recovering("QBitmap::QBitmap")

	return newQBitmapFromPointer(C.QBitmap_NewQBitmap2(PointerFromQPixmap(pixmap)))
}

func NewQBitmap4(size core.QSize_ITF) *QBitmap {
	defer qt.Recovering("QBitmap::QBitmap")

	return newQBitmapFromPointer(C.QBitmap_NewQBitmap4(core.PointerFromQSize(size)))
}

func NewQBitmap5(fileName string, format string) *QBitmap {
	defer qt.Recovering("QBitmap::QBitmap")

	return newQBitmapFromPointer(C.QBitmap_NewQBitmap5(C.CString(fileName), C.CString(format)))
}

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

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

func (ptr *QBitmap) Swap(other QBitmap_ITF) {
	defer qt.Recovering("QBitmap::swap")

	if ptr.Pointer() != nil {
		C.QBitmap_Swap(ptr.Pointer(), PointerFromQBitmap(other))
	}
}

func (ptr *QBitmap) DestroyQBitmap() {
	defer qt.Recovering("QBitmap::~QBitmap")

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

type QBrush struct {
	ptr unsafe.Pointer
}

type QBrush_ITF interface {
	QBrush_PTR() *QBrush
}

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

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

func PointerFromQBrush(ptr QBrush_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QBrush_PTR().Pointer()
	}
	return nil
}

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

func newQBrushFromPointer(ptr unsafe.Pointer) *QBrush {
	var n = NewQBrushFromPointer(ptr)
	return n
}

func (ptr *QBrush) QBrush_PTR() *QBrush {
	return ptr
}

func NewQBrush4(color core.Qt__GlobalColor, style core.Qt__BrushStyle) *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush4(C.int(color), C.int(style)))
}

func (ptr *QBrush) SetColor(color QColor_ITF) {
	defer qt.Recovering("QBrush::setColor")

	if ptr.Pointer() != nil {
		C.QBrush_SetColor(ptr.Pointer(), PointerFromQColor(color))
	}
}

func NewQBrush() *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush())
}

func NewQBrush2(style core.Qt__BrushStyle) *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush2(C.int(style)))
}

func NewQBrush6(color core.Qt__GlobalColor, pixmap QPixmap_ITF) *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush6(C.int(color), PointerFromQPixmap(pixmap)))
}

func NewQBrush9(other QBrush_ITF) *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush9(PointerFromQBrush(other)))
}

func NewQBrush3(color QColor_ITF, style core.Qt__BrushStyle) *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush3(PointerFromQColor(color), C.int(style)))
}

func NewQBrush5(color QColor_ITF, pixmap QPixmap_ITF) *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush5(PointerFromQColor(color), PointerFromQPixmap(pixmap)))
}

func NewQBrush10(gradient QGradient_ITF) *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush10(PointerFromQGradient(gradient)))
}

func NewQBrush8(image QImage_ITF) *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush8(PointerFromQImage(image)))
}

func NewQBrush7(pixmap QPixmap_ITF) *QBrush {
	defer qt.Recovering("QBrush::QBrush")

	return newQBrushFromPointer(C.QBrush_NewQBrush7(PointerFromQPixmap(pixmap)))
}

func (ptr *QBrush) Color() *QColor {
	defer qt.Recovering("QBrush::color")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QBrush_Color(ptr.Pointer()))
	}
	return nil
}

func (ptr *QBrush) Gradient() *QGradient {
	defer qt.Recovering("QBrush::gradient")

	if ptr.Pointer() != nil {
		return NewQGradientFromPointer(C.QBrush_Gradient(ptr.Pointer()))
	}
	return nil
}

func (ptr *QBrush) IsOpaque() bool {
	defer qt.Recovering("QBrush::isOpaque")

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

func (ptr *QBrush) SetColor2(color core.Qt__GlobalColor) {
	defer qt.Recovering("QBrush::setColor")

	if ptr.Pointer() != nil {
		C.QBrush_SetColor2(ptr.Pointer(), C.int(color))
	}
}

func (ptr *QBrush) SetStyle(style core.Qt__BrushStyle) {
	defer qt.Recovering("QBrush::setStyle")

	if ptr.Pointer() != nil {
		C.QBrush_SetStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QBrush) SetTexture(pixmap QPixmap_ITF) {
	defer qt.Recovering("QBrush::setTexture")

	if ptr.Pointer() != nil {
		C.QBrush_SetTexture(ptr.Pointer(), PointerFromQPixmap(pixmap))
	}
}

func (ptr *QBrush) SetTextureImage(image QImage_ITF) {
	defer qt.Recovering("QBrush::setTextureImage")

	if ptr.Pointer() != nil {
		C.QBrush_SetTextureImage(ptr.Pointer(), PointerFromQImage(image))
	}
}

func (ptr *QBrush) SetTransform(matrix QTransform_ITF) {
	defer qt.Recovering("QBrush::setTransform")

	if ptr.Pointer() != nil {
		C.QBrush_SetTransform(ptr.Pointer(), PointerFromQTransform(matrix))
	}
}

func (ptr *QBrush) Style() core.Qt__BrushStyle {
	defer qt.Recovering("QBrush::style")

	if ptr.Pointer() != nil {
		return core.Qt__BrushStyle(C.QBrush_Style(ptr.Pointer()))
	}
	return 0
}

func (ptr *QBrush) Swap(other QBrush_ITF) {
	defer qt.Recovering("QBrush::swap")

	if ptr.Pointer() != nil {
		C.QBrush_Swap(ptr.Pointer(), PointerFromQBrush(other))
	}
}

func (ptr *QBrush) DestroyQBrush() {
	defer qt.Recovering("QBrush::~QBrush")

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

type QClipboard struct {
	core.QObject
}

type QClipboard_ITF interface {
	core.QObject_ITF
	QClipboard_PTR() *QClipboard
}

func PointerFromQClipboard(ptr QClipboard_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QClipboard_PTR().Pointer()
	}
	return nil
}

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

func newQClipboardFromPointer(ptr unsafe.Pointer) *QClipboard {
	var n = NewQClipboardFromPointer(ptr)
	for len(n.ObjectName()) < len("QClipboard_") {
		n.SetObjectName("QClipboard_" + qt.Identifier())
	}
	return n
}

func (ptr *QClipboard) QClipboard_PTR() *QClipboard {
	return ptr
}

//QClipboard::Mode
type QClipboard__Mode int64

const (
	QClipboard__Clipboard  = QClipboard__Mode(0)
	QClipboard__Selection  = QClipboard__Mode(1)
	QClipboard__FindBuffer = QClipboard__Mode(2)
	QClipboard__LastMode   = QClipboard__Mode(QClipboard__FindBuffer)
)

func (ptr *QClipboard) Clear(mode QClipboard__Mode) {
	defer qt.Recovering("QClipboard::clear")

	if ptr.Pointer() != nil {
		C.QClipboard_Clear(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QClipboard) MimeData(mode QClipboard__Mode) *core.QMimeData {
	defer qt.Recovering("QClipboard::mimeData")

	if ptr.Pointer() != nil {
		return core.NewQMimeDataFromPointer(C.QClipboard_MimeData(ptr.Pointer(), C.int(mode)))
	}
	return nil
}

func (ptr *QClipboard) SetMimeData(src core.QMimeData_ITF, mode QClipboard__Mode) {
	defer qt.Recovering("QClipboard::setMimeData")

	if ptr.Pointer() != nil {
		C.QClipboard_SetMimeData(ptr.Pointer(), core.PointerFromQMimeData(src), C.int(mode))
	}
}

func (ptr *QClipboard) ConnectChanged(f func(mode QClipboard__Mode)) {
	defer qt.Recovering("connect QClipboard::changed")

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

func (ptr *QClipboard) DisconnectChanged() {
	defer qt.Recovering("disconnect QClipboard::changed")

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

//export callbackQClipboardChanged
func callbackQClipboardChanged(ptr unsafe.Pointer, ptrName *C.char, mode C.int) {
	defer qt.Recovering("callback QClipboard::changed")

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

}

func (ptr *QClipboard) Changed(mode QClipboard__Mode) {
	defer qt.Recovering("QClipboard::changed")

	if ptr.Pointer() != nil {
		C.QClipboard_Changed(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QClipboard) ConnectDataChanged(f func()) {
	defer qt.Recovering("connect QClipboard::dataChanged")

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

func (ptr *QClipboard) DisconnectDataChanged() {
	defer qt.Recovering("disconnect QClipboard::dataChanged")

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

//export callbackQClipboardDataChanged
func callbackQClipboardDataChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QClipboard::dataChanged")

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

}

func (ptr *QClipboard) DataChanged() {
	defer qt.Recovering("QClipboard::dataChanged")

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

func (ptr *QClipboard) ConnectFindBufferChanged(f func()) {
	defer qt.Recovering("connect QClipboard::findBufferChanged")

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

func (ptr *QClipboard) DisconnectFindBufferChanged() {
	defer qt.Recovering("disconnect QClipboard::findBufferChanged")

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

//export callbackQClipboardFindBufferChanged
func callbackQClipboardFindBufferChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QClipboard::findBufferChanged")

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

}

func (ptr *QClipboard) FindBufferChanged() {
	defer qt.Recovering("QClipboard::findBufferChanged")

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

func (ptr *QClipboard) OwnsClipboard() bool {
	defer qt.Recovering("QClipboard::ownsClipboard")

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

func (ptr *QClipboard) OwnsFindBuffer() bool {
	defer qt.Recovering("QClipboard::ownsFindBuffer")

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

func (ptr *QClipboard) OwnsSelection() bool {
	defer qt.Recovering("QClipboard::ownsSelection")

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

func (ptr *QClipboard) ConnectSelectionChanged(f func()) {
	defer qt.Recovering("connect QClipboard::selectionChanged")

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

func (ptr *QClipboard) DisconnectSelectionChanged() {
	defer qt.Recovering("disconnect QClipboard::selectionChanged")

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

//export callbackQClipboardSelectionChanged
func callbackQClipboardSelectionChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QClipboard::selectionChanged")

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

}

func (ptr *QClipboard) SelectionChanged() {
	defer qt.Recovering("QClipboard::selectionChanged")

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

func (ptr *QClipboard) SetImage(image QImage_ITF, mode QClipboard__Mode) {
	defer qt.Recovering("QClipboard::setImage")

	if ptr.Pointer() != nil {
		C.QClipboard_SetImage(ptr.Pointer(), PointerFromQImage(image), C.int(mode))
	}
}

func (ptr *QClipboard) SetPixmap(pixmap QPixmap_ITF, mode QClipboard__Mode) {
	defer qt.Recovering("QClipboard::setPixmap")

	if ptr.Pointer() != nil {
		C.QClipboard_SetPixmap(ptr.Pointer(), PointerFromQPixmap(pixmap), C.int(mode))
	}
}

func (ptr *QClipboard) SetText(text string, mode QClipboard__Mode) {
	defer qt.Recovering("QClipboard::setText")

	if ptr.Pointer() != nil {
		C.QClipboard_SetText(ptr.Pointer(), C.CString(text), C.int(mode))
	}
}

func (ptr *QClipboard) SupportsFindBuffer() bool {
	defer qt.Recovering("QClipboard::supportsFindBuffer")

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

func (ptr *QClipboard) SupportsSelection() bool {
	defer qt.Recovering("QClipboard::supportsSelection")

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

func (ptr *QClipboard) Text(mode QClipboard__Mode) string {
	defer qt.Recovering("QClipboard::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QClipboard_Text(ptr.Pointer(), C.int(mode)))
	}
	return ""
}

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

type QCloseEvent struct {
	core.QEvent
}

type QCloseEvent_ITF interface {
	core.QEvent_ITF
	QCloseEvent_PTR() *QCloseEvent
}

func PointerFromQCloseEvent(ptr QCloseEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCloseEvent_PTR().Pointer()
	}
	return nil
}

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

func newQCloseEventFromPointer(ptr unsafe.Pointer) *QCloseEvent {
	var n = NewQCloseEventFromPointer(ptr)
	return n
}

func (ptr *QCloseEvent) QCloseEvent_PTR() *QCloseEvent {
	return ptr
}

func NewQCloseEvent() *QCloseEvent {
	defer qt.Recovering("QCloseEvent::QCloseEvent")

	return newQCloseEventFromPointer(C.QCloseEvent_NewQCloseEvent())
}

type QColor struct {
	ptr unsafe.Pointer
}

type QColor_ITF interface {
	QColor_PTR() *QColor
}

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

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

func PointerFromQColor(ptr QColor_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QColor_PTR().Pointer()
	}
	return nil
}

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

func newQColorFromPointer(ptr unsafe.Pointer) *QColor {
	var n = NewQColorFromPointer(ptr)
	return n
}

func (ptr *QColor) QColor_PTR() *QColor {
	return ptr
}

//QColor::NameFormat
type QColor__NameFormat int64

const (
	QColor__HexRgb  = QColor__NameFormat(0)
	QColor__HexArgb = QColor__NameFormat(1)
)

//QColor::Spec
type QColor__Spec int64

const (
	QColor__Invalid = QColor__Spec(0)
	QColor__Rgb     = QColor__Spec(1)
	QColor__Hsv     = QColor__Spec(2)
	QColor__Cmyk    = QColor__Spec(3)
	QColor__Hsl     = QColor__Spec(4)
)

func (ptr *QColor) ConvertTo(colorSpec QColor__Spec) *QColor {
	defer qt.Recovering("QColor::convertTo")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QColor_ConvertTo(ptr.Pointer(), C.int(colorSpec)))
	}
	return nil
}

func (ptr *QColor) SetRgbF(r float64, g float64, b float64, a float64) {
	defer qt.Recovering("QColor::setRgbF")

	if ptr.Pointer() != nil {
		C.QColor_SetRgbF(ptr.Pointer(), C.double(r), C.double(g), C.double(b), C.double(a))
	}
}

func NewQColor() *QColor {
	defer qt.Recovering("QColor::QColor")

	return newQColorFromPointer(C.QColor_NewQColor())
}

func NewQColor8(color core.Qt__GlobalColor) *QColor {
	defer qt.Recovering("QColor::QColor")

	return newQColorFromPointer(C.QColor_NewQColor8(C.int(color)))
}

func NewQColor6(color QColor_ITF) *QColor {
	defer qt.Recovering("QColor::QColor")

	return newQColorFromPointer(C.QColor_NewQColor6(PointerFromQColor(color)))
}

func NewQColor4(name string) *QColor {
	defer qt.Recovering("QColor::QColor")

	return newQColorFromPointer(C.QColor_NewQColor4(C.CString(name)))
}

func NewQColor5(name string) *QColor {
	defer qt.Recovering("QColor::QColor")

	return newQColorFromPointer(C.QColor_NewQColor5(C.CString(name)))
}

func NewQColor2(r int, g int, b int, a int) *QColor {
	defer qt.Recovering("QColor::QColor")

	return newQColorFromPointer(C.QColor_NewQColor2(C.int(r), C.int(g), C.int(b), C.int(a)))
}

func (ptr *QColor) Alpha() int {
	defer qt.Recovering("QColor::alpha")

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

func (ptr *QColor) AlphaF() float64 {
	defer qt.Recovering("QColor::alphaF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_AlphaF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) Black() int {
	defer qt.Recovering("QColor::black")

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

func (ptr *QColor) BlackF() float64 {
	defer qt.Recovering("QColor::blackF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_BlackF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) Blue() int {
	defer qt.Recovering("QColor::blue")

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

func (ptr *QColor) BlueF() float64 {
	defer qt.Recovering("QColor::blueF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_BlueF(ptr.Pointer()))
	}
	return 0
}

func QColor_ColorNames() []string {
	defer qt.Recovering("QColor::colorNames")

	return strings.Split(C.GoString(C.QColor_QColor_ColorNames()), "|")
}

func (ptr *QColor) Cyan() int {
	defer qt.Recovering("QColor::cyan")

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

func (ptr *QColor) CyanF() float64 {
	defer qt.Recovering("QColor::cyanF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_CyanF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) Darker(factor int) *QColor {
	defer qt.Recovering("QColor::darker")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QColor_Darker(ptr.Pointer(), C.int(factor)))
	}
	return nil
}

func QColor_FromCmyk(c int, m int, y int, k int, a int) *QColor {
	defer qt.Recovering("QColor::fromCmyk")

	return NewQColorFromPointer(C.QColor_QColor_FromCmyk(C.int(c), C.int(m), C.int(y), C.int(k), C.int(a)))
}

func QColor_FromCmykF(c float64, m float64, y float64, k float64, a float64) *QColor {
	defer qt.Recovering("QColor::fromCmykF")

	return NewQColorFromPointer(C.QColor_QColor_FromCmykF(C.double(c), C.double(m), C.double(y), C.double(k), C.double(a)))
}

func QColor_FromHsl(h int, s int, l int, a int) *QColor {
	defer qt.Recovering("QColor::fromHsl")

	return NewQColorFromPointer(C.QColor_QColor_FromHsl(C.int(h), C.int(s), C.int(l), C.int(a)))
}

func QColor_FromHslF(h float64, s float64, l float64, a float64) *QColor {
	defer qt.Recovering("QColor::fromHslF")

	return NewQColorFromPointer(C.QColor_QColor_FromHslF(C.double(h), C.double(s), C.double(l), C.double(a)))
}

func QColor_FromHsv(h int, s int, v int, a int) *QColor {
	defer qt.Recovering("QColor::fromHsv")

	return NewQColorFromPointer(C.QColor_QColor_FromHsv(C.int(h), C.int(s), C.int(v), C.int(a)))
}

func QColor_FromHsvF(h float64, s float64, v float64, a float64) *QColor {
	defer qt.Recovering("QColor::fromHsvF")

	return NewQColorFromPointer(C.QColor_QColor_FromHsvF(C.double(h), C.double(s), C.double(v), C.double(a)))
}

func QColor_FromRgb2(r int, g int, b int, a int) *QColor {
	defer qt.Recovering("QColor::fromRgb")

	return NewQColorFromPointer(C.QColor_QColor_FromRgb2(C.int(r), C.int(g), C.int(b), C.int(a)))
}

func QColor_FromRgbF(r float64, g float64, b float64, a float64) *QColor {
	defer qt.Recovering("QColor::fromRgbF")

	return NewQColorFromPointer(C.QColor_QColor_FromRgbF(C.double(r), C.double(g), C.double(b), C.double(a)))
}

func (ptr *QColor) GetCmyk(c int, m int, y int, k int, a int) {
	defer qt.Recovering("QColor::getCmyk")

	if ptr.Pointer() != nil {
		C.QColor_GetCmyk(ptr.Pointer(), C.int(c), C.int(m), C.int(y), C.int(k), C.int(a))
	}
}

func (ptr *QColor) GetHsl(h int, s int, l int, a int) {
	defer qt.Recovering("QColor::getHsl")

	if ptr.Pointer() != nil {
		C.QColor_GetHsl(ptr.Pointer(), C.int(h), C.int(s), C.int(l), C.int(a))
	}
}

func (ptr *QColor) GetHsv(h int, s int, v int, a int) {
	defer qt.Recovering("QColor::getHsv")

	if ptr.Pointer() != nil {
		C.QColor_GetHsv(ptr.Pointer(), C.int(h), C.int(s), C.int(v), C.int(a))
	}
}

func (ptr *QColor) GetRgb(r int, g int, b int, a int) {
	defer qt.Recovering("QColor::getRgb")

	if ptr.Pointer() != nil {
		C.QColor_GetRgb(ptr.Pointer(), C.int(r), C.int(g), C.int(b), C.int(a))
	}
}

func (ptr *QColor) Green() int {
	defer qt.Recovering("QColor::green")

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

func (ptr *QColor) GreenF() float64 {
	defer qt.Recovering("QColor::greenF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_GreenF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) HslHue() int {
	defer qt.Recovering("QColor::hslHue")

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

func (ptr *QColor) HslHueF() float64 {
	defer qt.Recovering("QColor::hslHueF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_HslHueF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) HslSaturation() int {
	defer qt.Recovering("QColor::hslSaturation")

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

func (ptr *QColor) HslSaturationF() float64 {
	defer qt.Recovering("QColor::hslSaturationF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_HslSaturationF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) HsvHue() int {
	defer qt.Recovering("QColor::hsvHue")

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

func (ptr *QColor) HsvHueF() float64 {
	defer qt.Recovering("QColor::hsvHueF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_HsvHueF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) HsvSaturation() int {
	defer qt.Recovering("QColor::hsvSaturation")

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

func (ptr *QColor) HsvSaturationF() float64 {
	defer qt.Recovering("QColor::hsvSaturationF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_HsvSaturationF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) Hue() int {
	defer qt.Recovering("QColor::hue")

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

func (ptr *QColor) HueF() float64 {
	defer qt.Recovering("QColor::hueF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_HueF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) IsValid() bool {
	defer qt.Recovering("QColor::isValid")

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

func QColor_IsValidColor(name string) bool {
	defer qt.Recovering("QColor::isValidColor")

	return C.QColor_QColor_IsValidColor(C.CString(name)) != 0
}

func (ptr *QColor) Lighter(factor int) *QColor {
	defer qt.Recovering("QColor::lighter")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QColor_Lighter(ptr.Pointer(), C.int(factor)))
	}
	return nil
}

func (ptr *QColor) Lightness() int {
	defer qt.Recovering("QColor::lightness")

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

func (ptr *QColor) LightnessF() float64 {
	defer qt.Recovering("QColor::lightnessF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_LightnessF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) Magenta() int {
	defer qt.Recovering("QColor::magenta")

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

func (ptr *QColor) MagentaF() float64 {
	defer qt.Recovering("QColor::magentaF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_MagentaF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) Name() string {
	defer qt.Recovering("QColor::name")

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

func (ptr *QColor) Name2(format QColor__NameFormat) string {
	defer qt.Recovering("QColor::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QColor_Name2(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func (ptr *QColor) Red() int {
	defer qt.Recovering("QColor::red")

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

func (ptr *QColor) RedF() float64 {
	defer qt.Recovering("QColor::redF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_RedF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) Saturation() int {
	defer qt.Recovering("QColor::saturation")

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

func (ptr *QColor) SaturationF() float64 {
	defer qt.Recovering("QColor::saturationF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_SaturationF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) SetAlpha(alpha int) {
	defer qt.Recovering("QColor::setAlpha")

	if ptr.Pointer() != nil {
		C.QColor_SetAlpha(ptr.Pointer(), C.int(alpha))
	}
}

func (ptr *QColor) SetAlphaF(alpha float64) {
	defer qt.Recovering("QColor::setAlphaF")

	if ptr.Pointer() != nil {
		C.QColor_SetAlphaF(ptr.Pointer(), C.double(alpha))
	}
}

func (ptr *QColor) SetBlue(blue int) {
	defer qt.Recovering("QColor::setBlue")

	if ptr.Pointer() != nil {
		C.QColor_SetBlue(ptr.Pointer(), C.int(blue))
	}
}

func (ptr *QColor) SetBlueF(blue float64) {
	defer qt.Recovering("QColor::setBlueF")

	if ptr.Pointer() != nil {
		C.QColor_SetBlueF(ptr.Pointer(), C.double(blue))
	}
}

func (ptr *QColor) SetCmyk(c int, m int, y int, k int, a int) {
	defer qt.Recovering("QColor::setCmyk")

	if ptr.Pointer() != nil {
		C.QColor_SetCmyk(ptr.Pointer(), C.int(c), C.int(m), C.int(y), C.int(k), C.int(a))
	}
}

func (ptr *QColor) SetCmykF(c float64, m float64, y float64, k float64, a float64) {
	defer qt.Recovering("QColor::setCmykF")

	if ptr.Pointer() != nil {
		C.QColor_SetCmykF(ptr.Pointer(), C.double(c), C.double(m), C.double(y), C.double(k), C.double(a))
	}
}

func (ptr *QColor) SetGreen(green int) {
	defer qt.Recovering("QColor::setGreen")

	if ptr.Pointer() != nil {
		C.QColor_SetGreen(ptr.Pointer(), C.int(green))
	}
}

func (ptr *QColor) SetGreenF(green float64) {
	defer qt.Recovering("QColor::setGreenF")

	if ptr.Pointer() != nil {
		C.QColor_SetGreenF(ptr.Pointer(), C.double(green))
	}
}

func (ptr *QColor) SetHsl(h int, s int, l int, a int) {
	defer qt.Recovering("QColor::setHsl")

	if ptr.Pointer() != nil {
		C.QColor_SetHsl(ptr.Pointer(), C.int(h), C.int(s), C.int(l), C.int(a))
	}
}

func (ptr *QColor) SetHslF(h float64, s float64, l float64, a float64) {
	defer qt.Recovering("QColor::setHslF")

	if ptr.Pointer() != nil {
		C.QColor_SetHslF(ptr.Pointer(), C.double(h), C.double(s), C.double(l), C.double(a))
	}
}

func (ptr *QColor) SetHsv(h int, s int, v int, a int) {
	defer qt.Recovering("QColor::setHsv")

	if ptr.Pointer() != nil {
		C.QColor_SetHsv(ptr.Pointer(), C.int(h), C.int(s), C.int(v), C.int(a))
	}
}

func (ptr *QColor) SetHsvF(h float64, s float64, v float64, a float64) {
	defer qt.Recovering("QColor::setHsvF")

	if ptr.Pointer() != nil {
		C.QColor_SetHsvF(ptr.Pointer(), C.double(h), C.double(s), C.double(v), C.double(a))
	}
}

func (ptr *QColor) SetNamedColor(name string) {
	defer qt.Recovering("QColor::setNamedColor")

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

func (ptr *QColor) SetRed(red int) {
	defer qt.Recovering("QColor::setRed")

	if ptr.Pointer() != nil {
		C.QColor_SetRed(ptr.Pointer(), C.int(red))
	}
}

func (ptr *QColor) SetRedF(red float64) {
	defer qt.Recovering("QColor::setRedF")

	if ptr.Pointer() != nil {
		C.QColor_SetRedF(ptr.Pointer(), C.double(red))
	}
}

func (ptr *QColor) SetRgb(r int, g int, b int, a int) {
	defer qt.Recovering("QColor::setRgb")

	if ptr.Pointer() != nil {
		C.QColor_SetRgb(ptr.Pointer(), C.int(r), C.int(g), C.int(b), C.int(a))
	}
}

func (ptr *QColor) Spec() QColor__Spec {
	defer qt.Recovering("QColor::spec")

	if ptr.Pointer() != nil {
		return QColor__Spec(C.QColor_Spec(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) ToCmyk() *QColor {
	defer qt.Recovering("QColor::toCmyk")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QColor_ToCmyk(ptr.Pointer()))
	}
	return nil
}

func (ptr *QColor) ToHsl() *QColor {
	defer qt.Recovering("QColor::toHsl")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QColor_ToHsl(ptr.Pointer()))
	}
	return nil
}

func (ptr *QColor) ToHsv() *QColor {
	defer qt.Recovering("QColor::toHsv")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QColor_ToHsv(ptr.Pointer()))
	}
	return nil
}

func (ptr *QColor) ToRgb() *QColor {
	defer qt.Recovering("QColor::toRgb")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QColor_ToRgb(ptr.Pointer()))
	}
	return nil
}

func (ptr *QColor) Value() int {
	defer qt.Recovering("QColor::value")

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

func (ptr *QColor) ValueF() float64 {
	defer qt.Recovering("QColor::valueF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_ValueF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QColor) Yellow() int {
	defer qt.Recovering("QColor::yellow")

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

func (ptr *QColor) YellowF() float64 {
	defer qt.Recovering("QColor::yellowF")

	if ptr.Pointer() != nil {
		return float64(C.QColor_YellowF(ptr.Pointer()))
	}
	return 0
}

type QConicalGradient struct {
	QGradient
}

type QConicalGradient_ITF interface {
	QGradient_ITF
	QConicalGradient_PTR() *QConicalGradient
}

func PointerFromQConicalGradient(ptr QConicalGradient_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QConicalGradient_PTR().Pointer()
	}
	return nil
}

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

func newQConicalGradientFromPointer(ptr unsafe.Pointer) *QConicalGradient {
	var n = NewQConicalGradientFromPointer(ptr)
	return n
}

func (ptr *QConicalGradient) QConicalGradient_PTR() *QConicalGradient {
	return ptr
}

func NewQConicalGradient() *QConicalGradient {
	defer qt.Recovering("QConicalGradient::QConicalGradient")

	return newQConicalGradientFromPointer(C.QConicalGradient_NewQConicalGradient())
}

func NewQConicalGradient2(center core.QPointF_ITF, angle float64) *QConicalGradient {
	defer qt.Recovering("QConicalGradient::QConicalGradient")

	return newQConicalGradientFromPointer(C.QConicalGradient_NewQConicalGradient2(core.PointerFromQPointF(center), C.double(angle)))
}

func NewQConicalGradient3(cx float64, cy float64, angle float64) *QConicalGradient {
	defer qt.Recovering("QConicalGradient::QConicalGradient")

	return newQConicalGradientFromPointer(C.QConicalGradient_NewQConicalGradient3(C.double(cx), C.double(cy), C.double(angle)))
}

func (ptr *QConicalGradient) Angle() float64 {
	defer qt.Recovering("QConicalGradient::angle")

	if ptr.Pointer() != nil {
		return float64(C.QConicalGradient_Angle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QConicalGradient) SetAngle(angle float64) {
	defer qt.Recovering("QConicalGradient::setAngle")

	if ptr.Pointer() != nil {
		C.QConicalGradient_SetAngle(ptr.Pointer(), C.double(angle))
	}
}

func (ptr *QConicalGradient) SetCenter(center core.QPointF_ITF) {
	defer qt.Recovering("QConicalGradient::setCenter")

	if ptr.Pointer() != nil {
		C.QConicalGradient_SetCenter(ptr.Pointer(), core.PointerFromQPointF(center))
	}
}

func (ptr *QConicalGradient) SetCenter2(x float64, y float64) {
	defer qt.Recovering("QConicalGradient::setCenter")

	if ptr.Pointer() != nil {
		C.QConicalGradient_SetCenter2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

type QContextMenuEvent struct {
	QInputEvent
}

type QContextMenuEvent_ITF interface {
	QInputEvent_ITF
	QContextMenuEvent_PTR() *QContextMenuEvent
}

func PointerFromQContextMenuEvent(ptr QContextMenuEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QContextMenuEvent_PTR().Pointer()
	}
	return nil
}

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

func newQContextMenuEventFromPointer(ptr unsafe.Pointer) *QContextMenuEvent {
	var n = NewQContextMenuEventFromPointer(ptr)
	return n
}

func (ptr *QContextMenuEvent) QContextMenuEvent_PTR() *QContextMenuEvent {
	return ptr
}

//QContextMenuEvent::Reason
type QContextMenuEvent__Reason int64

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

func NewQContextMenuEvent3(reason QContextMenuEvent__Reason, pos core.QPoint_ITF) *QContextMenuEvent {
	defer qt.Recovering("QContextMenuEvent::QContextMenuEvent")

	return newQContextMenuEventFromPointer(C.QContextMenuEvent_NewQContextMenuEvent3(C.int(reason), core.PointerFromQPoint(pos)))
}

func NewQContextMenuEvent2(reason QContextMenuEvent__Reason, pos core.QPoint_ITF, globalPos core.QPoint_ITF) *QContextMenuEvent {
	defer qt.Recovering("QContextMenuEvent::QContextMenuEvent")

	return newQContextMenuEventFromPointer(C.QContextMenuEvent_NewQContextMenuEvent2(C.int(reason), core.PointerFromQPoint(pos), core.PointerFromQPoint(globalPos)))
}

func NewQContextMenuEvent(reason QContextMenuEvent__Reason, pos core.QPoint_ITF, globalPos core.QPoint_ITF, modifiers core.Qt__KeyboardModifier) *QContextMenuEvent {
	defer qt.Recovering("QContextMenuEvent::QContextMenuEvent")

	return newQContextMenuEventFromPointer(C.QContextMenuEvent_NewQContextMenuEvent(C.int(reason), core.PointerFromQPoint(pos), core.PointerFromQPoint(globalPos), C.int(modifiers)))
}

func (ptr *QContextMenuEvent) GlobalPos() *core.QPoint {
	defer qt.Recovering("QContextMenuEvent::globalPos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QContextMenuEvent_GlobalPos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QContextMenuEvent) GlobalX() int {
	defer qt.Recovering("QContextMenuEvent::globalX")

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

func (ptr *QContextMenuEvent) GlobalY() int {
	defer qt.Recovering("QContextMenuEvent::globalY")

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

func (ptr *QContextMenuEvent) Pos() *core.QPoint {
	defer qt.Recovering("QContextMenuEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QContextMenuEvent_Pos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QContextMenuEvent) Reason() QContextMenuEvent__Reason {
	defer qt.Recovering("QContextMenuEvent::reason")

	if ptr.Pointer() != nil {
		return QContextMenuEvent__Reason(C.QContextMenuEvent_Reason(ptr.Pointer()))
	}
	return 0
}

func (ptr *QContextMenuEvent) X() int {
	defer qt.Recovering("QContextMenuEvent::x")

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

func (ptr *QContextMenuEvent) Y() int {
	defer qt.Recovering("QContextMenuEvent::y")

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

type QCursor struct {
	ptr unsafe.Pointer
}

type QCursor_ITF interface {
	QCursor_PTR() *QCursor
}

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

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

func PointerFromQCursor(ptr QCursor_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCursor_PTR().Pointer()
	}
	return nil
}

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

func newQCursorFromPointer(ptr unsafe.Pointer) *QCursor {
	var n = NewQCursorFromPointer(ptr)
	return n
}

func (ptr *QCursor) QCursor_PTR() *QCursor {
	return ptr
}

func QCursor_Pos() *core.QPoint {
	defer qt.Recovering("QCursor::pos")

	return core.NewQPointFromPointer(C.QCursor_QCursor_Pos())
}

func QCursor_Pos2(screen QScreen_ITF) *core.QPoint {
	defer qt.Recovering("QCursor::pos")

	return core.NewQPointFromPointer(C.QCursor_QCursor_Pos2(PointerFromQScreen(screen)))
}

func QCursor_SetPos2(screen QScreen_ITF, x int, y int) {
	defer qt.Recovering("QCursor::setPos")

	C.QCursor_QCursor_SetPos2(PointerFromQScreen(screen), C.int(x), C.int(y))
}

func QCursor_SetPos(x int, y int) {
	defer qt.Recovering("QCursor::setPos")

	C.QCursor_QCursor_SetPos(C.int(x), C.int(y))
}

func NewQCursor() *QCursor {
	defer qt.Recovering("QCursor::QCursor")

	return newQCursorFromPointer(C.QCursor_NewQCursor())
}

func NewQCursor6(other QCursor_ITF) *QCursor {
	defer qt.Recovering("QCursor::QCursor")

	return newQCursorFromPointer(C.QCursor_NewQCursor6(PointerFromQCursor(other)))
}

func NewQCursor2(shape core.Qt__CursorShape) *QCursor {
	defer qt.Recovering("QCursor::QCursor")

	return newQCursorFromPointer(C.QCursor_NewQCursor2(C.int(shape)))
}

func NewQCursor3(bitmap QBitmap_ITF, mask QBitmap_ITF, hotX int, hotY int) *QCursor {
	defer qt.Recovering("QCursor::QCursor")

	return newQCursorFromPointer(C.QCursor_NewQCursor3(PointerFromQBitmap(bitmap), PointerFromQBitmap(mask), C.int(hotX), C.int(hotY)))
}

func NewQCursor5(c QCursor_ITF) *QCursor {
	defer qt.Recovering("QCursor::QCursor")

	return newQCursorFromPointer(C.QCursor_NewQCursor5(PointerFromQCursor(c)))
}

func NewQCursor4(pixmap QPixmap_ITF, hotX int, hotY int) *QCursor {
	defer qt.Recovering("QCursor::QCursor")

	return newQCursorFromPointer(C.QCursor_NewQCursor4(PointerFromQPixmap(pixmap), C.int(hotX), C.int(hotY)))
}

func (ptr *QCursor) Bitmap() *QBitmap {
	defer qt.Recovering("QCursor::bitmap")

	if ptr.Pointer() != nil {
		return NewQBitmapFromPointer(C.QCursor_Bitmap(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCursor) HotSpot() *core.QPoint {
	defer qt.Recovering("QCursor::hotSpot")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QCursor_HotSpot(ptr.Pointer()))
	}
	return nil
}

func (ptr *QCursor) Mask() *QBitmap {
	defer qt.Recovering("QCursor::mask")

	if ptr.Pointer() != nil {
		return NewQBitmapFromPointer(C.QCursor_Mask(ptr.Pointer()))
	}
	return nil
}

func QCursor_SetPos4(screen QScreen_ITF, p core.QPoint_ITF) {
	defer qt.Recovering("QCursor::setPos")

	C.QCursor_QCursor_SetPos4(PointerFromQScreen(screen), core.PointerFromQPoint(p))
}

func QCursor_SetPos3(p core.QPoint_ITF) {
	defer qt.Recovering("QCursor::setPos")

	C.QCursor_QCursor_SetPos3(core.PointerFromQPoint(p))
}

func (ptr *QCursor) SetShape(shape core.Qt__CursorShape) {
	defer qt.Recovering("QCursor::setShape")

	if ptr.Pointer() != nil {
		C.QCursor_SetShape(ptr.Pointer(), C.int(shape))
	}
}

func (ptr *QCursor) Shape() core.Qt__CursorShape {
	defer qt.Recovering("QCursor::shape")

	if ptr.Pointer() != nil {
		return core.Qt__CursorShape(C.QCursor_Shape(ptr.Pointer()))
	}
	return 0
}

func (ptr *QCursor) DestroyQCursor() {
	defer qt.Recovering("QCursor::~QCursor")

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

type QDesktopServices struct {
	ptr unsafe.Pointer
}

type QDesktopServices_ITF interface {
	QDesktopServices_PTR() *QDesktopServices
}

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

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

func PointerFromQDesktopServices(ptr QDesktopServices_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDesktopServices_PTR().Pointer()
	}
	return nil
}

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

func newQDesktopServicesFromPointer(ptr unsafe.Pointer) *QDesktopServices {
	var n = NewQDesktopServicesFromPointer(ptr)
	return n
}

func (ptr *QDesktopServices) QDesktopServices_PTR() *QDesktopServices {
	return ptr
}

func QDesktopServices_OpenUrl(url core.QUrl_ITF) bool {
	defer qt.Recovering("QDesktopServices::openUrl")

	return C.QDesktopServices_QDesktopServices_OpenUrl(core.PointerFromQUrl(url)) != 0
}

func QDesktopServices_SetUrlHandler(scheme string, receiver core.QObject_ITF, method string) {
	defer qt.Recovering("QDesktopServices::setUrlHandler")

	C.QDesktopServices_QDesktopServices_SetUrlHandler(C.CString(scheme), core.PointerFromQObject(receiver), C.CString(method))
}

func QDesktopServices_UnsetUrlHandler(scheme string) {
	defer qt.Recovering("QDesktopServices::unsetUrlHandler")

	C.QDesktopServices_QDesktopServices_UnsetUrlHandler(C.CString(scheme))
}

type QDoubleValidator struct {
	QValidator
}

type QDoubleValidator_ITF interface {
	QValidator_ITF
	QDoubleValidator_PTR() *QDoubleValidator
}

func PointerFromQDoubleValidator(ptr QDoubleValidator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDoubleValidator_PTR().Pointer()
	}
	return nil
}

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

func newQDoubleValidatorFromPointer(ptr unsafe.Pointer) *QDoubleValidator {
	var n = NewQDoubleValidatorFromPointer(ptr)
	for len(n.ObjectName()) < len("QDoubleValidator_") {
		n.SetObjectName("QDoubleValidator_" + qt.Identifier())
	}
	return n
}

func (ptr *QDoubleValidator) QDoubleValidator_PTR() *QDoubleValidator {
	return ptr
}

//QDoubleValidator::Notation
type QDoubleValidator__Notation int64

const (
	QDoubleValidator__StandardNotation   = QDoubleValidator__Notation(0)
	QDoubleValidator__ScientificNotation = QDoubleValidator__Notation(1)
)

func (ptr *QDoubleValidator) Notation() QDoubleValidator__Notation {
	defer qt.Recovering("QDoubleValidator::notation")

	if ptr.Pointer() != nil {
		return QDoubleValidator__Notation(C.QDoubleValidator_Notation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDoubleValidator) SetDecimals(v int) {
	defer qt.Recovering("QDoubleValidator::setDecimals")

	if ptr.Pointer() != nil {
		C.QDoubleValidator_SetDecimals(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QDoubleValidator) SetNotation(v QDoubleValidator__Notation) {
	defer qt.Recovering("QDoubleValidator::setNotation")

	if ptr.Pointer() != nil {
		C.QDoubleValidator_SetNotation(ptr.Pointer(), C.int(v))
	}
}

func NewQDoubleValidator(parent core.QObject_ITF) *QDoubleValidator {
	defer qt.Recovering("QDoubleValidator::QDoubleValidator")

	return newQDoubleValidatorFromPointer(C.QDoubleValidator_NewQDoubleValidator(core.PointerFromQObject(parent)))
}

func (ptr *QDoubleValidator) Decimals() int {
	defer qt.Recovering("QDoubleValidator::decimals")

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

func (ptr *QDoubleValidator) DestroyQDoubleValidator() {
	defer qt.Recovering("QDoubleValidator::~QDoubleValidator")

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

type QDrag struct {
	core.QObject
}

type QDrag_ITF interface {
	core.QObject_ITF
	QDrag_PTR() *QDrag
}

func PointerFromQDrag(ptr QDrag_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDrag_PTR().Pointer()
	}
	return nil
}

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

func newQDragFromPointer(ptr unsafe.Pointer) *QDrag {
	var n = NewQDragFromPointer(ptr)
	for len(n.ObjectName()) < len("QDrag_") {
		n.SetObjectName("QDrag_" + qt.Identifier())
	}
	return n
}

func (ptr *QDrag) QDrag_PTR() *QDrag {
	return ptr
}

func NewQDrag(dragSource core.QObject_ITF) *QDrag {
	defer qt.Recovering("QDrag::QDrag")

	return newQDragFromPointer(C.QDrag_NewQDrag(core.PointerFromQObject(dragSource)))
}

func (ptr *QDrag) ConnectActionChanged(f func(action core.Qt__DropAction)) {
	defer qt.Recovering("connect QDrag::actionChanged")

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

func (ptr *QDrag) DisconnectActionChanged() {
	defer qt.Recovering("disconnect QDrag::actionChanged")

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

//export callbackQDragActionChanged
func callbackQDragActionChanged(ptr unsafe.Pointer, ptrName *C.char, action C.int) {
	defer qt.Recovering("callback QDrag::actionChanged")

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

}

func (ptr *QDrag) ActionChanged(action core.Qt__DropAction) {
	defer qt.Recovering("QDrag::actionChanged")

	if ptr.Pointer() != nil {
		C.QDrag_ActionChanged(ptr.Pointer(), C.int(action))
	}
}

func (ptr *QDrag) Exec(supportedActions core.Qt__DropAction) core.Qt__DropAction {
	defer qt.Recovering("QDrag::exec")

	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QDrag_Exec(ptr.Pointer(), C.int(supportedActions)))
	}
	return 0
}

func (ptr *QDrag) Exec2(supportedActions core.Qt__DropAction, defaultDropAction core.Qt__DropAction) core.Qt__DropAction {
	defer qt.Recovering("QDrag::exec")

	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QDrag_Exec2(ptr.Pointer(), C.int(supportedActions), C.int(defaultDropAction)))
	}
	return 0
}

func (ptr *QDrag) HotSpot() *core.QPoint {
	defer qt.Recovering("QDrag::hotSpot")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QDrag_HotSpot(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDrag) MimeData() *core.QMimeData {
	defer qt.Recovering("QDrag::mimeData")

	if ptr.Pointer() != nil {
		return core.NewQMimeDataFromPointer(C.QDrag_MimeData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDrag) SetDragCursor(cursor QPixmap_ITF, action core.Qt__DropAction) {
	defer qt.Recovering("QDrag::setDragCursor")

	if ptr.Pointer() != nil {
		C.QDrag_SetDragCursor(ptr.Pointer(), PointerFromQPixmap(cursor), C.int(action))
	}
}

func (ptr *QDrag) SetHotSpot(hotspot core.QPoint_ITF) {
	defer qt.Recovering("QDrag::setHotSpot")

	if ptr.Pointer() != nil {
		C.QDrag_SetHotSpot(ptr.Pointer(), core.PointerFromQPoint(hotspot))
	}
}

func (ptr *QDrag) SetMimeData(data core.QMimeData_ITF) {
	defer qt.Recovering("QDrag::setMimeData")

	if ptr.Pointer() != nil {
		C.QDrag_SetMimeData(ptr.Pointer(), core.PointerFromQMimeData(data))
	}
}

func (ptr *QDrag) SetPixmap(pixmap QPixmap_ITF) {
	defer qt.Recovering("QDrag::setPixmap")

	if ptr.Pointer() != nil {
		C.QDrag_SetPixmap(ptr.Pointer(), PointerFromQPixmap(pixmap))
	}
}

func (ptr *QDrag) Source() *core.QObject {
	defer qt.Recovering("QDrag::source")

	if ptr.Pointer() != nil {
		return core.NewQObjectFromPointer(C.QDrag_Source(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDrag) SupportedActions() core.Qt__DropAction {
	defer qt.Recovering("QDrag::supportedActions")

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

func (ptr *QDrag) Target() *core.QObject {
	defer qt.Recovering("QDrag::target")

	if ptr.Pointer() != nil {
		return core.NewQObjectFromPointer(C.QDrag_Target(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDrag) ConnectTargetChanged(f func(newTarget *core.QObject)) {
	defer qt.Recovering("connect QDrag::targetChanged")

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

func (ptr *QDrag) DisconnectTargetChanged() {
	defer qt.Recovering("disconnect QDrag::targetChanged")

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

//export callbackQDragTargetChanged
func callbackQDragTargetChanged(ptr unsafe.Pointer, ptrName *C.char, newTarget unsafe.Pointer) {
	defer qt.Recovering("callback QDrag::targetChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "targetChanged"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(newTarget))
	}

}

func (ptr *QDrag) TargetChanged(newTarget core.QObject_ITF) {
	defer qt.Recovering("QDrag::targetChanged")

	if ptr.Pointer() != nil {
		C.QDrag_TargetChanged(ptr.Pointer(), core.PointerFromQObject(newTarget))
	}
}

func (ptr *QDrag) DestroyQDrag() {
	defer qt.Recovering("QDrag::~QDrag")

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

type QDragEnterEvent struct {
	QDragMoveEvent
}

type QDragEnterEvent_ITF interface {
	QDragMoveEvent_ITF
	QDragEnterEvent_PTR() *QDragEnterEvent
}

func PointerFromQDragEnterEvent(ptr QDragEnterEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDragEnterEvent_PTR().Pointer()
	}
	return nil
}

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

func newQDragEnterEventFromPointer(ptr unsafe.Pointer) *QDragEnterEvent {
	var n = NewQDragEnterEventFromPointer(ptr)
	return n
}

func (ptr *QDragEnterEvent) QDragEnterEvent_PTR() *QDragEnterEvent {
	return ptr
}

func NewQDragEnterEvent(point core.QPoint_ITF, actions core.Qt__DropAction, data core.QMimeData_ITF, buttons core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier) *QDragEnterEvent {
	defer qt.Recovering("QDragEnterEvent::QDragEnterEvent")

	return newQDragEnterEventFromPointer(C.QDragEnterEvent_NewQDragEnterEvent(core.PointerFromQPoint(point), C.int(actions), core.PointerFromQMimeData(data), C.int(buttons), C.int(modifiers)))
}

type QDragLeaveEvent struct {
	core.QEvent
}

type QDragLeaveEvent_ITF interface {
	core.QEvent_ITF
	QDragLeaveEvent_PTR() *QDragLeaveEvent
}

func PointerFromQDragLeaveEvent(ptr QDragLeaveEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDragLeaveEvent_PTR().Pointer()
	}
	return nil
}

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

func newQDragLeaveEventFromPointer(ptr unsafe.Pointer) *QDragLeaveEvent {
	var n = NewQDragLeaveEventFromPointer(ptr)
	return n
}

func (ptr *QDragLeaveEvent) QDragLeaveEvent_PTR() *QDragLeaveEvent {
	return ptr
}

func NewQDragLeaveEvent() *QDragLeaveEvent {
	defer qt.Recovering("QDragLeaveEvent::QDragLeaveEvent")

	return newQDragLeaveEventFromPointer(C.QDragLeaveEvent_NewQDragLeaveEvent())
}

type QDragMoveEvent struct {
	QDropEvent
}

type QDragMoveEvent_ITF interface {
	QDropEvent_ITF
	QDragMoveEvent_PTR() *QDragMoveEvent
}

func PointerFromQDragMoveEvent(ptr QDragMoveEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDragMoveEvent_PTR().Pointer()
	}
	return nil
}

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

func newQDragMoveEventFromPointer(ptr unsafe.Pointer) *QDragMoveEvent {
	var n = NewQDragMoveEventFromPointer(ptr)
	return n
}

func (ptr *QDragMoveEvent) QDragMoveEvent_PTR() *QDragMoveEvent {
	return ptr
}

func NewQDragMoveEvent(pos core.QPoint_ITF, actions core.Qt__DropAction, data core.QMimeData_ITF, buttons core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier, ty core.QEvent__Type) *QDragMoveEvent {
	defer qt.Recovering("QDragMoveEvent::QDragMoveEvent")

	return newQDragMoveEventFromPointer(C.QDragMoveEvent_NewQDragMoveEvent(core.PointerFromQPoint(pos), C.int(actions), core.PointerFromQMimeData(data), C.int(buttons), C.int(modifiers), C.int(ty)))
}

func (ptr *QDragMoveEvent) Accept2() {
	defer qt.Recovering("QDragMoveEvent::accept")

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

func (ptr *QDragMoveEvent) Accept(rectangle core.QRect_ITF) {
	defer qt.Recovering("QDragMoveEvent::accept")

	if ptr.Pointer() != nil {
		C.QDragMoveEvent_Accept(ptr.Pointer(), core.PointerFromQRect(rectangle))
	}
}

func (ptr *QDragMoveEvent) AnswerRect() *core.QRect {
	defer qt.Recovering("QDragMoveEvent::answerRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QDragMoveEvent_AnswerRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDragMoveEvent) Ignore2() {
	defer qt.Recovering("QDragMoveEvent::ignore")

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

func (ptr *QDragMoveEvent) Ignore(rectangle core.QRect_ITF) {
	defer qt.Recovering("QDragMoveEvent::ignore")

	if ptr.Pointer() != nil {
		C.QDragMoveEvent_Ignore(ptr.Pointer(), core.PointerFromQRect(rectangle))
	}
}

func (ptr *QDragMoveEvent) DestroyQDragMoveEvent() {
	defer qt.Recovering("QDragMoveEvent::~QDragMoveEvent")

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

type QDropEvent struct {
	core.QEvent
}

type QDropEvent_ITF interface {
	core.QEvent_ITF
	QDropEvent_PTR() *QDropEvent
}

func PointerFromQDropEvent(ptr QDropEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QDropEvent_PTR().Pointer()
	}
	return nil
}

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

func newQDropEventFromPointer(ptr unsafe.Pointer) *QDropEvent {
	var n = NewQDropEventFromPointer(ptr)
	return n
}

func (ptr *QDropEvent) QDropEvent_PTR() *QDropEvent {
	return ptr
}

func (ptr *QDropEvent) SetDropAction(action core.Qt__DropAction) {
	defer qt.Recovering("QDropEvent::setDropAction")

	if ptr.Pointer() != nil {
		C.QDropEvent_SetDropAction(ptr.Pointer(), C.int(action))
	}
}

func NewQDropEvent(pos core.QPointF_ITF, actions core.Qt__DropAction, data core.QMimeData_ITF, buttons core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier, ty core.QEvent__Type) *QDropEvent {
	defer qt.Recovering("QDropEvent::QDropEvent")

	return newQDropEventFromPointer(C.QDropEvent_NewQDropEvent(core.PointerFromQPointF(pos), C.int(actions), core.PointerFromQMimeData(data), C.int(buttons), C.int(modifiers), C.int(ty)))
}

func (ptr *QDropEvent) AcceptProposedAction() {
	defer qt.Recovering("QDropEvent::acceptProposedAction")

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

func (ptr *QDropEvent) DropAction() core.Qt__DropAction {
	defer qt.Recovering("QDropEvent::dropAction")

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

func (ptr *QDropEvent) KeyboardModifiers() core.Qt__KeyboardModifier {
	defer qt.Recovering("QDropEvent::keyboardModifiers")

	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QDropEvent_KeyboardModifiers(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDropEvent) MimeData() *core.QMimeData {
	defer qt.Recovering("QDropEvent::mimeData")

	if ptr.Pointer() != nil {
		return core.NewQMimeDataFromPointer(C.QDropEvent_MimeData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDropEvent) MouseButtons() core.Qt__MouseButton {
	defer qt.Recovering("QDropEvent::mouseButtons")

	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QDropEvent_MouseButtons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QDropEvent) Pos() *core.QPoint {
	defer qt.Recovering("QDropEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QDropEvent_Pos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QDropEvent) PossibleActions() core.Qt__DropAction {
	defer qt.Recovering("QDropEvent::possibleActions")

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

func (ptr *QDropEvent) ProposedAction() core.Qt__DropAction {
	defer qt.Recovering("QDropEvent::proposedAction")

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

func (ptr *QDropEvent) Source() *core.QObject {
	defer qt.Recovering("QDropEvent::source")

	if ptr.Pointer() != nil {
		return core.NewQObjectFromPointer(C.QDropEvent_Source(ptr.Pointer()))
	}
	return nil
}

type QEnterEvent struct {
	core.QEvent
}

type QEnterEvent_ITF interface {
	core.QEvent_ITF
	QEnterEvent_PTR() *QEnterEvent
}

func PointerFromQEnterEvent(ptr QEnterEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QEnterEvent_PTR().Pointer()
	}
	return nil
}

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

func newQEnterEventFromPointer(ptr unsafe.Pointer) *QEnterEvent {
	var n = NewQEnterEventFromPointer(ptr)
	return n
}

func (ptr *QEnterEvent) QEnterEvent_PTR() *QEnterEvent {
	return ptr
}

func NewQEnterEvent(localPos core.QPointF_ITF, windowPos core.QPointF_ITF, screenPos core.QPointF_ITF) *QEnterEvent {
	defer qt.Recovering("QEnterEvent::QEnterEvent")

	return newQEnterEventFromPointer(C.QEnterEvent_NewQEnterEvent(core.PointerFromQPointF(localPos), core.PointerFromQPointF(windowPos), core.PointerFromQPointF(screenPos)))
}

func (ptr *QEnterEvent) GlobalPos() *core.QPoint {
	defer qt.Recovering("QEnterEvent::globalPos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QEnterEvent_GlobalPos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QEnterEvent) GlobalX() int {
	defer qt.Recovering("QEnterEvent::globalX")

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

func (ptr *QEnterEvent) GlobalY() int {
	defer qt.Recovering("QEnterEvent::globalY")

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

func (ptr *QEnterEvent) Pos() *core.QPoint {
	defer qt.Recovering("QEnterEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QEnterEvent_Pos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QEnterEvent) X() int {
	defer qt.Recovering("QEnterEvent::x")

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

func (ptr *QEnterEvent) Y() int {
	defer qt.Recovering("QEnterEvent::y")

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

type QExposeEvent struct {
	core.QEvent
}

type QExposeEvent_ITF interface {
	core.QEvent_ITF
	QExposeEvent_PTR() *QExposeEvent
}

func PointerFromQExposeEvent(ptr QExposeEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QExposeEvent_PTR().Pointer()
	}
	return nil
}

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

func newQExposeEventFromPointer(ptr unsafe.Pointer) *QExposeEvent {
	var n = NewQExposeEventFromPointer(ptr)
	return n
}

func (ptr *QExposeEvent) QExposeEvent_PTR() *QExposeEvent {
	return ptr
}

func NewQExposeEvent(exposeRegion QRegion_ITF) *QExposeEvent {
	defer qt.Recovering("QExposeEvent::QExposeEvent")

	return newQExposeEventFromPointer(C.QExposeEvent_NewQExposeEvent(PointerFromQRegion(exposeRegion)))
}

func (ptr *QExposeEvent) Region() *QRegion {
	defer qt.Recovering("QExposeEvent::region")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QExposeEvent_Region(ptr.Pointer()))
	}
	return nil
}

type QFileOpenEvent struct {
	core.QEvent
}

type QFileOpenEvent_ITF interface {
	core.QEvent_ITF
	QFileOpenEvent_PTR() *QFileOpenEvent
}

func PointerFromQFileOpenEvent(ptr QFileOpenEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFileOpenEvent_PTR().Pointer()
	}
	return nil
}

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

func newQFileOpenEventFromPointer(ptr unsafe.Pointer) *QFileOpenEvent {
	var n = NewQFileOpenEventFromPointer(ptr)
	return n
}

func (ptr *QFileOpenEvent) QFileOpenEvent_PTR() *QFileOpenEvent {
	return ptr
}

func (ptr *QFileOpenEvent) OpenFile(file core.QFile_ITF, flags core.QIODevice__OpenModeFlag) bool {
	defer qt.Recovering("QFileOpenEvent::openFile")

	if ptr.Pointer() != nil {
		return C.QFileOpenEvent_OpenFile(ptr.Pointer(), core.PointerFromQFile(file), C.int(flags)) != 0
	}
	return false
}

func (ptr *QFileOpenEvent) File() string {
	defer qt.Recovering("QFileOpenEvent::file")

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

func (ptr *QFileOpenEvent) Url() *core.QUrl {
	defer qt.Recovering("QFileOpenEvent::url")

	if ptr.Pointer() != nil {
		return core.NewQUrlFromPointer(C.QFileOpenEvent_Url(ptr.Pointer()))
	}
	return nil
}

type QFocusEvent struct {
	core.QEvent
}

type QFocusEvent_ITF interface {
	core.QEvent_ITF
	QFocusEvent_PTR() *QFocusEvent
}

func PointerFromQFocusEvent(ptr QFocusEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFocusEvent_PTR().Pointer()
	}
	return nil
}

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

func newQFocusEventFromPointer(ptr unsafe.Pointer) *QFocusEvent {
	var n = NewQFocusEventFromPointer(ptr)
	return n
}

func (ptr *QFocusEvent) QFocusEvent_PTR() *QFocusEvent {
	return ptr
}

func NewQFocusEvent(ty core.QEvent__Type, reason core.Qt__FocusReason) *QFocusEvent {
	defer qt.Recovering("QFocusEvent::QFocusEvent")

	return newQFocusEventFromPointer(C.QFocusEvent_NewQFocusEvent(C.int(ty), C.int(reason)))
}

func (ptr *QFocusEvent) GotFocus() bool {
	defer qt.Recovering("QFocusEvent::gotFocus")

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

func (ptr *QFocusEvent) LostFocus() bool {
	defer qt.Recovering("QFocusEvent::lostFocus")

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

func (ptr *QFocusEvent) Reason() core.Qt__FocusReason {
	defer qt.Recovering("QFocusEvent::reason")

	if ptr.Pointer() != nil {
		return core.Qt__FocusReason(C.QFocusEvent_Reason(ptr.Pointer()))
	}
	return 0
}

type QFont struct {
	ptr unsafe.Pointer
}

type QFont_ITF interface {
	QFont_PTR() *QFont
}

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

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

func PointerFromQFont(ptr QFont_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFont_PTR().Pointer()
	}
	return nil
}

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

func newQFontFromPointer(ptr unsafe.Pointer) *QFont {
	var n = NewQFontFromPointer(ptr)
	return n
}

func (ptr *QFont) QFont_PTR() *QFont {
	return ptr
}

//QFont::Capitalization
type QFont__Capitalization int64

const (
	QFont__MixedCase    = QFont__Capitalization(0)
	QFont__AllUppercase = QFont__Capitalization(1)
	QFont__AllLowercase = QFont__Capitalization(2)
	QFont__SmallCaps    = QFont__Capitalization(3)
	QFont__Capitalize   = QFont__Capitalization(4)
)

//QFont::HintingPreference
type QFont__HintingPreference int64

const (
	QFont__PreferDefaultHinting  = QFont__HintingPreference(0)
	QFont__PreferNoHinting       = QFont__HintingPreference(1)
	QFont__PreferVerticalHinting = QFont__HintingPreference(2)
	QFont__PreferFullHinting     = QFont__HintingPreference(3)
)

//QFont::SpacingType
type QFont__SpacingType int64

const (
	QFont__PercentageSpacing = QFont__SpacingType(0)
	QFont__AbsoluteSpacing   = QFont__SpacingType(1)
)

//QFont::Stretch
type QFont__Stretch int64

const (
	QFont__UltraCondensed = QFont__Stretch(50)
	QFont__ExtraCondensed = QFont__Stretch(62)
	QFont__Condensed      = QFont__Stretch(75)
	QFont__SemiCondensed  = QFont__Stretch(87)
	QFont__Unstretched    = QFont__Stretch(100)
	QFont__SemiExpanded   = QFont__Stretch(112)
	QFont__Expanded       = QFont__Stretch(125)
	QFont__ExtraExpanded  = QFont__Stretch(150)
	QFont__UltraExpanded  = QFont__Stretch(200)
)

//QFont::Style
type QFont__Style int64

var (
	QFont__StyleNormal  = QFont__Style(0)
	QFont__StyleItalic  = QFont__Style(1)
	QFont__StyleOblique = QFont__Style(2)
)

//QFont::StyleHint
type QFont__StyleHint int64

var (
	QFont__Helvetica  = QFont__StyleHint(0)
	QFont__SansSerif  = QFont__StyleHint(QFont__Helvetica)
	QFont__Times      = QFont__StyleHint(C.QFont_Times_Type())
	QFont__Serif      = QFont__StyleHint(QFont__Times)
	QFont__Courier    = QFont__StyleHint(C.QFont_Courier_Type())
	QFont__TypeWriter = QFont__StyleHint(QFont__Courier)
	QFont__OldEnglish = QFont__StyleHint(C.QFont_OldEnglish_Type())
	QFont__Decorative = QFont__StyleHint(QFont__OldEnglish)
	QFont__System     = QFont__StyleHint(C.QFont_System_Type())
	QFont__AnyStyle   = QFont__StyleHint(C.QFont_AnyStyle_Type())
	QFont__Cursive    = QFont__StyleHint(C.QFont_Cursive_Type())
	QFont__Monospace  = QFont__StyleHint(C.QFont_Monospace_Type())
	QFont__Fantasy    = QFont__StyleHint(C.QFont_Fantasy_Type())
)

//QFont::StyleStrategy
type QFont__StyleStrategy int64

var (
	QFont__PreferDefault       = QFont__StyleStrategy(0x0001)
	QFont__PreferBitmap        = QFont__StyleStrategy(0x0002)
	QFont__PreferDevice        = QFont__StyleStrategy(0x0004)
	QFont__PreferOutline       = QFont__StyleStrategy(0x0008)
	QFont__ForceOutline        = QFont__StyleStrategy(0x0010)
	QFont__PreferMatch         = QFont__StyleStrategy(0x0020)
	QFont__PreferQuality       = QFont__StyleStrategy(0x0040)
	QFont__PreferAntialias     = QFont__StyleStrategy(0x0080)
	QFont__NoAntialias         = QFont__StyleStrategy(0x0100)
	QFont__OpenGLCompatible    = QFont__StyleStrategy(0x0200)
	QFont__ForceIntegerMetrics = QFont__StyleStrategy(0x0400)
	QFont__NoSubpixelAntialias = QFont__StyleStrategy(0x0800)
	QFont__NoFontMerging       = QFont__StyleStrategy(0x8000)
)

//QFont::Weight
type QFont__Weight int64

const (
	QFont__Thin       = QFont__Weight(0)
	QFont__ExtraLight = QFont__Weight(12)
	QFont__Light      = QFont__Weight(25)
	QFont__Normal     = QFont__Weight(50)
	QFont__Medium     = QFont__Weight(57)
	QFont__DemiBold   = QFont__Weight(63)
	QFont__Bold       = QFont__Weight(75)
	QFont__ExtraBold  = QFont__Weight(81)
	QFont__Black      = QFont__Weight(87)
)

func (ptr *QFont) DefaultFamily() string {
	defer qt.Recovering("QFont::defaultFamily")

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

func (ptr *QFont) LastResortFamily() string {
	defer qt.Recovering("QFont::lastResortFamily")

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

func (ptr *QFont) LastResortFont() string {
	defer qt.Recovering("QFont::lastResortFont")

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

func NewQFont() *QFont {
	defer qt.Recovering("QFont::QFont")

	return newQFontFromPointer(C.QFont_NewQFont())
}

func NewQFont4(font QFont_ITF) *QFont {
	defer qt.Recovering("QFont::QFont")

	return newQFontFromPointer(C.QFont_NewQFont4(PointerFromQFont(font)))
}

func NewQFont3(font QFont_ITF, pd QPaintDevice_ITF) *QFont {
	defer qt.Recovering("QFont::QFont")

	return newQFontFromPointer(C.QFont_NewQFont3(PointerFromQFont(font), PointerFromQPaintDevice(pd)))
}

func NewQFont2(family string, pointSize int, weight int, italic bool) *QFont {
	defer qt.Recovering("QFont::QFont")

	return newQFontFromPointer(C.QFont_NewQFont2(C.CString(family), C.int(pointSize), C.int(weight), C.int(qt.GoBoolToInt(italic))))
}

func (ptr *QFont) Bold() bool {
	defer qt.Recovering("QFont::bold")

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

func (ptr *QFont) Capitalization() QFont__Capitalization {
	defer qt.Recovering("QFont::capitalization")

	if ptr.Pointer() != nil {
		return QFont__Capitalization(C.QFont_Capitalization(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFont) ExactMatch() bool {
	defer qt.Recovering("QFont::exactMatch")

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

func (ptr *QFont) Family() string {
	defer qt.Recovering("QFont::family")

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

func (ptr *QFont) FixedPitch() bool {
	defer qt.Recovering("QFont::fixedPitch")

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

func (ptr *QFont) FromString(descrip string) bool {
	defer qt.Recovering("QFont::fromString")

	if ptr.Pointer() != nil {
		return C.QFont_FromString(ptr.Pointer(), C.CString(descrip)) != 0
	}
	return false
}

func (ptr *QFont) HintingPreference() QFont__HintingPreference {
	defer qt.Recovering("QFont::hintingPreference")

	if ptr.Pointer() != nil {
		return QFont__HintingPreference(C.QFont_HintingPreference(ptr.Pointer()))
	}
	return 0
}

func QFont_InsertSubstitution(familyName string, substituteName string) {
	defer qt.Recovering("QFont::insertSubstitution")

	C.QFont_QFont_InsertSubstitution(C.CString(familyName), C.CString(substituteName))
}

func QFont_InsertSubstitutions(familyName string, substituteNames []string) {
	defer qt.Recovering("QFont::insertSubstitutions")

	C.QFont_QFont_InsertSubstitutions(C.CString(familyName), C.CString(strings.Join(substituteNames, "|")))
}

func (ptr *QFont) IsCopyOf(f QFont_ITF) bool {
	defer qt.Recovering("QFont::isCopyOf")

	if ptr.Pointer() != nil {
		return C.QFont_IsCopyOf(ptr.Pointer(), PointerFromQFont(f)) != 0
	}
	return false
}

func (ptr *QFont) Italic() bool {
	defer qt.Recovering("QFont::italic")

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

func (ptr *QFont) Kerning() bool {
	defer qt.Recovering("QFont::kerning")

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

func (ptr *QFont) Key() string {
	defer qt.Recovering("QFont::key")

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

func (ptr *QFont) LetterSpacing() float64 {
	defer qt.Recovering("QFont::letterSpacing")

	if ptr.Pointer() != nil {
		return float64(C.QFont_LetterSpacing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFont) LetterSpacingType() QFont__SpacingType {
	defer qt.Recovering("QFont::letterSpacingType")

	if ptr.Pointer() != nil {
		return QFont__SpacingType(C.QFont_LetterSpacingType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFont) Overline() bool {
	defer qt.Recovering("QFont::overline")

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

func (ptr *QFont) PixelSize() int {
	defer qt.Recovering("QFont::pixelSize")

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

func (ptr *QFont) PointSize() int {
	defer qt.Recovering("QFont::pointSize")

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

func (ptr *QFont) PointSizeF() float64 {
	defer qt.Recovering("QFont::pointSizeF")

	if ptr.Pointer() != nil {
		return float64(C.QFont_PointSizeF(ptr.Pointer()))
	}
	return 0
}

func QFont_RemoveSubstitutions(familyName string) {
	defer qt.Recovering("QFont::removeSubstitutions")

	C.QFont_QFont_RemoveSubstitutions(C.CString(familyName))
}

func (ptr *QFont) SetBold(enable bool) {
	defer qt.Recovering("QFont::setBold")

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

func (ptr *QFont) SetCapitalization(caps QFont__Capitalization) {
	defer qt.Recovering("QFont::setCapitalization")

	if ptr.Pointer() != nil {
		C.QFont_SetCapitalization(ptr.Pointer(), C.int(caps))
	}
}

func (ptr *QFont) SetFamily(family string) {
	defer qt.Recovering("QFont::setFamily")

	if ptr.Pointer() != nil {
		C.QFont_SetFamily(ptr.Pointer(), C.CString(family))
	}
}

func (ptr *QFont) SetFixedPitch(enable bool) {
	defer qt.Recovering("QFont::setFixedPitch")

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

func (ptr *QFont) SetHintingPreference(hintingPreference QFont__HintingPreference) {
	defer qt.Recovering("QFont::setHintingPreference")

	if ptr.Pointer() != nil {
		C.QFont_SetHintingPreference(ptr.Pointer(), C.int(hintingPreference))
	}
}

func (ptr *QFont) SetItalic(enable bool) {
	defer qt.Recovering("QFont::setItalic")

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

func (ptr *QFont) SetKerning(enable bool) {
	defer qt.Recovering("QFont::setKerning")

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

func (ptr *QFont) SetLetterSpacing(ty QFont__SpacingType, spacing float64) {
	defer qt.Recovering("QFont::setLetterSpacing")

	if ptr.Pointer() != nil {
		C.QFont_SetLetterSpacing(ptr.Pointer(), C.int(ty), C.double(spacing))
	}
}

func (ptr *QFont) SetOverline(enable bool) {
	defer qt.Recovering("QFont::setOverline")

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

func (ptr *QFont) SetPixelSize(pixelSize int) {
	defer qt.Recovering("QFont::setPixelSize")

	if ptr.Pointer() != nil {
		C.QFont_SetPixelSize(ptr.Pointer(), C.int(pixelSize))
	}
}

func (ptr *QFont) SetPointSize(pointSize int) {
	defer qt.Recovering("QFont::setPointSize")

	if ptr.Pointer() != nil {
		C.QFont_SetPointSize(ptr.Pointer(), C.int(pointSize))
	}
}

func (ptr *QFont) SetPointSizeF(pointSize float64) {
	defer qt.Recovering("QFont::setPointSizeF")

	if ptr.Pointer() != nil {
		C.QFont_SetPointSizeF(ptr.Pointer(), C.double(pointSize))
	}
}

func (ptr *QFont) SetStretch(factor int) {
	defer qt.Recovering("QFont::setStretch")

	if ptr.Pointer() != nil {
		C.QFont_SetStretch(ptr.Pointer(), C.int(factor))
	}
}

func (ptr *QFont) SetStrikeOut(enable bool) {
	defer qt.Recovering("QFont::setStrikeOut")

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

func (ptr *QFont) SetStyle(style QFont__Style) {
	defer qt.Recovering("QFont::setStyle")

	if ptr.Pointer() != nil {
		C.QFont_SetStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QFont) SetStyleHint(hint QFont__StyleHint, strategy QFont__StyleStrategy) {
	defer qt.Recovering("QFont::setStyleHint")

	if ptr.Pointer() != nil {
		C.QFont_SetStyleHint(ptr.Pointer(), C.int(hint), C.int(strategy))
	}
}

func (ptr *QFont) SetStyleName(styleName string) {
	defer qt.Recovering("QFont::setStyleName")

	if ptr.Pointer() != nil {
		C.QFont_SetStyleName(ptr.Pointer(), C.CString(styleName))
	}
}

func (ptr *QFont) SetStyleStrategy(s QFont__StyleStrategy) {
	defer qt.Recovering("QFont::setStyleStrategy")

	if ptr.Pointer() != nil {
		C.QFont_SetStyleStrategy(ptr.Pointer(), C.int(s))
	}
}

func (ptr *QFont) SetUnderline(enable bool) {
	defer qt.Recovering("QFont::setUnderline")

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

func (ptr *QFont) SetWeight(weight int) {
	defer qt.Recovering("QFont::setWeight")

	if ptr.Pointer() != nil {
		C.QFont_SetWeight(ptr.Pointer(), C.int(weight))
	}
}

func (ptr *QFont) SetWordSpacing(spacing float64) {
	defer qt.Recovering("QFont::setWordSpacing")

	if ptr.Pointer() != nil {
		C.QFont_SetWordSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QFont) Stretch() int {
	defer qt.Recovering("QFont::stretch")

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

func (ptr *QFont) StrikeOut() bool {
	defer qt.Recovering("QFont::strikeOut")

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

func (ptr *QFont) Style() QFont__Style {
	defer qt.Recovering("QFont::style")

	if ptr.Pointer() != nil {
		return QFont__Style(C.QFont_Style(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFont) StyleHint() QFont__StyleHint {
	defer qt.Recovering("QFont::styleHint")

	if ptr.Pointer() != nil {
		return QFont__StyleHint(C.QFont_StyleHint(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFont) StyleName() string {
	defer qt.Recovering("QFont::styleName")

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

func (ptr *QFont) StyleStrategy() QFont__StyleStrategy {
	defer qt.Recovering("QFont::styleStrategy")

	if ptr.Pointer() != nil {
		return QFont__StyleStrategy(C.QFont_StyleStrategy(ptr.Pointer()))
	}
	return 0
}

func QFont_Substitute(familyName string) string {
	defer qt.Recovering("QFont::substitute")

	return C.GoString(C.QFont_QFont_Substitute(C.CString(familyName)))
}

func QFont_Substitutes(familyName string) []string {
	defer qt.Recovering("QFont::substitutes")

	return strings.Split(C.GoString(C.QFont_QFont_Substitutes(C.CString(familyName))), "|")
}

func QFont_Substitutions() []string {
	defer qt.Recovering("QFont::substitutions")

	return strings.Split(C.GoString(C.QFont_QFont_Substitutions()), "|")
}

func (ptr *QFont) Swap(other QFont_ITF) {
	defer qt.Recovering("QFont::swap")

	if ptr.Pointer() != nil {
		C.QFont_Swap(ptr.Pointer(), PointerFromQFont(other))
	}
}

func (ptr *QFont) ToString() string {
	defer qt.Recovering("QFont::toString")

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

func (ptr *QFont) Underline() bool {
	defer qt.Recovering("QFont::underline")

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

func (ptr *QFont) Weight() int {
	defer qt.Recovering("QFont::weight")

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

func (ptr *QFont) WordSpacing() float64 {
	defer qt.Recovering("QFont::wordSpacing")

	if ptr.Pointer() != nil {
		return float64(C.QFont_WordSpacing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFont) DestroyQFont() {
	defer qt.Recovering("QFont::~QFont")

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

type QFontDatabase struct {
	ptr unsafe.Pointer
}

type QFontDatabase_ITF interface {
	QFontDatabase_PTR() *QFontDatabase
}

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

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

func PointerFromQFontDatabase(ptr QFontDatabase_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFontDatabase_PTR().Pointer()
	}
	return nil
}

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

func newQFontDatabaseFromPointer(ptr unsafe.Pointer) *QFontDatabase {
	var n = NewQFontDatabaseFromPointer(ptr)
	return n
}

func (ptr *QFontDatabase) QFontDatabase_PTR() *QFontDatabase {
	return ptr
}

//QFontDatabase::SystemFont
type QFontDatabase__SystemFont int64

const (
	QFontDatabase__GeneralFont          = QFontDatabase__SystemFont(0)
	QFontDatabase__FixedFont            = QFontDatabase__SystemFont(1)
	QFontDatabase__TitleFont            = QFontDatabase__SystemFont(2)
	QFontDatabase__SmallestReadableFont = QFontDatabase__SystemFont(3)
)

//QFontDatabase::WritingSystem
type QFontDatabase__WritingSystem int64

var (
	QFontDatabase__Any                 = QFontDatabase__WritingSystem(0)
	QFontDatabase__Latin               = QFontDatabase__WritingSystem(1)
	QFontDatabase__Greek               = QFontDatabase__WritingSystem(2)
	QFontDatabase__Cyrillic            = QFontDatabase__WritingSystem(3)
	QFontDatabase__Armenian            = QFontDatabase__WritingSystem(4)
	QFontDatabase__Hebrew              = QFontDatabase__WritingSystem(5)
	QFontDatabase__Arabic              = QFontDatabase__WritingSystem(6)
	QFontDatabase__Syriac              = QFontDatabase__WritingSystem(7)
	QFontDatabase__Thaana              = QFontDatabase__WritingSystem(8)
	QFontDatabase__Devanagari          = QFontDatabase__WritingSystem(9)
	QFontDatabase__Bengali             = QFontDatabase__WritingSystem(10)
	QFontDatabase__Gurmukhi            = QFontDatabase__WritingSystem(11)
	QFontDatabase__Gujarati            = QFontDatabase__WritingSystem(12)
	QFontDatabase__Oriya               = QFontDatabase__WritingSystem(13)
	QFontDatabase__Tamil               = QFontDatabase__WritingSystem(14)
	QFontDatabase__Telugu              = QFontDatabase__WritingSystem(15)
	QFontDatabase__Kannada             = QFontDatabase__WritingSystem(16)
	QFontDatabase__Malayalam           = QFontDatabase__WritingSystem(17)
	QFontDatabase__Sinhala             = QFontDatabase__WritingSystem(18)
	QFontDatabase__Thai                = QFontDatabase__WritingSystem(19)
	QFontDatabase__Lao                 = QFontDatabase__WritingSystem(20)
	QFontDatabase__Tibetan             = QFontDatabase__WritingSystem(21)
	QFontDatabase__Myanmar             = QFontDatabase__WritingSystem(22)
	QFontDatabase__Georgian            = QFontDatabase__WritingSystem(23)
	QFontDatabase__Khmer               = QFontDatabase__WritingSystem(24)
	QFontDatabase__SimplifiedChinese   = QFontDatabase__WritingSystem(25)
	QFontDatabase__TraditionalChinese  = QFontDatabase__WritingSystem(26)
	QFontDatabase__Japanese            = QFontDatabase__WritingSystem(27)
	QFontDatabase__Korean              = QFontDatabase__WritingSystem(28)
	QFontDatabase__Vietnamese          = QFontDatabase__WritingSystem(29)
	QFontDatabase__Symbol              = QFontDatabase__WritingSystem(30)
	QFontDatabase__Other               = QFontDatabase__WritingSystem(QFontDatabase__Symbol)
	QFontDatabase__Ogham               = QFontDatabase__WritingSystem(C.QFontDatabase_Ogham_Type())
	QFontDatabase__Runic               = QFontDatabase__WritingSystem(C.QFontDatabase_Runic_Type())
	QFontDatabase__Nko                 = QFontDatabase__WritingSystem(C.QFontDatabase_Nko_Type())
	QFontDatabase__WritingSystemsCount = QFontDatabase__WritingSystem(C.QFontDatabase_WritingSystemsCount_Type())
)

func QFontDatabase_RemoveAllApplicationFonts() bool {
	defer qt.Recovering("QFontDatabase::removeAllApplicationFonts")

	return C.QFontDatabase_QFontDatabase_RemoveAllApplicationFonts() != 0
}

func QFontDatabase_RemoveApplicationFont(id int) bool {
	defer qt.Recovering("QFontDatabase::removeApplicationFont")

	return C.QFontDatabase_QFontDatabase_RemoveApplicationFont(C.int(id)) != 0
}

func NewQFontDatabase() *QFontDatabase {
	defer qt.Recovering("QFontDatabase::QFontDatabase")

	return newQFontDatabaseFromPointer(C.QFontDatabase_NewQFontDatabase())
}

func QFontDatabase_AddApplicationFont(fileName string) int {
	defer qt.Recovering("QFontDatabase::addApplicationFont")

	return int(C.QFontDatabase_QFontDatabase_AddApplicationFont(C.CString(fileName)))
}

func QFontDatabase_AddApplicationFontFromData(fontData core.QByteArray_ITF) int {
	defer qt.Recovering("QFontDatabase::addApplicationFontFromData")

	return int(C.QFontDatabase_QFontDatabase_AddApplicationFontFromData(core.PointerFromQByteArray(fontData)))
}

func QFontDatabase_ApplicationFontFamilies(id int) []string {
	defer qt.Recovering("QFontDatabase::applicationFontFamilies")

	return strings.Split(C.GoString(C.QFontDatabase_QFontDatabase_ApplicationFontFamilies(C.int(id))), "|")
}

func (ptr *QFontDatabase) Bold(family string, style string) bool {
	defer qt.Recovering("QFontDatabase::bold")

	if ptr.Pointer() != nil {
		return C.QFontDatabase_Bold(ptr.Pointer(), C.CString(family), C.CString(style)) != 0
	}
	return false
}

func (ptr *QFontDatabase) Families(writingSystem QFontDatabase__WritingSystem) []string {
	defer qt.Recovering("QFontDatabase::families")

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

func (ptr *QFontDatabase) IsBitmapScalable(family string, style string) bool {
	defer qt.Recovering("QFontDatabase::isBitmapScalable")

	if ptr.Pointer() != nil {
		return C.QFontDatabase_IsBitmapScalable(ptr.Pointer(), C.CString(family), C.CString(style)) != 0
	}
	return false
}

func (ptr *QFontDatabase) IsFixedPitch(family string, style string) bool {
	defer qt.Recovering("QFontDatabase::isFixedPitch")

	if ptr.Pointer() != nil {
		return C.QFontDatabase_IsFixedPitch(ptr.Pointer(), C.CString(family), C.CString(style)) != 0
	}
	return false
}

func (ptr *QFontDatabase) IsPrivateFamily(family string) bool {
	defer qt.Recovering("QFontDatabase::isPrivateFamily")

	if ptr.Pointer() != nil {
		return C.QFontDatabase_IsPrivateFamily(ptr.Pointer(), C.CString(family)) != 0
	}
	return false
}

func (ptr *QFontDatabase) IsScalable(family string, style string) bool {
	defer qt.Recovering("QFontDatabase::isScalable")

	if ptr.Pointer() != nil {
		return C.QFontDatabase_IsScalable(ptr.Pointer(), C.CString(family), C.CString(style)) != 0
	}
	return false
}

func (ptr *QFontDatabase) IsSmoothlyScalable(family string, style string) bool {
	defer qt.Recovering("QFontDatabase::isSmoothlyScalable")

	if ptr.Pointer() != nil {
		return C.QFontDatabase_IsSmoothlyScalable(ptr.Pointer(), C.CString(family), C.CString(style)) != 0
	}
	return false
}

func (ptr *QFontDatabase) Italic(family string, style string) bool {
	defer qt.Recovering("QFontDatabase::italic")

	if ptr.Pointer() != nil {
		return C.QFontDatabase_Italic(ptr.Pointer(), C.CString(family), C.CString(style)) != 0
	}
	return false
}

func (ptr *QFontDatabase) StyleString(font QFont_ITF) string {
	defer qt.Recovering("QFontDatabase::styleString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFontDatabase_StyleString(ptr.Pointer(), PointerFromQFont(font)))
	}
	return ""
}

func (ptr *QFontDatabase) StyleString2(fontInfo QFontInfo_ITF) string {
	defer qt.Recovering("QFontDatabase::styleString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFontDatabase_StyleString2(ptr.Pointer(), PointerFromQFontInfo(fontInfo)))
	}
	return ""
}

func (ptr *QFontDatabase) Styles(family string) []string {
	defer qt.Recovering("QFontDatabase::styles")

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

func (ptr *QFontDatabase) Weight(family string, style string) int {
	defer qt.Recovering("QFontDatabase::weight")

	if ptr.Pointer() != nil {
		return int(C.QFontDatabase_Weight(ptr.Pointer(), C.CString(family), C.CString(style)))
	}
	return 0
}

func QFontDatabase_WritingSystemName(writingSystem QFontDatabase__WritingSystem) string {
	defer qt.Recovering("QFontDatabase::writingSystemName")

	return C.GoString(C.QFontDatabase_QFontDatabase_WritingSystemName(C.int(writingSystem)))
}

func QFontDatabase_WritingSystemSample(writingSystem QFontDatabase__WritingSystem) string {
	defer qt.Recovering("QFontDatabase::writingSystemSample")

	return C.GoString(C.QFontDatabase_QFontDatabase_WritingSystemSample(C.int(writingSystem)))
}

type QFontInfo struct {
	ptr unsafe.Pointer
}

type QFontInfo_ITF interface {
	QFontInfo_PTR() *QFontInfo
}

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

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

func PointerFromQFontInfo(ptr QFontInfo_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFontInfo_PTR().Pointer()
	}
	return nil
}

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

func newQFontInfoFromPointer(ptr unsafe.Pointer) *QFontInfo {
	var n = NewQFontInfoFromPointer(ptr)
	return n
}

func (ptr *QFontInfo) QFontInfo_PTR() *QFontInfo {
	return ptr
}

func NewQFontInfo(font QFont_ITF) *QFontInfo {
	defer qt.Recovering("QFontInfo::QFontInfo")

	return newQFontInfoFromPointer(C.QFontInfo_NewQFontInfo(PointerFromQFont(font)))
}

func NewQFontInfo2(fi QFontInfo_ITF) *QFontInfo {
	defer qt.Recovering("QFontInfo::QFontInfo")

	return newQFontInfoFromPointer(C.QFontInfo_NewQFontInfo2(PointerFromQFontInfo(fi)))
}

func (ptr *QFontInfo) Bold() bool {
	defer qt.Recovering("QFontInfo::bold")

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

func (ptr *QFontInfo) ExactMatch() bool {
	defer qt.Recovering("QFontInfo::exactMatch")

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

func (ptr *QFontInfo) Family() string {
	defer qt.Recovering("QFontInfo::family")

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

func (ptr *QFontInfo) FixedPitch() bool {
	defer qt.Recovering("QFontInfo::fixedPitch")

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

func (ptr *QFontInfo) Italic() bool {
	defer qt.Recovering("QFontInfo::italic")

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

func (ptr *QFontInfo) PixelSize() int {
	defer qt.Recovering("QFontInfo::pixelSize")

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

func (ptr *QFontInfo) PointSize() int {
	defer qt.Recovering("QFontInfo::pointSize")

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

func (ptr *QFontInfo) PointSizeF() float64 {
	defer qt.Recovering("QFontInfo::pointSizeF")

	if ptr.Pointer() != nil {
		return float64(C.QFontInfo_PointSizeF(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontInfo) Style() QFont__Style {
	defer qt.Recovering("QFontInfo::style")

	if ptr.Pointer() != nil {
		return QFont__Style(C.QFontInfo_Style(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontInfo) StyleName() string {
	defer qt.Recovering("QFontInfo::styleName")

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

func (ptr *QFontInfo) Swap(other QFontInfo_ITF) {
	defer qt.Recovering("QFontInfo::swap")

	if ptr.Pointer() != nil {
		C.QFontInfo_Swap(ptr.Pointer(), PointerFromQFontInfo(other))
	}
}

func (ptr *QFontInfo) StyleHint() QFont__StyleHint {
	defer qt.Recovering("QFontInfo::styleHint")

	if ptr.Pointer() != nil {
		return QFont__StyleHint(C.QFontInfo_StyleHint(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontInfo) Weight() int {
	defer qt.Recovering("QFontInfo::weight")

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

func (ptr *QFontInfo) DestroyQFontInfo() {
	defer qt.Recovering("QFontInfo::~QFontInfo")

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

type QFontMetrics struct {
	ptr unsafe.Pointer
}

type QFontMetrics_ITF interface {
	QFontMetrics_PTR() *QFontMetrics
}

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

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

func PointerFromQFontMetrics(ptr QFontMetrics_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFontMetrics_PTR().Pointer()
	}
	return nil
}

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

func newQFontMetricsFromPointer(ptr unsafe.Pointer) *QFontMetrics {
	var n = NewQFontMetricsFromPointer(ptr)
	return n
}

func (ptr *QFontMetrics) QFontMetrics_PTR() *QFontMetrics {
	return ptr
}

func NewQFontMetrics(font QFont_ITF) *QFontMetrics {
	defer qt.Recovering("QFontMetrics::QFontMetrics")

	return newQFontMetricsFromPointer(C.QFontMetrics_NewQFontMetrics(PointerFromQFont(font)))
}

func NewQFontMetrics2(font QFont_ITF, paintdevice QPaintDevice_ITF) *QFontMetrics {
	defer qt.Recovering("QFontMetrics::QFontMetrics")

	return newQFontMetricsFromPointer(C.QFontMetrics_NewQFontMetrics2(PointerFromQFont(font), PointerFromQPaintDevice(paintdevice)))
}

func NewQFontMetrics3(fm QFontMetrics_ITF) *QFontMetrics {
	defer qt.Recovering("QFontMetrics::QFontMetrics")

	return newQFontMetricsFromPointer(C.QFontMetrics_NewQFontMetrics3(PointerFromQFontMetrics(fm)))
}

func (ptr *QFontMetrics) Ascent() int {
	defer qt.Recovering("QFontMetrics::ascent")

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

func (ptr *QFontMetrics) AverageCharWidth() int {
	defer qt.Recovering("QFontMetrics::averageCharWidth")

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

func (ptr *QFontMetrics) BoundingRect(ch core.QChar_ITF) *core.QRect {
	defer qt.Recovering("QFontMetrics::boundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QFontMetrics_BoundingRect(ptr.Pointer(), core.PointerFromQChar(ch)))
	}
	return nil
}

func (ptr *QFontMetrics) BoundingRect4(rect core.QRect_ITF, flags int, text string, tabStops int, tabArray int) *core.QRect {
	defer qt.Recovering("QFontMetrics::boundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QFontMetrics_BoundingRect4(ptr.Pointer(), core.PointerFromQRect(rect), C.int(flags), C.CString(text), C.int(tabStops), C.int(tabArray)))
	}
	return nil
}

func (ptr *QFontMetrics) BoundingRect2(text string) *core.QRect {
	defer qt.Recovering("QFontMetrics::boundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QFontMetrics_BoundingRect2(ptr.Pointer(), C.CString(text)))
	}
	return nil
}

func (ptr *QFontMetrics) BoundingRect3(x int, y int, width int, height int, flags int, text string, tabStops int, tabArray int) *core.QRect {
	defer qt.Recovering("QFontMetrics::boundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QFontMetrics_BoundingRect3(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), C.int(flags), C.CString(text), C.int(tabStops), C.int(tabArray)))
	}
	return nil
}

func (ptr *QFontMetrics) Descent() int {
	defer qt.Recovering("QFontMetrics::descent")

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

func (ptr *QFontMetrics) ElidedText(text string, mode core.Qt__TextElideMode, width int, flags int) string {
	defer qt.Recovering("QFontMetrics::elidedText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFontMetrics_ElidedText(ptr.Pointer(), C.CString(text), C.int(mode), C.int(width), C.int(flags)))
	}
	return ""
}

func (ptr *QFontMetrics) Height() int {
	defer qt.Recovering("QFontMetrics::height")

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

func (ptr *QFontMetrics) InFont(ch core.QChar_ITF) bool {
	defer qt.Recovering("QFontMetrics::inFont")

	if ptr.Pointer() != nil {
		return C.QFontMetrics_InFont(ptr.Pointer(), core.PointerFromQChar(ch)) != 0
	}
	return false
}

func (ptr *QFontMetrics) Leading() int {
	defer qt.Recovering("QFontMetrics::leading")

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

func (ptr *QFontMetrics) LeftBearing(ch core.QChar_ITF) int {
	defer qt.Recovering("QFontMetrics::leftBearing")

	if ptr.Pointer() != nil {
		return int(C.QFontMetrics_LeftBearing(ptr.Pointer(), core.PointerFromQChar(ch)))
	}
	return 0
}

func (ptr *QFontMetrics) LineSpacing() int {
	defer qt.Recovering("QFontMetrics::lineSpacing")

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

func (ptr *QFontMetrics) LineWidth() int {
	defer qt.Recovering("QFontMetrics::lineWidth")

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

func (ptr *QFontMetrics) MaxWidth() int {
	defer qt.Recovering("QFontMetrics::maxWidth")

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

func (ptr *QFontMetrics) MinLeftBearing() int {
	defer qt.Recovering("QFontMetrics::minLeftBearing")

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

func (ptr *QFontMetrics) MinRightBearing() int {
	defer qt.Recovering("QFontMetrics::minRightBearing")

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

func (ptr *QFontMetrics) OverlinePos() int {
	defer qt.Recovering("QFontMetrics::overlinePos")

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

func (ptr *QFontMetrics) RightBearing(ch core.QChar_ITF) int {
	defer qt.Recovering("QFontMetrics::rightBearing")

	if ptr.Pointer() != nil {
		return int(C.QFontMetrics_RightBearing(ptr.Pointer(), core.PointerFromQChar(ch)))
	}
	return 0
}

func (ptr *QFontMetrics) Size(flags int, text string, tabStops int, tabArray int) *core.QSize {
	defer qt.Recovering("QFontMetrics::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QFontMetrics_Size(ptr.Pointer(), C.int(flags), C.CString(text), C.int(tabStops), C.int(tabArray)))
	}
	return nil
}

func (ptr *QFontMetrics) StrikeOutPos() int {
	defer qt.Recovering("QFontMetrics::strikeOutPos")

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

func (ptr *QFontMetrics) Swap(other QFontMetrics_ITF) {
	defer qt.Recovering("QFontMetrics::swap")

	if ptr.Pointer() != nil {
		C.QFontMetrics_Swap(ptr.Pointer(), PointerFromQFontMetrics(other))
	}
}

func (ptr *QFontMetrics) TightBoundingRect(text string) *core.QRect {
	defer qt.Recovering("QFontMetrics::tightBoundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QFontMetrics_TightBoundingRect(ptr.Pointer(), C.CString(text)))
	}
	return nil
}

func (ptr *QFontMetrics) UnderlinePos() int {
	defer qt.Recovering("QFontMetrics::underlinePos")

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

func (ptr *QFontMetrics) Width3(ch core.QChar_ITF) int {
	defer qt.Recovering("QFontMetrics::width")

	if ptr.Pointer() != nil {
		return int(C.QFontMetrics_Width3(ptr.Pointer(), core.PointerFromQChar(ch)))
	}
	return 0
}

func (ptr *QFontMetrics) Width(text string, len int) int {
	defer qt.Recovering("QFontMetrics::width")

	if ptr.Pointer() != nil {
		return int(C.QFontMetrics_Width(ptr.Pointer(), C.CString(text), C.int(len)))
	}
	return 0
}

func (ptr *QFontMetrics) XHeight() int {
	defer qt.Recovering("QFontMetrics::xHeight")

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

func (ptr *QFontMetrics) DestroyQFontMetrics() {
	defer qt.Recovering("QFontMetrics::~QFontMetrics")

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

type QFontMetricsF struct {
	ptr unsafe.Pointer
}

type QFontMetricsF_ITF interface {
	QFontMetricsF_PTR() *QFontMetricsF
}

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

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

func PointerFromQFontMetricsF(ptr QFontMetricsF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QFontMetricsF_PTR().Pointer()
	}
	return nil
}

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

func newQFontMetricsFFromPointer(ptr unsafe.Pointer) *QFontMetricsF {
	var n = NewQFontMetricsFFromPointer(ptr)
	return n
}

func (ptr *QFontMetricsF) QFontMetricsF_PTR() *QFontMetricsF {
	return ptr
}

func NewQFontMetricsF(font QFont_ITF) *QFontMetricsF {
	defer qt.Recovering("QFontMetricsF::QFontMetricsF")

	return newQFontMetricsFFromPointer(C.QFontMetricsF_NewQFontMetricsF(PointerFromQFont(font)))
}

func NewQFontMetricsF2(font QFont_ITF, paintdevice QPaintDevice_ITF) *QFontMetricsF {
	defer qt.Recovering("QFontMetricsF::QFontMetricsF")

	return newQFontMetricsFFromPointer(C.QFontMetricsF_NewQFontMetricsF2(PointerFromQFont(font), PointerFromQPaintDevice(paintdevice)))
}

func NewQFontMetricsF3(fontMetrics QFontMetrics_ITF) *QFontMetricsF {
	defer qt.Recovering("QFontMetricsF::QFontMetricsF")

	return newQFontMetricsFFromPointer(C.QFontMetricsF_NewQFontMetricsF3(PointerFromQFontMetrics(fontMetrics)))
}

func NewQFontMetricsF4(fm QFontMetricsF_ITF) *QFontMetricsF {
	defer qt.Recovering("QFontMetricsF::QFontMetricsF")

	return newQFontMetricsFFromPointer(C.QFontMetricsF_NewQFontMetricsF4(PointerFromQFontMetricsF(fm)))
}

func (ptr *QFontMetricsF) Ascent() float64 {
	defer qt.Recovering("QFontMetricsF::ascent")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_Ascent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) AverageCharWidth() float64 {
	defer qt.Recovering("QFontMetricsF::averageCharWidth")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_AverageCharWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) Descent() float64 {
	defer qt.Recovering("QFontMetricsF::descent")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_Descent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) ElidedText(text string, mode core.Qt__TextElideMode, width float64, flags int) string {
	defer qt.Recovering("QFontMetricsF::elidedText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QFontMetricsF_ElidedText(ptr.Pointer(), C.CString(text), C.int(mode), C.double(width), C.int(flags)))
	}
	return ""
}

func (ptr *QFontMetricsF) Height() float64 {
	defer qt.Recovering("QFontMetricsF::height")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) InFont(ch core.QChar_ITF) bool {
	defer qt.Recovering("QFontMetricsF::inFont")

	if ptr.Pointer() != nil {
		return C.QFontMetricsF_InFont(ptr.Pointer(), core.PointerFromQChar(ch)) != 0
	}
	return false
}

func (ptr *QFontMetricsF) Leading() float64 {
	defer qt.Recovering("QFontMetricsF::leading")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_Leading(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) LeftBearing(ch core.QChar_ITF) float64 {
	defer qt.Recovering("QFontMetricsF::leftBearing")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_LeftBearing(ptr.Pointer(), core.PointerFromQChar(ch)))
	}
	return 0
}

func (ptr *QFontMetricsF) LineSpacing() float64 {
	defer qt.Recovering("QFontMetricsF::lineSpacing")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_LineSpacing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) LineWidth() float64 {
	defer qt.Recovering("QFontMetricsF::lineWidth")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_LineWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) MaxWidth() float64 {
	defer qt.Recovering("QFontMetricsF::maxWidth")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_MaxWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) MinLeftBearing() float64 {
	defer qt.Recovering("QFontMetricsF::minLeftBearing")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_MinLeftBearing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) MinRightBearing() float64 {
	defer qt.Recovering("QFontMetricsF::minRightBearing")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_MinRightBearing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) OverlinePos() float64 {
	defer qt.Recovering("QFontMetricsF::overlinePos")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_OverlinePos(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) RightBearing(ch core.QChar_ITF) float64 {
	defer qt.Recovering("QFontMetricsF::rightBearing")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_RightBearing(ptr.Pointer(), core.PointerFromQChar(ch)))
	}
	return 0
}

func (ptr *QFontMetricsF) StrikeOutPos() float64 {
	defer qt.Recovering("QFontMetricsF::strikeOutPos")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_StrikeOutPos(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) Swap(other QFontMetricsF_ITF) {
	defer qt.Recovering("QFontMetricsF::swap")

	if ptr.Pointer() != nil {
		C.QFontMetricsF_Swap(ptr.Pointer(), PointerFromQFontMetricsF(other))
	}
}

func (ptr *QFontMetricsF) UnderlinePos() float64 {
	defer qt.Recovering("QFontMetricsF::underlinePos")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_UnderlinePos(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) Width2(ch core.QChar_ITF) float64 {
	defer qt.Recovering("QFontMetricsF::width")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_Width2(ptr.Pointer(), core.PointerFromQChar(ch)))
	}
	return 0
}

func (ptr *QFontMetricsF) Width(text string) float64 {
	defer qt.Recovering("QFontMetricsF::width")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_Width(ptr.Pointer(), C.CString(text)))
	}
	return 0
}

func (ptr *QFontMetricsF) XHeight() float64 {
	defer qt.Recovering("QFontMetricsF::xHeight")

	if ptr.Pointer() != nil {
		return float64(C.QFontMetricsF_XHeight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QFontMetricsF) DestroyQFontMetricsF() {
	defer qt.Recovering("QFontMetricsF::~QFontMetricsF")

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

type QGenericMatrix struct {
	ptr unsafe.Pointer
}

type QGenericMatrix_ITF interface {
	QGenericMatrix_PTR() *QGenericMatrix
}

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

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

func PointerFromQGenericMatrix(ptr QGenericMatrix_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericMatrix_PTR().Pointer()
	}
	return nil
}

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

func newQGenericMatrixFromPointer(ptr unsafe.Pointer) *QGenericMatrix {
	var n = NewQGenericMatrixFromPointer(ptr)
	return n
}

func (ptr *QGenericMatrix) QGenericMatrix_PTR() *QGenericMatrix {
	return ptr
}

type QGenericPlugin struct {
	core.QObject
}

type QGenericPlugin_ITF interface {
	core.QObject_ITF
	QGenericPlugin_PTR() *QGenericPlugin
}

func PointerFromQGenericPlugin(ptr QGenericPlugin_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericPlugin_PTR().Pointer()
	}
	return nil
}

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

func newQGenericPluginFromPointer(ptr unsafe.Pointer) *QGenericPlugin {
	var n = NewQGenericPluginFromPointer(ptr)
	for len(n.ObjectName()) < len("QGenericPlugin_") {
		n.SetObjectName("QGenericPlugin_" + qt.Identifier())
	}
	return n
}

func (ptr *QGenericPlugin) QGenericPlugin_PTR() *QGenericPlugin {
	return ptr
}

type QGenericPluginFactory struct {
	ptr unsafe.Pointer
}

type QGenericPluginFactory_ITF interface {
	QGenericPluginFactory_PTR() *QGenericPluginFactory
}

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

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

func PointerFromQGenericPluginFactory(ptr QGenericPluginFactory_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGenericPluginFactory_PTR().Pointer()
	}
	return nil
}

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

func newQGenericPluginFactoryFromPointer(ptr unsafe.Pointer) *QGenericPluginFactory {
	var n = NewQGenericPluginFactoryFromPointer(ptr)
	return n
}

func (ptr *QGenericPluginFactory) QGenericPluginFactory_PTR() *QGenericPluginFactory {
	return ptr
}

func QGenericPluginFactory_Create(key string, specification string) *core.QObject {
	defer qt.Recovering("QGenericPluginFactory::create")

	return core.NewQObjectFromPointer(C.QGenericPluginFactory_QGenericPluginFactory_Create(C.CString(key), C.CString(specification)))
}

func QGenericPluginFactory_Keys() []string {
	defer qt.Recovering("QGenericPluginFactory::keys")

	return strings.Split(C.GoString(C.QGenericPluginFactory_QGenericPluginFactory_Keys()), "|")
}

type QGlyphRun struct {
	ptr unsafe.Pointer
}

type QGlyphRun_ITF interface {
	QGlyphRun_PTR() *QGlyphRun
}

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

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

func PointerFromQGlyphRun(ptr QGlyphRun_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGlyphRun_PTR().Pointer()
	}
	return nil
}

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

func newQGlyphRunFromPointer(ptr unsafe.Pointer) *QGlyphRun {
	var n = NewQGlyphRunFromPointer(ptr)
	return n
}

func (ptr *QGlyphRun) QGlyphRun_PTR() *QGlyphRun {
	return ptr
}

//QGlyphRun::GlyphRunFlag
type QGlyphRun__GlyphRunFlag int64

const (
	QGlyphRun__Overline      = QGlyphRun__GlyphRunFlag(0x01)
	QGlyphRun__Underline     = QGlyphRun__GlyphRunFlag(0x02)
	QGlyphRun__StrikeOut     = QGlyphRun__GlyphRunFlag(0x04)
	QGlyphRun__RightToLeft   = QGlyphRun__GlyphRunFlag(0x08)
	QGlyphRun__SplitLigature = QGlyphRun__GlyphRunFlag(0x10)
)

func NewQGlyphRun() *QGlyphRun {
	defer qt.Recovering("QGlyphRun::QGlyphRun")

	return newQGlyphRunFromPointer(C.QGlyphRun_NewQGlyphRun())
}

func NewQGlyphRun2(other QGlyphRun_ITF) *QGlyphRun {
	defer qt.Recovering("QGlyphRun::QGlyphRun")

	return newQGlyphRunFromPointer(C.QGlyphRun_NewQGlyphRun2(PointerFromQGlyphRun(other)))
}

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

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

func (ptr *QGlyphRun) Flags() QGlyphRun__GlyphRunFlag {
	defer qt.Recovering("QGlyphRun::flags")

	if ptr.Pointer() != nil {
		return QGlyphRun__GlyphRunFlag(C.QGlyphRun_Flags(ptr.Pointer()))
	}
	return 0
}

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

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

func (ptr *QGlyphRun) IsRightToLeft() bool {
	defer qt.Recovering("QGlyphRun::isRightToLeft")

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

func (ptr *QGlyphRun) Overline() bool {
	defer qt.Recovering("QGlyphRun::overline")

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

func (ptr *QGlyphRun) SetBoundingRect(boundingRect core.QRectF_ITF) {
	defer qt.Recovering("QGlyphRun::setBoundingRect")

	if ptr.Pointer() != nil {
		C.QGlyphRun_SetBoundingRect(ptr.Pointer(), core.PointerFromQRectF(boundingRect))
	}
}

func (ptr *QGlyphRun) SetFlag(flag QGlyphRun__GlyphRunFlag, enabled bool) {
	defer qt.Recovering("QGlyphRun::setFlag")

	if ptr.Pointer() != nil {
		C.QGlyphRun_SetFlag(ptr.Pointer(), C.int(flag), C.int(qt.GoBoolToInt(enabled)))
	}
}

func (ptr *QGlyphRun) SetFlags(flags QGlyphRun__GlyphRunFlag) {
	defer qt.Recovering("QGlyphRun::setFlags")

	if ptr.Pointer() != nil {
		C.QGlyphRun_SetFlags(ptr.Pointer(), C.int(flags))
	}
}

func (ptr *QGlyphRun) SetOverline(overline bool) {
	defer qt.Recovering("QGlyphRun::setOverline")

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

func (ptr *QGlyphRun) SetRawFont(rawFont QRawFont_ITF) {
	defer qt.Recovering("QGlyphRun::setRawFont")

	if ptr.Pointer() != nil {
		C.QGlyphRun_SetRawFont(ptr.Pointer(), PointerFromQRawFont(rawFont))
	}
}

func (ptr *QGlyphRun) SetRightToLeft(rightToLeft bool) {
	defer qt.Recovering("QGlyphRun::setRightToLeft")

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

func (ptr *QGlyphRun) SetStrikeOut(strikeOut bool) {
	defer qt.Recovering("QGlyphRun::setStrikeOut")

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

func (ptr *QGlyphRun) SetUnderline(underline bool) {
	defer qt.Recovering("QGlyphRun::setUnderline")

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

func (ptr *QGlyphRun) StrikeOut() bool {
	defer qt.Recovering("QGlyphRun::strikeOut")

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

func (ptr *QGlyphRun) Swap(other QGlyphRun_ITF) {
	defer qt.Recovering("QGlyphRun::swap")

	if ptr.Pointer() != nil {
		C.QGlyphRun_Swap(ptr.Pointer(), PointerFromQGlyphRun(other))
	}
}

func (ptr *QGlyphRun) Underline() bool {
	defer qt.Recovering("QGlyphRun::underline")

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

func (ptr *QGlyphRun) DestroyQGlyphRun() {
	defer qt.Recovering("QGlyphRun::~QGlyphRun")

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

type QGradient struct {
	ptr unsafe.Pointer
}

type QGradient_ITF interface {
	QGradient_PTR() *QGradient
}

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

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

func PointerFromQGradient(ptr QGradient_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGradient_PTR().Pointer()
	}
	return nil
}

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

func newQGradientFromPointer(ptr unsafe.Pointer) *QGradient {
	var n = NewQGradientFromPointer(ptr)
	return n
}

func (ptr *QGradient) QGradient_PTR() *QGradient {
	return ptr
}

//QGradient::CoordinateMode
type QGradient__CoordinateMode int64

const (
	QGradient__LogicalMode         = QGradient__CoordinateMode(0)
	QGradient__StretchToDeviceMode = QGradient__CoordinateMode(1)
	QGradient__ObjectBoundingMode  = QGradient__CoordinateMode(2)
)

//QGradient::Spread
type QGradient__Spread int64

const (
	QGradient__PadSpread     = QGradient__Spread(0)
	QGradient__ReflectSpread = QGradient__Spread(1)
	QGradient__RepeatSpread  = QGradient__Spread(2)
)

//QGradient::Type
type QGradient__Type int64

const (
	QGradient__LinearGradient  = QGradient__Type(0)
	QGradient__RadialGradient  = QGradient__Type(1)
	QGradient__ConicalGradient = QGradient__Type(2)
	QGradient__NoGradient      = QGradient__Type(3)
)

func (ptr *QGradient) SetColorAt(position float64, color QColor_ITF) {
	defer qt.Recovering("QGradient::setColorAt")

	if ptr.Pointer() != nil {
		C.QGradient_SetColorAt(ptr.Pointer(), C.double(position), PointerFromQColor(color))
	}
}

func (ptr *QGradient) CoordinateMode() QGradient__CoordinateMode {
	defer qt.Recovering("QGradient::coordinateMode")

	if ptr.Pointer() != nil {
		return QGradient__CoordinateMode(C.QGradient_CoordinateMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGradient) SetCoordinateMode(mode QGradient__CoordinateMode) {
	defer qt.Recovering("QGradient::setCoordinateMode")

	if ptr.Pointer() != nil {
		C.QGradient_SetCoordinateMode(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QGradient) SetSpread(method QGradient__Spread) {
	defer qt.Recovering("QGradient::setSpread")

	if ptr.Pointer() != nil {
		C.QGradient_SetSpread(ptr.Pointer(), C.int(method))
	}
}

func (ptr *QGradient) Spread() QGradient__Spread {
	defer qt.Recovering("QGradient::spread")

	if ptr.Pointer() != nil {
		return QGradient__Spread(C.QGradient_Spread(ptr.Pointer()))
	}
	return 0
}

func (ptr *QGradient) Type() QGradient__Type {
	defer qt.Recovering("QGradient::type")

	if ptr.Pointer() != nil {
		return QGradient__Type(C.QGradient_Type(ptr.Pointer()))
	}
	return 0
}

type QGuiApplication struct {
	core.QCoreApplication
}

type QGuiApplication_ITF interface {
	core.QCoreApplication_ITF
	QGuiApplication_PTR() *QGuiApplication
}

func PointerFromQGuiApplication(ptr QGuiApplication_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QGuiApplication_PTR().Pointer()
	}
	return nil
}

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

func newQGuiApplicationFromPointer(ptr unsafe.Pointer) *QGuiApplication {
	var n = NewQGuiApplicationFromPointer(ptr)
	for len(n.ObjectName()) < len("QGuiApplication_") {
		n.SetObjectName("QGuiApplication_" + qt.Identifier())
	}
	return n
}

func (ptr *QGuiApplication) QGuiApplication_PTR() *QGuiApplication {
	return ptr
}

func QGuiApplication_ApplicationDisplayName() string {
	defer qt.Recovering("QGuiApplication::applicationDisplayName")

	return C.GoString(C.QGuiApplication_QGuiApplication_ApplicationDisplayName())
}

func QGuiApplication_ApplicationState() core.Qt__ApplicationState {
	defer qt.Recovering("QGuiApplication::applicationState")

	return core.Qt__ApplicationState(C.QGuiApplication_QGuiApplication_ApplicationState())
}

func (ptr *QGuiApplication) IsSavingSession() bool {
	defer qt.Recovering("QGuiApplication::isSavingSession")

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

func (ptr *QGuiApplication) IsSessionRestored() bool {
	defer qt.Recovering("QGuiApplication::isSessionRestored")

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

func QGuiApplication_LayoutDirection() core.Qt__LayoutDirection {
	defer qt.Recovering("QGuiApplication::layoutDirection")

	return core.Qt__LayoutDirection(C.QGuiApplication_QGuiApplication_LayoutDirection())
}

func QGuiApplication_OverrideCursor() *QCursor {
	defer qt.Recovering("QGuiApplication::overrideCursor")

	return NewQCursorFromPointer(C.QGuiApplication_QGuiApplication_OverrideCursor())
}

func QGuiApplication_PlatformName() string {
	defer qt.Recovering("QGuiApplication::platformName")

	return C.GoString(C.QGuiApplication_QGuiApplication_PlatformName())
}

func QGuiApplication_QueryKeyboardModifiers() core.Qt__KeyboardModifier {
	defer qt.Recovering("QGuiApplication::queryKeyboardModifiers")

	return core.Qt__KeyboardModifier(C.QGuiApplication_QGuiApplication_QueryKeyboardModifiers())
}

func QGuiApplication_QuitOnLastWindowClosed() bool {
	defer qt.Recovering("QGuiApplication::quitOnLastWindowClosed")

	return C.QGuiApplication_QGuiApplication_QuitOnLastWindowClosed() != 0
}

func QGuiApplication_RestoreOverrideCursor() {
	defer qt.Recovering("QGuiApplication::restoreOverrideCursor")

	C.QGuiApplication_QGuiApplication_RestoreOverrideCursor()
}

func (ptr *QGuiApplication) SessionId() string {
	defer qt.Recovering("QGuiApplication::sessionId")

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

func (ptr *QGuiApplication) SessionKey() string {
	defer qt.Recovering("QGuiApplication::sessionKey")

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

func QGuiApplication_SetApplicationDisplayName(name string) {
	defer qt.Recovering("QGuiApplication::setApplicationDisplayName")

	C.QGuiApplication_QGuiApplication_SetApplicationDisplayName(C.CString(name))
}

func QGuiApplication_SetLayoutDirection(direction core.Qt__LayoutDirection) {
	defer qt.Recovering("QGuiApplication::setLayoutDirection")

	C.QGuiApplication_QGuiApplication_SetLayoutDirection(C.int(direction))
}

func QGuiApplication_SetOverrideCursor(cursor QCursor_ITF) {
	defer qt.Recovering("QGuiApplication::setOverrideCursor")

	C.QGuiApplication_QGuiApplication_SetOverrideCursor(PointerFromQCursor(cursor))
}

func QGuiApplication_SetQuitOnLastWindowClosed(quit bool) {
	defer qt.Recovering("QGuiApplication::setQuitOnLastWindowClosed")

	C.QGuiApplication_QGuiApplication_SetQuitOnLastWindowClosed(C.int(qt.GoBoolToInt(quit)))
}

func QGuiApplication_SetWindowIcon(icon QIcon_ITF) {
	defer qt.Recovering("QGuiApplication::setWindowIcon")

	C.QGuiApplication_QGuiApplication_SetWindowIcon(PointerFromQIcon(icon))
}

func QGuiApplication_WindowIcon() *QIcon {
	defer qt.Recovering("QGuiApplication::windowIcon")

	return NewQIconFromPointer(C.QGuiApplication_QGuiApplication_WindowIcon())
}

func NewQGuiApplication(argc int, argv []string) *QGuiApplication {
	defer qt.Recovering("QGuiApplication::QGuiApplication")

	return newQGuiApplicationFromPointer(C.QGuiApplication_NewQGuiApplication(C.int(argc), C.CString(strings.Join(argv, "|"))))
}

func (ptr *QGuiApplication) ConnectApplicationStateChanged(f func(state core.Qt__ApplicationState)) {
	defer qt.Recovering("connect QGuiApplication::applicationStateChanged")

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

func (ptr *QGuiApplication) DisconnectApplicationStateChanged() {
	defer qt.Recovering("disconnect QGuiApplication::applicationStateChanged")

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

//export callbackQGuiApplicationApplicationStateChanged
func callbackQGuiApplicationApplicationStateChanged(ptr unsafe.Pointer, ptrName *C.char, state C.int) {
	defer qt.Recovering("callback QGuiApplication::applicationStateChanged")

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

}

func (ptr *QGuiApplication) ApplicationStateChanged(state core.Qt__ApplicationState) {
	defer qt.Recovering("QGuiApplication::applicationStateChanged")

	if ptr.Pointer() != nil {
		C.QGuiApplication_ApplicationStateChanged(ptr.Pointer(), C.int(state))
	}
}

func QGuiApplication_ChangeOverrideCursor(cursor QCursor_ITF) {
	defer qt.Recovering("QGuiApplication::changeOverrideCursor")

	C.QGuiApplication_QGuiApplication_ChangeOverrideCursor(PointerFromQCursor(cursor))
}

func QGuiApplication_Clipboard() *QClipboard {
	defer qt.Recovering("QGuiApplication::clipboard")

	return NewQClipboardFromPointer(C.QGuiApplication_QGuiApplication_Clipboard())
}

func QGuiApplication_DesktopSettingsAware() bool {
	defer qt.Recovering("QGuiApplication::desktopSettingsAware")

	return C.QGuiApplication_QGuiApplication_DesktopSettingsAware() != 0
}

func (ptr *QGuiApplication) DevicePixelRatio() float64 {
	defer qt.Recovering("QGuiApplication::devicePixelRatio")

	if ptr.Pointer() != nil {
		return float64(C.QGuiApplication_DevicePixelRatio(ptr.Pointer()))
	}
	return 0
}

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

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

func QGuiApplication_Exec() int {
	defer qt.Recovering("QGuiApplication::exec")

	return int(C.QGuiApplication_QGuiApplication_Exec())
}

func QGuiApplication_FocusObject() *core.QObject {
	defer qt.Recovering("QGuiApplication::focusObject")

	return core.NewQObjectFromPointer(C.QGuiApplication_QGuiApplication_FocusObject())
}

func (ptr *QGuiApplication) ConnectFocusObjectChanged(f func(focusObject *core.QObject)) {
	defer qt.Recovering("connect QGuiApplication::focusObjectChanged")

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

func (ptr *QGuiApplication) DisconnectFocusObjectChanged() {
	defer qt.Recovering("disconnect QGuiApplication::focusObjectChanged")

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

//export callbackQGuiApplicationFocusObjectChanged
func callbackQGuiApplicationFocusObjectChanged(ptr unsafe.Pointer, ptrName *C.char, focusObject unsafe.Pointer) {
	defer qt.Recovering("callback QGuiApplication::focusObjectChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "focusObjectChanged"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(focusObject))
	}

}

func (ptr *QGuiApplication) FocusObjectChanged(focusObject core.QObject_ITF) {
	defer qt.Recovering("QGuiApplication::focusObjectChanged")

	if ptr.Pointer() != nil {
		C.QGuiApplication_FocusObjectChanged(ptr.Pointer(), core.PointerFromQObject(focusObject))
	}
}

func QGuiApplication_FocusWindow() *QWindow {
	defer qt.Recovering("QGuiApplication::focusWindow")

	return NewQWindowFromPointer(C.QGuiApplication_QGuiApplication_FocusWindow())
}

func (ptr *QGuiApplication) ConnectFocusWindowChanged(f func(focusWindow *QWindow)) {
	defer qt.Recovering("connect QGuiApplication::focusWindowChanged")

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

func (ptr *QGuiApplication) DisconnectFocusWindowChanged() {
	defer qt.Recovering("disconnect QGuiApplication::focusWindowChanged")

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

//export callbackQGuiApplicationFocusWindowChanged
func callbackQGuiApplicationFocusWindowChanged(ptr unsafe.Pointer, ptrName *C.char, focusWindow unsafe.Pointer) {
	defer qt.Recovering("callback QGuiApplication::focusWindowChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "focusWindowChanged"); signal != nil {
		signal.(func(*QWindow))(NewQWindowFromPointer(focusWindow))
	}

}

func (ptr *QGuiApplication) FocusWindowChanged(focusWindow QWindow_ITF) {
	defer qt.Recovering("QGuiApplication::focusWindowChanged")

	if ptr.Pointer() != nil {
		C.QGuiApplication_FocusWindowChanged(ptr.Pointer(), PointerFromQWindow(focusWindow))
	}
}

func (ptr *QGuiApplication) ConnectFontDatabaseChanged(f func()) {
	defer qt.Recovering("connect QGuiApplication::fontDatabaseChanged")

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

func (ptr *QGuiApplication) DisconnectFontDatabaseChanged() {
	defer qt.Recovering("disconnect QGuiApplication::fontDatabaseChanged")

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

//export callbackQGuiApplicationFontDatabaseChanged
func callbackQGuiApplicationFontDatabaseChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QGuiApplication::fontDatabaseChanged")

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

}

func (ptr *QGuiApplication) FontDatabaseChanged() {
	defer qt.Recovering("QGuiApplication::fontDatabaseChanged")

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

func QGuiApplication_InputMethod() *QInputMethod {
	defer qt.Recovering("QGuiApplication::inputMethod")

	return NewQInputMethodFromPointer(C.QGuiApplication_QGuiApplication_InputMethod())
}

func QGuiApplication_IsLeftToRight() bool {
	defer qt.Recovering("QGuiApplication::isLeftToRight")

	return C.QGuiApplication_QGuiApplication_IsLeftToRight() != 0
}

func QGuiApplication_IsRightToLeft() bool {
	defer qt.Recovering("QGuiApplication::isRightToLeft")

	return C.QGuiApplication_QGuiApplication_IsRightToLeft() != 0
}

func QGuiApplication_KeyboardModifiers() core.Qt__KeyboardModifier {
	defer qt.Recovering("QGuiApplication::keyboardModifiers")

	return core.Qt__KeyboardModifier(C.QGuiApplication_QGuiApplication_KeyboardModifiers())
}

func (ptr *QGuiApplication) ConnectLastWindowClosed(f func()) {
	defer qt.Recovering("connect QGuiApplication::lastWindowClosed")

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

func (ptr *QGuiApplication) DisconnectLastWindowClosed() {
	defer qt.Recovering("disconnect QGuiApplication::lastWindowClosed")

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

//export callbackQGuiApplicationLastWindowClosed
func callbackQGuiApplicationLastWindowClosed(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QGuiApplication::lastWindowClosed")

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

}

func (ptr *QGuiApplication) LastWindowClosed() {
	defer qt.Recovering("QGuiApplication::lastWindowClosed")

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

func (ptr *QGuiApplication) ConnectLayoutDirectionChanged(f func(direction core.Qt__LayoutDirection)) {
	defer qt.Recovering("connect QGuiApplication::layoutDirectionChanged")

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

func (ptr *QGuiApplication) DisconnectLayoutDirectionChanged() {
	defer qt.Recovering("disconnect QGuiApplication::layoutDirectionChanged")

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

//export callbackQGuiApplicationLayoutDirectionChanged
func callbackQGuiApplicationLayoutDirectionChanged(ptr unsafe.Pointer, ptrName *C.char, direction C.int) {
	defer qt.Recovering("callback QGuiApplication::layoutDirectionChanged")

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

}

func (ptr *QGuiApplication) LayoutDirectionChanged(direction core.Qt__LayoutDirection) {
	defer qt.Recovering("QGuiApplication::layoutDirectionChanged")

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

func QGuiApplication_ModalWindow() *QWindow {
	defer qt.Recovering("QGuiApplication::modalWindow")

	return NewQWindowFromPointer(C.QGuiApplication_QGuiApplication_ModalWindow())
}

func QGuiApplication_MouseButtons() core.Qt__MouseButton {
	defer qt.Recovering("QGuiApplication::mouseButtons")

	return core.Qt__MouseButton(C.QGuiApplication_QGuiApplication_MouseButtons())
}

func (ptr *QGuiApplication) Notify(object core.QObject_ITF, event core.QEvent_ITF) bool {
	defer qt.Recovering("QGuiApplication::notify")

	if ptr.Pointer() != nil {
		return C.QGuiApplication_Notify(ptr.Pointer(), core.PointerFromQObject(object), core.PointerFromQEvent(event)) != 0
	}
	return false
}

func QGuiApplication_PrimaryScreen() *QScreen {
	defer qt.Recovering("QGuiApplication::primaryScreen")

	return NewQScreenFromPointer(C.QGuiApplication_QGuiApplication_PrimaryScreen())
}

func (ptr *QGuiApplication) ConnectScreenAdded(f func(screen *QScreen)) {
	defer qt.Recovering("connect QGuiApplication::screenAdded")

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

func (ptr *QGuiApplication) DisconnectScreenAdded() {
	defer qt.Recovering("disconnect QGuiApplication::screenAdded")

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

//export callbackQGuiApplicationScreenAdded
func callbackQGuiApplicationScreenAdded(ptr unsafe.Pointer, ptrName *C.char, screen unsafe.Pointer) {
	defer qt.Recovering("callback QGuiApplication::screenAdded")

	if signal := qt.GetSignal(C.GoString(ptrName), "screenAdded"); signal != nil {
		signal.(func(*QScreen))(NewQScreenFromPointer(screen))
	}

}

func (ptr *QGuiApplication) ScreenAdded(screen QScreen_ITF) {
	defer qt.Recovering("QGuiApplication::screenAdded")

	if ptr.Pointer() != nil {
		C.QGuiApplication_ScreenAdded(ptr.Pointer(), PointerFromQScreen(screen))
	}
}

func (ptr *QGuiApplication) ConnectScreenRemoved(f func(screen *QScreen)) {
	defer qt.Recovering("connect QGuiApplication::screenRemoved")

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

func (ptr *QGuiApplication) DisconnectScreenRemoved() {
	defer qt.Recovering("disconnect QGuiApplication::screenRemoved")

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

//export callbackQGuiApplicationScreenRemoved
func callbackQGuiApplicationScreenRemoved(ptr unsafe.Pointer, ptrName *C.char, screen unsafe.Pointer) {
	defer qt.Recovering("callback QGuiApplication::screenRemoved")

	if signal := qt.GetSignal(C.GoString(ptrName), "screenRemoved"); signal != nil {
		signal.(func(*QScreen))(NewQScreenFromPointer(screen))
	}

}

func (ptr *QGuiApplication) ScreenRemoved(screen QScreen_ITF) {
	defer qt.Recovering("QGuiApplication::screenRemoved")

	if ptr.Pointer() != nil {
		C.QGuiApplication_ScreenRemoved(ptr.Pointer(), PointerFromQScreen(screen))
	}
}

func QGuiApplication_SetDesktopSettingsAware(on bool) {
	defer qt.Recovering("QGuiApplication::setDesktopSettingsAware")

	C.QGuiApplication_QGuiApplication_SetDesktopSettingsAware(C.int(qt.GoBoolToInt(on)))
}

func QGuiApplication_SetFont(font QFont_ITF) {
	defer qt.Recovering("QGuiApplication::setFont")

	C.QGuiApplication_QGuiApplication_SetFont(PointerFromQFont(font))
}

func QGuiApplication_SetPalette(pal QPalette_ITF) {
	defer qt.Recovering("QGuiApplication::setPalette")

	C.QGuiApplication_QGuiApplication_SetPalette(PointerFromQPalette(pal))
}

func QGuiApplication_StyleHints() *QStyleHints {
	defer qt.Recovering("QGuiApplication::styleHints")

	return NewQStyleHintsFromPointer(C.QGuiApplication_QGuiApplication_StyleHints())
}

func QGuiApplication_Sync() {
	defer qt.Recovering("QGuiApplication::sync")

	C.QGuiApplication_QGuiApplication_Sync()
}

func QGuiApplication_TopLevelAt(pos core.QPoint_ITF) *QWindow {
	defer qt.Recovering("QGuiApplication::topLevelAt")

	return NewQWindowFromPointer(C.QGuiApplication_QGuiApplication_TopLevelAt(core.PointerFromQPoint(pos)))
}

func (ptr *QGuiApplication) DestroyQGuiApplication() {
	defer qt.Recovering("QGuiApplication::~QGuiApplication")

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

type QHelpEvent struct {
	core.QEvent
}

type QHelpEvent_ITF interface {
	core.QEvent_ITF
	QHelpEvent_PTR() *QHelpEvent
}

func PointerFromQHelpEvent(ptr QHelpEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHelpEvent_PTR().Pointer()
	}
	return nil
}

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

func newQHelpEventFromPointer(ptr unsafe.Pointer) *QHelpEvent {
	var n = NewQHelpEventFromPointer(ptr)
	return n
}

func (ptr *QHelpEvent) QHelpEvent_PTR() *QHelpEvent {
	return ptr
}

func NewQHelpEvent(ty core.QEvent__Type, pos core.QPoint_ITF, globalPos core.QPoint_ITF) *QHelpEvent {
	defer qt.Recovering("QHelpEvent::QHelpEvent")

	return newQHelpEventFromPointer(C.QHelpEvent_NewQHelpEvent(C.int(ty), core.PointerFromQPoint(pos), core.PointerFromQPoint(globalPos)))
}

func (ptr *QHelpEvent) GlobalPos() *core.QPoint {
	defer qt.Recovering("QHelpEvent::globalPos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QHelpEvent_GlobalPos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QHelpEvent) GlobalX() int {
	defer qt.Recovering("QHelpEvent::globalX")

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

func (ptr *QHelpEvent) GlobalY() int {
	defer qt.Recovering("QHelpEvent::globalY")

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

func (ptr *QHelpEvent) Pos() *core.QPoint {
	defer qt.Recovering("QHelpEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QHelpEvent_Pos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QHelpEvent) X() int {
	defer qt.Recovering("QHelpEvent::x")

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

func (ptr *QHelpEvent) Y() int {
	defer qt.Recovering("QHelpEvent::y")

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

type QHideEvent struct {
	core.QEvent
}

type QHideEvent_ITF interface {
	core.QEvent_ITF
	QHideEvent_PTR() *QHideEvent
}

func PointerFromQHideEvent(ptr QHideEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHideEvent_PTR().Pointer()
	}
	return nil
}

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

func newQHideEventFromPointer(ptr unsafe.Pointer) *QHideEvent {
	var n = NewQHideEventFromPointer(ptr)
	return n
}

func (ptr *QHideEvent) QHideEvent_PTR() *QHideEvent {
	return ptr
}

func NewQHideEvent() *QHideEvent {
	defer qt.Recovering("QHideEvent::QHideEvent")

	return newQHideEventFromPointer(C.QHideEvent_NewQHideEvent())
}

type QHoverEvent struct {
	QInputEvent
}

type QHoverEvent_ITF interface {
	QInputEvent_ITF
	QHoverEvent_PTR() *QHoverEvent
}

func PointerFromQHoverEvent(ptr QHoverEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QHoverEvent_PTR().Pointer()
	}
	return nil
}

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

func newQHoverEventFromPointer(ptr unsafe.Pointer) *QHoverEvent {
	var n = NewQHoverEventFromPointer(ptr)
	return n
}

func (ptr *QHoverEvent) QHoverEvent_PTR() *QHoverEvent {
	return ptr
}

func NewQHoverEvent(ty core.QEvent__Type, pos core.QPointF_ITF, oldPos core.QPointF_ITF, modifiers core.Qt__KeyboardModifier) *QHoverEvent {
	defer qt.Recovering("QHoverEvent::QHoverEvent")

	return newQHoverEventFromPointer(C.QHoverEvent_NewQHoverEvent(C.int(ty), core.PointerFromQPointF(pos), core.PointerFromQPointF(oldPos), C.int(modifiers)))
}

func (ptr *QHoverEvent) OldPos() *core.QPoint {
	defer qt.Recovering("QHoverEvent::oldPos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QHoverEvent_OldPos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QHoverEvent) Pos() *core.QPoint {
	defer qt.Recovering("QHoverEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QHoverEvent_Pos(ptr.Pointer()))
	}
	return nil
}

type QIcon struct {
	ptr unsafe.Pointer
}

type QIcon_ITF interface {
	QIcon_PTR() *QIcon
}

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

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

func PointerFromQIcon(ptr QIcon_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIcon_PTR().Pointer()
	}
	return nil
}

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

func newQIconFromPointer(ptr unsafe.Pointer) *QIcon {
	var n = NewQIconFromPointer(ptr)
	return n
}

func (ptr *QIcon) QIcon_PTR() *QIcon {
	return ptr
}

//QIcon::Mode
type QIcon__Mode int64

const (
	QIcon__Normal   = QIcon__Mode(0)
	QIcon__Disabled = QIcon__Mode(1)
	QIcon__Active   = QIcon__Mode(2)
	QIcon__Selected = QIcon__Mode(3)
)

//QIcon::State
type QIcon__State int64

const (
	QIcon__On  = QIcon__State(0)
	QIcon__Off = QIcon__State(1)
)

func NewQIcon() *QIcon {
	defer qt.Recovering("QIcon::QIcon")

	return newQIconFromPointer(C.QIcon_NewQIcon())
}

func NewQIcon4(other QIcon_ITF) *QIcon {
	defer qt.Recovering("QIcon::QIcon")

	return newQIconFromPointer(C.QIcon_NewQIcon4(PointerFromQIcon(other)))
}

func NewQIcon6(engine QIconEngine_ITF) *QIcon {
	defer qt.Recovering("QIcon::QIcon")

	return newQIconFromPointer(C.QIcon_NewQIcon6(PointerFromQIconEngine(engine)))
}

func NewQIcon3(other QIcon_ITF) *QIcon {
	defer qt.Recovering("QIcon::QIcon")

	return newQIconFromPointer(C.QIcon_NewQIcon3(PointerFromQIcon(other)))
}

func NewQIcon2(pixmap QPixmap_ITF) *QIcon {
	defer qt.Recovering("QIcon::QIcon")

	return newQIconFromPointer(C.QIcon_NewQIcon2(PointerFromQPixmap(pixmap)))
}

func NewQIcon5(fileName string) *QIcon {
	defer qt.Recovering("QIcon::QIcon")

	return newQIconFromPointer(C.QIcon_NewQIcon5(C.CString(fileName)))
}

func (ptr *QIcon) ActualSize2(window QWindow_ITF, size core.QSize_ITF, mode QIcon__Mode, state QIcon__State) *core.QSize {
	defer qt.Recovering("QIcon::actualSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QIcon_ActualSize2(ptr.Pointer(), PointerFromQWindow(window), core.PointerFromQSize(size), C.int(mode), C.int(state)))
	}
	return nil
}

func (ptr *QIcon) ActualSize(size core.QSize_ITF, mode QIcon__Mode, state QIcon__State) *core.QSize {
	defer qt.Recovering("QIcon::actualSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QIcon_ActualSize(ptr.Pointer(), core.PointerFromQSize(size), C.int(mode), C.int(state)))
	}
	return nil
}

func (ptr *QIcon) AddFile(fileName string, size core.QSize_ITF, mode QIcon__Mode, state QIcon__State) {
	defer qt.Recovering("QIcon::addFile")

	if ptr.Pointer() != nil {
		C.QIcon_AddFile(ptr.Pointer(), C.CString(fileName), core.PointerFromQSize(size), C.int(mode), C.int(state))
	}
}

func (ptr *QIcon) AddPixmap(pixmap QPixmap_ITF, mode QIcon__Mode, state QIcon__State) {
	defer qt.Recovering("QIcon::addPixmap")

	if ptr.Pointer() != nil {
		C.QIcon_AddPixmap(ptr.Pointer(), PointerFromQPixmap(pixmap), C.int(mode), C.int(state))
	}
}

func (ptr *QIcon) CacheKey() int64 {
	defer qt.Recovering("QIcon::cacheKey")

	if ptr.Pointer() != nil {
		return int64(C.QIcon_CacheKey(ptr.Pointer()))
	}
	return 0
}

func QIcon_FromTheme(name string, fallback QIcon_ITF) *QIcon {
	defer qt.Recovering("QIcon::fromTheme")

	return NewQIconFromPointer(C.QIcon_QIcon_FromTheme(C.CString(name), PointerFromQIcon(fallback)))
}

func QIcon_HasThemeIcon(name string) bool {
	defer qt.Recovering("QIcon::hasThemeIcon")

	return C.QIcon_QIcon_HasThemeIcon(C.CString(name)) != 0
}

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

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

func (ptr *QIcon) Name() string {
	defer qt.Recovering("QIcon::name")

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

func (ptr *QIcon) Paint(painter QPainter_ITF, rect core.QRect_ITF, alignment core.Qt__AlignmentFlag, mode QIcon__Mode, state QIcon__State) {
	defer qt.Recovering("QIcon::paint")

	if ptr.Pointer() != nil {
		C.QIcon_Paint(ptr.Pointer(), PointerFromQPainter(painter), core.PointerFromQRect(rect), C.int(alignment), C.int(mode), C.int(state))
	}
}

func (ptr *QIcon) Paint2(painter QPainter_ITF, x int, y int, w int, h int, alignment core.Qt__AlignmentFlag, mode QIcon__Mode, state QIcon__State) {
	defer qt.Recovering("QIcon::paint")

	if ptr.Pointer() != nil {
		C.QIcon_Paint2(ptr.Pointer(), PointerFromQPainter(painter), C.int(x), C.int(y), C.int(w), C.int(h), C.int(alignment), C.int(mode), C.int(state))
	}
}

func QIcon_SetThemeName(name string) {
	defer qt.Recovering("QIcon::setThemeName")

	C.QIcon_QIcon_SetThemeName(C.CString(name))
}

func QIcon_SetThemeSearchPaths(paths []string) {
	defer qt.Recovering("QIcon::setThemeSearchPaths")

	C.QIcon_QIcon_SetThemeSearchPaths(C.CString(strings.Join(paths, "|")))
}

func (ptr *QIcon) Swap(other QIcon_ITF) {
	defer qt.Recovering("QIcon::swap")

	if ptr.Pointer() != nil {
		C.QIcon_Swap(ptr.Pointer(), PointerFromQIcon(other))
	}
}

func QIcon_ThemeName() string {
	defer qt.Recovering("QIcon::themeName")

	return C.GoString(C.QIcon_QIcon_ThemeName())
}

func QIcon_ThemeSearchPaths() []string {
	defer qt.Recovering("QIcon::themeSearchPaths")

	return strings.Split(C.GoString(C.QIcon_QIcon_ThemeSearchPaths()), "|")
}

func (ptr *QIcon) DestroyQIcon() {
	defer qt.Recovering("QIcon::~QIcon")

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

type QIconDragEvent struct {
	core.QEvent
}

type QIconDragEvent_ITF interface {
	core.QEvent_ITF
	QIconDragEvent_PTR() *QIconDragEvent
}

func PointerFromQIconDragEvent(ptr QIconDragEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIconDragEvent_PTR().Pointer()
	}
	return nil
}

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

func newQIconDragEventFromPointer(ptr unsafe.Pointer) *QIconDragEvent {
	var n = NewQIconDragEventFromPointer(ptr)
	return n
}

func (ptr *QIconDragEvent) QIconDragEvent_PTR() *QIconDragEvent {
	return ptr
}

func NewQIconDragEvent() *QIconDragEvent {
	defer qt.Recovering("QIconDragEvent::QIconDragEvent")

	return newQIconDragEventFromPointer(C.QIconDragEvent_NewQIconDragEvent())
}

type QIconEngine struct {
	ptr unsafe.Pointer
}

type QIconEngine_ITF interface {
	QIconEngine_PTR() *QIconEngine
}

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

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

func PointerFromQIconEngine(ptr QIconEngine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIconEngine_PTR().Pointer()
	}
	return nil
}

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

func newQIconEngineFromPointer(ptr unsafe.Pointer) *QIconEngine {
	var n = NewQIconEngineFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QIconEngine_") {
		n.SetObjectNameAbs("QIconEngine_" + qt.Identifier())
	}
	return n
}

func (ptr *QIconEngine) QIconEngine_PTR() *QIconEngine {
	return ptr
}

//QIconEngine::IconEngineHook
type QIconEngine__IconEngineHook int64

const (
	QIconEngine__AvailableSizesHook = QIconEngine__IconEngineHook(1)
	QIconEngine__IconNameHook       = QIconEngine__IconEngineHook(2)
)

func (ptr *QIconEngine) ActualSize(size core.QSize_ITF, mode QIcon__Mode, state QIcon__State) *core.QSize {
	defer qt.Recovering("QIconEngine::actualSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QIconEngine_ActualSize(ptr.Pointer(), core.PointerFromQSize(size), C.int(mode), C.int(state)))
	}
	return nil
}

func (ptr *QIconEngine) ConnectAddFile(f func(fileName string, size *core.QSize, mode QIcon__Mode, state QIcon__State)) {
	defer qt.Recovering("connect QIconEngine::addFile")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectNameAbs(), "addFile", f)
	}
}

func (ptr *QIconEngine) DisconnectAddFile() {
	defer qt.Recovering("disconnect QIconEngine::addFile")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectNameAbs(), "addFile")
	}
}

//export callbackQIconEngineAddFile
func callbackQIconEngineAddFile(ptr unsafe.Pointer, ptrName *C.char, fileName *C.char, size unsafe.Pointer, mode C.int, state C.int) {
	defer qt.Recovering("callback QIconEngine::addFile")

	if signal := qt.GetSignal(C.GoString(ptrName), "addFile"); signal != nil {
		signal.(func(string, *core.QSize, QIcon__Mode, QIcon__State))(C.GoString(fileName), core.NewQSizeFromPointer(size), QIcon__Mode(mode), QIcon__State(state))
	} else {
		NewQIconEngineFromPointer(ptr).AddFileDefault(C.GoString(fileName), core.NewQSizeFromPointer(size), QIcon__Mode(mode), QIcon__State(state))
	}
}

func (ptr *QIconEngine) AddFile(fileName string, size core.QSize_ITF, mode QIcon__Mode, state QIcon__State) {
	defer qt.Recovering("QIconEngine::addFile")

	if ptr.Pointer() != nil {
		C.QIconEngine_AddFile(ptr.Pointer(), C.CString(fileName), core.PointerFromQSize(size), C.int(mode), C.int(state))
	}
}

func (ptr *QIconEngine) AddFileDefault(fileName string, size core.QSize_ITF, mode QIcon__Mode, state QIcon__State) {
	defer qt.Recovering("QIconEngine::addFile")

	if ptr.Pointer() != nil {
		C.QIconEngine_AddFileDefault(ptr.Pointer(), C.CString(fileName), core.PointerFromQSize(size), C.int(mode), C.int(state))
	}
}

func (ptr *QIconEngine) Clone() *QIconEngine {
	defer qt.Recovering("QIconEngine::clone")

	if ptr.Pointer() != nil {
		return NewQIconEngineFromPointer(C.QIconEngine_Clone(ptr.Pointer()))
	}
	return nil
}

func (ptr *QIconEngine) IconName() string {
	defer qt.Recovering("QIconEngine::iconName")

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

func (ptr *QIconEngine) Key() string {
	defer qt.Recovering("QIconEngine::key")

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

func (ptr *QIconEngine) Paint(painter QPainter_ITF, rect core.QRect_ITF, mode QIcon__Mode, state QIcon__State) {
	defer qt.Recovering("QIconEngine::paint")

	if ptr.Pointer() != nil {
		C.QIconEngine_Paint(ptr.Pointer(), PointerFromQPainter(painter), core.PointerFromQRect(rect), C.int(mode), C.int(state))
	}
}

func (ptr *QIconEngine) Read(in core.QDataStream_ITF) bool {
	defer qt.Recovering("QIconEngine::read")

	if ptr.Pointer() != nil {
		return C.QIconEngine_Read(ptr.Pointer(), core.PointerFromQDataStream(in)) != 0
	}
	return false
}

func (ptr *QIconEngine) Write(out core.QDataStream_ITF) bool {
	defer qt.Recovering("QIconEngine::write")

	if ptr.Pointer() != nil {
		return C.QIconEngine_Write(ptr.Pointer(), core.PointerFromQDataStream(out)) != 0
	}
	return false
}

func (ptr *QIconEngine) DestroyQIconEngine() {
	defer qt.Recovering("QIconEngine::~QIconEngine")

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

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

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

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

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

type QIconEnginePlugin struct {
	core.QObject
}

type QIconEnginePlugin_ITF interface {
	core.QObject_ITF
	QIconEnginePlugin_PTR() *QIconEnginePlugin
}

func PointerFromQIconEnginePlugin(ptr QIconEnginePlugin_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIconEnginePlugin_PTR().Pointer()
	}
	return nil
}

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

func newQIconEnginePluginFromPointer(ptr unsafe.Pointer) *QIconEnginePlugin {
	var n = NewQIconEnginePluginFromPointer(ptr)
	for len(n.ObjectName()) < len("QIconEnginePlugin_") {
		n.SetObjectName("QIconEnginePlugin_" + qt.Identifier())
	}
	return n
}

func (ptr *QIconEnginePlugin) QIconEnginePlugin_PTR() *QIconEnginePlugin {
	return ptr
}

type QImage struct {
	QPaintDevice
}

type QImage_ITF interface {
	QPaintDevice_ITF
	QImage_PTR() *QImage
}

func PointerFromQImage(ptr QImage_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QImage_PTR().Pointer()
	}
	return nil
}

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

func newQImageFromPointer(ptr unsafe.Pointer) *QImage {
	var n = NewQImageFromPointer(ptr)
	return n
}

func (ptr *QImage) QImage_PTR() *QImage {
	return ptr
}

//QImage::Format
type QImage__Format int64

const (
	QImage__Format_Invalid                = QImage__Format(0)
	QImage__Format_Mono                   = QImage__Format(1)
	QImage__Format_MonoLSB                = QImage__Format(2)
	QImage__Format_Indexed8               = QImage__Format(3)
	QImage__Format_RGB32                  = QImage__Format(4)
	QImage__Format_ARGB32                 = QImage__Format(5)
	QImage__Format_ARGB32_Premultiplied   = QImage__Format(6)
	QImage__Format_RGB16                  = QImage__Format(7)
	QImage__Format_ARGB8565_Premultiplied = QImage__Format(8)
	QImage__Format_RGB666                 = QImage__Format(9)
	QImage__Format_ARGB6666_Premultiplied = QImage__Format(10)
	QImage__Format_RGB555                 = QImage__Format(11)
	QImage__Format_ARGB8555_Premultiplied = QImage__Format(12)
	QImage__Format_RGB888                 = QImage__Format(13)
	QImage__Format_RGB444                 = QImage__Format(14)
	QImage__Format_ARGB4444_Premultiplied = QImage__Format(15)
	QImage__Format_RGBX8888               = QImage__Format(16)
	QImage__Format_RGBA8888               = QImage__Format(17)
	QImage__Format_RGBA8888_Premultiplied = QImage__Format(18)
	QImage__Format_BGR30                  = QImage__Format(19)
	QImage__Format_A2BGR30_Premultiplied  = QImage__Format(20)
	QImage__Format_RGB30                  = QImage__Format(21)
	QImage__Format_A2RGB30_Premultiplied  = QImage__Format(22)
	QImage__Format_Alpha8                 = QImage__Format(23)
	QImage__Format_Grayscale8             = QImage__Format(24)
)

//QImage::InvertMode
type QImage__InvertMode int64

const (
	QImage__InvertRgb  = QImage__InvertMode(0)
	QImage__InvertRgba = QImage__InvertMode(1)
)

func (ptr *QImage) ColorCount() int {
	defer qt.Recovering("QImage::colorCount")

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

func (ptr *QImage) Fill2(color core.Qt__GlobalColor) {
	defer qt.Recovering("QImage::fill")

	if ptr.Pointer() != nil {
		C.QImage_Fill2(ptr.Pointer(), C.int(color))
	}
}

func (ptr *QImage) Fill3(color QColor_ITF) {
	defer qt.Recovering("QImage::fill")

	if ptr.Pointer() != nil {
		C.QImage_Fill3(ptr.Pointer(), PointerFromQColor(color))
	}
}

func (ptr *QImage) Height() int {
	defer qt.Recovering("QImage::height")

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

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

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

func (ptr *QImage) Offset() *core.QPoint {
	defer qt.Recovering("QImage::offset")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QImage_Offset(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImage) Rect() *core.QRect {
	defer qt.Recovering("QImage::rect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QImage_Rect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImage) SetOffset(offset core.QPoint_ITF) {
	defer qt.Recovering("QImage::setOffset")

	if ptr.Pointer() != nil {
		C.QImage_SetOffset(ptr.Pointer(), core.PointerFromQPoint(offset))
	}
}

func (ptr *QImage) SetText(key string, text string) {
	defer qt.Recovering("QImage::setText")

	if ptr.Pointer() != nil {
		C.QImage_SetText(ptr.Pointer(), C.CString(key), C.CString(text))
	}
}

func (ptr *QImage) Size() *core.QSize {
	defer qt.Recovering("QImage::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QImage_Size(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImage) Width() int {
	defer qt.Recovering("QImage::width")

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

func NewQImage() *QImage {
	defer qt.Recovering("QImage::QImage")

	return newQImageFromPointer(C.QImage_NewQImage())
}

func NewQImage11(other QImage_ITF) *QImage {
	defer qt.Recovering("QImage::QImage")

	return newQImageFromPointer(C.QImage_NewQImage11(PointerFromQImage(other)))
}

func NewQImage10(image QImage_ITF) *QImage {
	defer qt.Recovering("QImage::QImage")

	return newQImageFromPointer(C.QImage_NewQImage10(PointerFromQImage(image)))
}

func NewQImage2(size core.QSize_ITF, format QImage__Format) *QImage {
	defer qt.Recovering("QImage::QImage")

	return newQImageFromPointer(C.QImage_NewQImage2(core.PointerFromQSize(size), C.int(format)))
}

func NewQImage9(fileName string, format string) *QImage {
	defer qt.Recovering("QImage::QImage")

	return newQImageFromPointer(C.QImage_NewQImage9(C.CString(fileName), C.CString(format)))
}

func NewQImage3(width int, height int, format QImage__Format) *QImage {
	defer qt.Recovering("QImage::QImage")

	return newQImageFromPointer(C.QImage_NewQImage3(C.int(width), C.int(height), C.int(format)))
}

func (ptr *QImage) AllGray() bool {
	defer qt.Recovering("QImage::allGray")

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

func (ptr *QImage) BitPlaneCount() int {
	defer qt.Recovering("QImage::bitPlaneCount")

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

func (ptr *QImage) ByteCount() int {
	defer qt.Recovering("QImage::byteCount")

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

func (ptr *QImage) BytesPerLine() int {
	defer qt.Recovering("QImage::bytesPerLine")

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

func (ptr *QImage) CacheKey() int64 {
	defer qt.Recovering("QImage::cacheKey")

	if ptr.Pointer() != nil {
		return int64(C.QImage_CacheKey(ptr.Pointer()))
	}
	return 0
}

func (ptr *QImage) Depth() int {
	defer qt.Recovering("QImage::depth")

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

func (ptr *QImage) DevicePixelRatio() float64 {
	defer qt.Recovering("QImage::devicePixelRatio")

	if ptr.Pointer() != nil {
		return float64(C.QImage_DevicePixelRatio(ptr.Pointer()))
	}
	return 0
}

func (ptr *QImage) DotsPerMeterX() int {
	defer qt.Recovering("QImage::dotsPerMeterX")

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

func (ptr *QImage) DotsPerMeterY() int {
	defer qt.Recovering("QImage::dotsPerMeterY")

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

func (ptr *QImage) Format() QImage__Format {
	defer qt.Recovering("QImage::format")

	if ptr.Pointer() != nil {
		return QImage__Format(C.QImage_Format(ptr.Pointer()))
	}
	return 0
}

func (ptr *QImage) HasAlphaChannel() bool {
	defer qt.Recovering("QImage::hasAlphaChannel")

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

func (ptr *QImage) InvertPixels(mode QImage__InvertMode) {
	defer qt.Recovering("QImage::invertPixels")

	if ptr.Pointer() != nil {
		C.QImage_InvertPixels(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QImage) IsGrayscale() bool {
	defer qt.Recovering("QImage::isGrayscale")

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

func (ptr *QImage) Load2(device core.QIODevice_ITF, format string) bool {
	defer qt.Recovering("QImage::load")

	if ptr.Pointer() != nil {
		return C.QImage_Load2(ptr.Pointer(), core.PointerFromQIODevice(device), C.CString(format)) != 0
	}
	return false
}

func (ptr *QImage) Load(fileName string, format string) bool {
	defer qt.Recovering("QImage::load")

	if ptr.Pointer() != nil {
		return C.QImage_Load(ptr.Pointer(), C.CString(fileName), C.CString(format)) != 0
	}
	return false
}

func (ptr *QImage) LoadFromData2(data core.QByteArray_ITF, format string) bool {
	defer qt.Recovering("QImage::loadFromData")

	if ptr.Pointer() != nil {
		return C.QImage_LoadFromData2(ptr.Pointer(), core.PointerFromQByteArray(data), C.CString(format)) != 0
	}
	return false
}

func (ptr *QImage) PixelIndex(position core.QPoint_ITF) int {
	defer qt.Recovering("QImage::pixelIndex")

	if ptr.Pointer() != nil {
		return int(C.QImage_PixelIndex(ptr.Pointer(), core.PointerFromQPoint(position)))
	}
	return 0
}

func (ptr *QImage) PixelIndex2(x int, y int) int {
	defer qt.Recovering("QImage::pixelIndex")

	if ptr.Pointer() != nil {
		return int(C.QImage_PixelIndex2(ptr.Pointer(), C.int(x), C.int(y)))
	}
	return 0
}

func (ptr *QImage) Save2(device core.QIODevice_ITF, format string, quality int) bool {
	defer qt.Recovering("QImage::save")

	if ptr.Pointer() != nil {
		return C.QImage_Save2(ptr.Pointer(), core.PointerFromQIODevice(device), C.CString(format), C.int(quality)) != 0
	}
	return false
}

func (ptr *QImage) Save(fileName string, format string, quality int) bool {
	defer qt.Recovering("QImage::save")

	if ptr.Pointer() != nil {
		return C.QImage_Save(ptr.Pointer(), C.CString(fileName), C.CString(format), C.int(quality)) != 0
	}
	return false
}

func (ptr *QImage) SetColorCount(colorCount int) {
	defer qt.Recovering("QImage::setColorCount")

	if ptr.Pointer() != nil {
		C.QImage_SetColorCount(ptr.Pointer(), C.int(colorCount))
	}
}

func (ptr *QImage) SetDevicePixelRatio(scaleFactor float64) {
	defer qt.Recovering("QImage::setDevicePixelRatio")

	if ptr.Pointer() != nil {
		C.QImage_SetDevicePixelRatio(ptr.Pointer(), C.double(scaleFactor))
	}
}

func (ptr *QImage) SetDotsPerMeterX(x int) {
	defer qt.Recovering("QImage::setDotsPerMeterX")

	if ptr.Pointer() != nil {
		C.QImage_SetDotsPerMeterX(ptr.Pointer(), C.int(x))
	}
}

func (ptr *QImage) SetDotsPerMeterY(y int) {
	defer qt.Recovering("QImage::setDotsPerMeterY")

	if ptr.Pointer() != nil {
		C.QImage_SetDotsPerMeterY(ptr.Pointer(), C.int(y))
	}
}

func (ptr *QImage) Swap(other QImage_ITF) {
	defer qt.Recovering("QImage::swap")

	if ptr.Pointer() != nil {
		C.QImage_Swap(ptr.Pointer(), PointerFromQImage(other))
	}
}

func (ptr *QImage) Text(key string) string {
	defer qt.Recovering("QImage::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QImage_Text(ptr.Pointer(), C.CString(key)))
	}
	return ""
}

func (ptr *QImage) TextKeys() []string {
	defer qt.Recovering("QImage::textKeys")

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

func QImage_ToImageFormat(format QPixelFormat_ITF) QImage__Format {
	defer qt.Recovering("QImage::toImageFormat")

	return QImage__Format(C.QImage_QImage_ToImageFormat(PointerFromQPixelFormat(format)))
}

func (ptr *QImage) Valid(pos core.QPoint_ITF) bool {
	defer qt.Recovering("QImage::valid")

	if ptr.Pointer() != nil {
		return C.QImage_Valid(ptr.Pointer(), core.PointerFromQPoint(pos)) != 0
	}
	return false
}

func (ptr *QImage) Valid2(x int, y int) bool {
	defer qt.Recovering("QImage::valid")

	if ptr.Pointer() != nil {
		return C.QImage_Valid2(ptr.Pointer(), C.int(x), C.int(y)) != 0
	}
	return false
}

func (ptr *QImage) DestroyQImage() {
	defer qt.Recovering("QImage::~QImage")

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

type QImageIOHandler struct {
	ptr unsafe.Pointer
}

type QImageIOHandler_ITF interface {
	QImageIOHandler_PTR() *QImageIOHandler
}

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

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

func PointerFromQImageIOHandler(ptr QImageIOHandler_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QImageIOHandler_PTR().Pointer()
	}
	return nil
}

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

func newQImageIOHandlerFromPointer(ptr unsafe.Pointer) *QImageIOHandler {
	var n = NewQImageIOHandlerFromPointer(ptr)
	return n
}

func (ptr *QImageIOHandler) QImageIOHandler_PTR() *QImageIOHandler {
	return ptr
}

//QImageIOHandler::ImageOption
type QImageIOHandler__ImageOption int64

const (
	QImageIOHandler__Size                 = QImageIOHandler__ImageOption(0)
	QImageIOHandler__ClipRect             = QImageIOHandler__ImageOption(1)
	QImageIOHandler__Description          = QImageIOHandler__ImageOption(2)
	QImageIOHandler__ScaledClipRect       = QImageIOHandler__ImageOption(3)
	QImageIOHandler__ScaledSize           = QImageIOHandler__ImageOption(4)
	QImageIOHandler__CompressionRatio     = QImageIOHandler__ImageOption(5)
	QImageIOHandler__Gamma                = QImageIOHandler__ImageOption(6)
	QImageIOHandler__Quality              = QImageIOHandler__ImageOption(7)
	QImageIOHandler__Name                 = QImageIOHandler__ImageOption(8)
	QImageIOHandler__SubType              = QImageIOHandler__ImageOption(9)
	QImageIOHandler__IncrementalReading   = QImageIOHandler__ImageOption(10)
	QImageIOHandler__Endianness           = QImageIOHandler__ImageOption(11)
	QImageIOHandler__Animation            = QImageIOHandler__ImageOption(12)
	QImageIOHandler__BackgroundColor      = QImageIOHandler__ImageOption(13)
	QImageIOHandler__ImageFormat          = QImageIOHandler__ImageOption(14)
	QImageIOHandler__SupportedSubTypes    = QImageIOHandler__ImageOption(15)
	QImageIOHandler__OptimizedWrite       = QImageIOHandler__ImageOption(16)
	QImageIOHandler__ProgressiveScanWrite = QImageIOHandler__ImageOption(17)
	QImageIOHandler__ImageTransformation  = QImageIOHandler__ImageOption(18)
	QImageIOHandler__TransformedByDefault = QImageIOHandler__ImageOption(19)
)

//QImageIOHandler::Transformation
type QImageIOHandler__Transformation int64

const (
	QImageIOHandler__TransformationNone              = QImageIOHandler__Transformation(0)
	QImageIOHandler__TransformationMirror            = QImageIOHandler__Transformation(1)
	QImageIOHandler__TransformationFlip              = QImageIOHandler__Transformation(2)
	QImageIOHandler__TransformationRotate180         = QImageIOHandler__Transformation(QImageIOHandler__TransformationMirror | QImageIOHandler__TransformationFlip)
	QImageIOHandler__TransformationRotate90          = QImageIOHandler__Transformation(4)
	QImageIOHandler__TransformationMirrorAndRotate90 = QImageIOHandler__Transformation(QImageIOHandler__TransformationMirror | QImageIOHandler__TransformationRotate90)
	QImageIOHandler__TransformationFlipAndRotate90   = QImageIOHandler__Transformation(QImageIOHandler__TransformationFlip | QImageIOHandler__TransformationRotate90)
	QImageIOHandler__TransformationRotate270         = QImageIOHandler__Transformation(QImageIOHandler__TransformationRotate180 | QImageIOHandler__TransformationRotate90)
)

type QImageIOPlugin struct {
	core.QObject
}

type QImageIOPlugin_ITF interface {
	core.QObject_ITF
	QImageIOPlugin_PTR() *QImageIOPlugin
}

func PointerFromQImageIOPlugin(ptr QImageIOPlugin_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QImageIOPlugin_PTR().Pointer()
	}
	return nil
}

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

func newQImageIOPluginFromPointer(ptr unsafe.Pointer) *QImageIOPlugin {
	var n = NewQImageIOPluginFromPointer(ptr)
	for len(n.ObjectName()) < len("QImageIOPlugin_") {
		n.SetObjectName("QImageIOPlugin_" + qt.Identifier())
	}
	return n
}

func (ptr *QImageIOPlugin) QImageIOPlugin_PTR() *QImageIOPlugin {
	return ptr
}

//QImageIOPlugin::Capability
type QImageIOPlugin__Capability int64

const (
	QImageIOPlugin__CanRead            = QImageIOPlugin__Capability(0x1)
	QImageIOPlugin__CanWrite           = QImageIOPlugin__Capability(0x2)
	QImageIOPlugin__CanReadIncremental = QImageIOPlugin__Capability(0x4)
)

type QImageReader struct {
	ptr unsafe.Pointer
}

type QImageReader_ITF interface {
	QImageReader_PTR() *QImageReader
}

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

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

func PointerFromQImageReader(ptr QImageReader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QImageReader_PTR().Pointer()
	}
	return nil
}

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

func newQImageReaderFromPointer(ptr unsafe.Pointer) *QImageReader {
	var n = NewQImageReaderFromPointer(ptr)
	return n
}

func (ptr *QImageReader) QImageReader_PTR() *QImageReader {
	return ptr
}

//QImageReader::ImageReaderError
type QImageReader__ImageReaderError int64

const (
	QImageReader__UnknownError           = QImageReader__ImageReaderError(0)
	QImageReader__FileNotFoundError      = QImageReader__ImageReaderError(1)
	QImageReader__DeviceError            = QImageReader__ImageReaderError(2)
	QImageReader__UnsupportedFormatError = QImageReader__ImageReaderError(3)
	QImageReader__InvalidDataError       = QImageReader__ImageReaderError(4)
)

func NewQImageReader() *QImageReader {
	defer qt.Recovering("QImageReader::QImageReader")

	return newQImageReaderFromPointer(C.QImageReader_NewQImageReader())
}

func NewQImageReader2(device core.QIODevice_ITF, format core.QByteArray_ITF) *QImageReader {
	defer qt.Recovering("QImageReader::QImageReader")

	return newQImageReaderFromPointer(C.QImageReader_NewQImageReader2(core.PointerFromQIODevice(device), core.PointerFromQByteArray(format)))
}

func NewQImageReader3(fileName string, format core.QByteArray_ITF) *QImageReader {
	defer qt.Recovering("QImageReader::QImageReader")

	return newQImageReaderFromPointer(C.QImageReader_NewQImageReader3(C.CString(fileName), core.PointerFromQByteArray(format)))
}

func (ptr *QImageReader) AutoDetectImageFormat() bool {
	defer qt.Recovering("QImageReader::autoDetectImageFormat")

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

func (ptr *QImageReader) AutoTransform() bool {
	defer qt.Recovering("QImageReader::autoTransform")

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

func (ptr *QImageReader) BackgroundColor() *QColor {
	defer qt.Recovering("QImageReader::backgroundColor")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QImageReader_BackgroundColor(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageReader) CanRead() bool {
	defer qt.Recovering("QImageReader::canRead")

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

func (ptr *QImageReader) ClipRect() *core.QRect {
	defer qt.Recovering("QImageReader::clipRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QImageReader_ClipRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageReader) CurrentImageNumber() int {
	defer qt.Recovering("QImageReader::currentImageNumber")

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

func (ptr *QImageReader) CurrentImageRect() *core.QRect {
	defer qt.Recovering("QImageReader::currentImageRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QImageReader_CurrentImageRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageReader) DecideFormatFromContent() bool {
	defer qt.Recovering("QImageReader::decideFormatFromContent")

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

func (ptr *QImageReader) Device() *core.QIODevice {
	defer qt.Recovering("QImageReader::device")

	if ptr.Pointer() != nil {
		return core.NewQIODeviceFromPointer(C.QImageReader_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageReader) Error() QImageReader__ImageReaderError {
	defer qt.Recovering("QImageReader::error")

	if ptr.Pointer() != nil {
		return QImageReader__ImageReaderError(C.QImageReader_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QImageReader) ErrorString() string {
	defer qt.Recovering("QImageReader::errorString")

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

func (ptr *QImageReader) FileName() string {
	defer qt.Recovering("QImageReader::fileName")

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

func (ptr *QImageReader) Format() *core.QByteArray {
	defer qt.Recovering("QImageReader::format")

	if ptr.Pointer() != nil {
		return core.NewQByteArrayFromPointer(C.QImageReader_Format(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageReader) ImageCount() int {
	defer qt.Recovering("QImageReader::imageCount")

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

func QImageReader_ImageFormat3(device core.QIODevice_ITF) *core.QByteArray {
	defer qt.Recovering("QImageReader::imageFormat")

	return core.NewQByteArrayFromPointer(C.QImageReader_QImageReader_ImageFormat3(core.PointerFromQIODevice(device)))
}

func QImageReader_ImageFormat2(fileName string) *core.QByteArray {
	defer qt.Recovering("QImageReader::imageFormat")

	return core.NewQByteArrayFromPointer(C.QImageReader_QImageReader_ImageFormat2(C.CString(fileName)))
}

func (ptr *QImageReader) ImageFormat() QImage__Format {
	defer qt.Recovering("QImageReader::imageFormat")

	if ptr.Pointer() != nil {
		return QImage__Format(C.QImageReader_ImageFormat(ptr.Pointer()))
	}
	return 0
}

func (ptr *QImageReader) JumpToImage(imageNumber int) bool {
	defer qt.Recovering("QImageReader::jumpToImage")

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

func (ptr *QImageReader) JumpToNextImage() bool {
	defer qt.Recovering("QImageReader::jumpToNextImage")

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

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

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

func (ptr *QImageReader) NextImageDelay() int {
	defer qt.Recovering("QImageReader::nextImageDelay")

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

func (ptr *QImageReader) Quality() int {
	defer qt.Recovering("QImageReader::quality")

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

func (ptr *QImageReader) Read2(image QImage_ITF) bool {
	defer qt.Recovering("QImageReader::read")

	if ptr.Pointer() != nil {
		return C.QImageReader_Read2(ptr.Pointer(), PointerFromQImage(image)) != 0
	}
	return false
}

func (ptr *QImageReader) ScaledClipRect() *core.QRect {
	defer qt.Recovering("QImageReader::scaledClipRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QImageReader_ScaledClipRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageReader) ScaledSize() *core.QSize {
	defer qt.Recovering("QImageReader::scaledSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QImageReader_ScaledSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageReader) SetAutoDetectImageFormat(enabled bool) {
	defer qt.Recovering("QImageReader::setAutoDetectImageFormat")

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

func (ptr *QImageReader) SetAutoTransform(enabled bool) {
	defer qt.Recovering("QImageReader::setAutoTransform")

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

func (ptr *QImageReader) SetBackgroundColor(color QColor_ITF) {
	defer qt.Recovering("QImageReader::setBackgroundColor")

	if ptr.Pointer() != nil {
		C.QImageReader_SetBackgroundColor(ptr.Pointer(), PointerFromQColor(color))
	}
}

func (ptr *QImageReader) SetClipRect(rect core.QRect_ITF) {
	defer qt.Recovering("QImageReader::setClipRect")

	if ptr.Pointer() != nil {
		C.QImageReader_SetClipRect(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QImageReader) SetDecideFormatFromContent(ignored bool) {
	defer qt.Recovering("QImageReader::setDecideFormatFromContent")

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

func (ptr *QImageReader) SetDevice(device core.QIODevice_ITF) {
	defer qt.Recovering("QImageReader::setDevice")

	if ptr.Pointer() != nil {
		C.QImageReader_SetDevice(ptr.Pointer(), core.PointerFromQIODevice(device))
	}
}

func (ptr *QImageReader) SetFileName(fileName string) {
	defer qt.Recovering("QImageReader::setFileName")

	if ptr.Pointer() != nil {
		C.QImageReader_SetFileName(ptr.Pointer(), C.CString(fileName))
	}
}

func (ptr *QImageReader) SetFormat(format core.QByteArray_ITF) {
	defer qt.Recovering("QImageReader::setFormat")

	if ptr.Pointer() != nil {
		C.QImageReader_SetFormat(ptr.Pointer(), core.PointerFromQByteArray(format))
	}
}

func (ptr *QImageReader) SetQuality(quality int) {
	defer qt.Recovering("QImageReader::setQuality")

	if ptr.Pointer() != nil {
		C.QImageReader_SetQuality(ptr.Pointer(), C.int(quality))
	}
}

func (ptr *QImageReader) SetScaledClipRect(rect core.QRect_ITF) {
	defer qt.Recovering("QImageReader::setScaledClipRect")

	if ptr.Pointer() != nil {
		C.QImageReader_SetScaledClipRect(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QImageReader) SetScaledSize(size core.QSize_ITF) {
	defer qt.Recovering("QImageReader::setScaledSize")

	if ptr.Pointer() != nil {
		C.QImageReader_SetScaledSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QImageReader) Size() *core.QSize {
	defer qt.Recovering("QImageReader::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QImageReader_Size(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageReader) SubType() *core.QByteArray {
	defer qt.Recovering("QImageReader::subType")

	if ptr.Pointer() != nil {
		return core.NewQByteArrayFromPointer(C.QImageReader_SubType(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageReader) SupportsAnimation() bool {
	defer qt.Recovering("QImageReader::supportsAnimation")

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

func (ptr *QImageReader) SupportsOption(option QImageIOHandler__ImageOption) bool {
	defer qt.Recovering("QImageReader::supportsOption")

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

func (ptr *QImageReader) Text(key string) string {
	defer qt.Recovering("QImageReader::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QImageReader_Text(ptr.Pointer(), C.CString(key)))
	}
	return ""
}

func (ptr *QImageReader) TextKeys() []string {
	defer qt.Recovering("QImageReader::textKeys")

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

func (ptr *QImageReader) Transformation() QImageIOHandler__Transformation {
	defer qt.Recovering("QImageReader::transformation")

	if ptr.Pointer() != nil {
		return QImageIOHandler__Transformation(C.QImageReader_Transformation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QImageReader) DestroyQImageReader() {
	defer qt.Recovering("QImageReader::~QImageReader")

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

type QImageWriter struct {
	ptr unsafe.Pointer
}

type QImageWriter_ITF interface {
	QImageWriter_PTR() *QImageWriter
}

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

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

func PointerFromQImageWriter(ptr QImageWriter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QImageWriter_PTR().Pointer()
	}
	return nil
}

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

func newQImageWriterFromPointer(ptr unsafe.Pointer) *QImageWriter {
	var n = NewQImageWriterFromPointer(ptr)
	return n
}

func (ptr *QImageWriter) QImageWriter_PTR() *QImageWriter {
	return ptr
}

//QImageWriter::ImageWriterError
type QImageWriter__ImageWriterError int64

const (
	QImageWriter__UnknownError           = QImageWriter__ImageWriterError(0)
	QImageWriter__DeviceError            = QImageWriter__ImageWriterError(1)
	QImageWriter__UnsupportedFormatError = QImageWriter__ImageWriterError(2)
)

func NewQImageWriter() *QImageWriter {
	defer qt.Recovering("QImageWriter::QImageWriter")

	return newQImageWriterFromPointer(C.QImageWriter_NewQImageWriter())
}

func NewQImageWriter2(device core.QIODevice_ITF, format core.QByteArray_ITF) *QImageWriter {
	defer qt.Recovering("QImageWriter::QImageWriter")

	return newQImageWriterFromPointer(C.QImageWriter_NewQImageWriter2(core.PointerFromQIODevice(device), core.PointerFromQByteArray(format)))
}

func NewQImageWriter3(fileName string, format core.QByteArray_ITF) *QImageWriter {
	defer qt.Recovering("QImageWriter::QImageWriter")

	return newQImageWriterFromPointer(C.QImageWriter_NewQImageWriter3(C.CString(fileName), core.PointerFromQByteArray(format)))
}

func (ptr *QImageWriter) CanWrite() bool {
	defer qt.Recovering("QImageWriter::canWrite")

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

func (ptr *QImageWriter) Compression() int {
	defer qt.Recovering("QImageWriter::compression")

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

func (ptr *QImageWriter) Device() *core.QIODevice {
	defer qt.Recovering("QImageWriter::device")

	if ptr.Pointer() != nil {
		return core.NewQIODeviceFromPointer(C.QImageWriter_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageWriter) Error() QImageWriter__ImageWriterError {
	defer qt.Recovering("QImageWriter::error")

	if ptr.Pointer() != nil {
		return QImageWriter__ImageWriterError(C.QImageWriter_Error(ptr.Pointer()))
	}
	return 0
}

func (ptr *QImageWriter) ErrorString() string {
	defer qt.Recovering("QImageWriter::errorString")

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

func (ptr *QImageWriter) FileName() string {
	defer qt.Recovering("QImageWriter::fileName")

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

func (ptr *QImageWriter) Format() *core.QByteArray {
	defer qt.Recovering("QImageWriter::format")

	if ptr.Pointer() != nil {
		return core.NewQByteArrayFromPointer(C.QImageWriter_Format(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageWriter) OptimizedWrite() bool {
	defer qt.Recovering("QImageWriter::optimizedWrite")

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

func (ptr *QImageWriter) ProgressiveScanWrite() bool {
	defer qt.Recovering("QImageWriter::progressiveScanWrite")

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

func (ptr *QImageWriter) Quality() int {
	defer qt.Recovering("QImageWriter::quality")

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

func (ptr *QImageWriter) SetCompression(compression int) {
	defer qt.Recovering("QImageWriter::setCompression")

	if ptr.Pointer() != nil {
		C.QImageWriter_SetCompression(ptr.Pointer(), C.int(compression))
	}
}

func (ptr *QImageWriter) SetDevice(device core.QIODevice_ITF) {
	defer qt.Recovering("QImageWriter::setDevice")

	if ptr.Pointer() != nil {
		C.QImageWriter_SetDevice(ptr.Pointer(), core.PointerFromQIODevice(device))
	}
}

func (ptr *QImageWriter) SetFileName(fileName string) {
	defer qt.Recovering("QImageWriter::setFileName")

	if ptr.Pointer() != nil {
		C.QImageWriter_SetFileName(ptr.Pointer(), C.CString(fileName))
	}
}

func (ptr *QImageWriter) SetFormat(format core.QByteArray_ITF) {
	defer qt.Recovering("QImageWriter::setFormat")

	if ptr.Pointer() != nil {
		C.QImageWriter_SetFormat(ptr.Pointer(), core.PointerFromQByteArray(format))
	}
}

func (ptr *QImageWriter) SetOptimizedWrite(optimize bool) {
	defer qt.Recovering("QImageWriter::setOptimizedWrite")

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

func (ptr *QImageWriter) SetProgressiveScanWrite(progressive bool) {
	defer qt.Recovering("QImageWriter::setProgressiveScanWrite")

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

func (ptr *QImageWriter) SetQuality(quality int) {
	defer qt.Recovering("QImageWriter::setQuality")

	if ptr.Pointer() != nil {
		C.QImageWriter_SetQuality(ptr.Pointer(), C.int(quality))
	}
}

func (ptr *QImageWriter) SetSubType(ty core.QByteArray_ITF) {
	defer qt.Recovering("QImageWriter::setSubType")

	if ptr.Pointer() != nil {
		C.QImageWriter_SetSubType(ptr.Pointer(), core.PointerFromQByteArray(ty))
	}
}

func (ptr *QImageWriter) SetText(key string, text string) {
	defer qt.Recovering("QImageWriter::setText")

	if ptr.Pointer() != nil {
		C.QImageWriter_SetText(ptr.Pointer(), C.CString(key), C.CString(text))
	}
}

func (ptr *QImageWriter) SetTransformation(transform QImageIOHandler__Transformation) {
	defer qt.Recovering("QImageWriter::setTransformation")

	if ptr.Pointer() != nil {
		C.QImageWriter_SetTransformation(ptr.Pointer(), C.int(transform))
	}
}

func (ptr *QImageWriter) SubType() *core.QByteArray {
	defer qt.Recovering("QImageWriter::subType")

	if ptr.Pointer() != nil {
		return core.NewQByteArrayFromPointer(C.QImageWriter_SubType(ptr.Pointer()))
	}
	return nil
}

func (ptr *QImageWriter) SupportsOption(option QImageIOHandler__ImageOption) bool {
	defer qt.Recovering("QImageWriter::supportsOption")

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

func (ptr *QImageWriter) Transformation() QImageIOHandler__Transformation {
	defer qt.Recovering("QImageWriter::transformation")

	if ptr.Pointer() != nil {
		return QImageIOHandler__Transformation(C.QImageWriter_Transformation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QImageWriter) Write(image QImage_ITF) bool {
	defer qt.Recovering("QImageWriter::write")

	if ptr.Pointer() != nil {
		return C.QImageWriter_Write(ptr.Pointer(), PointerFromQImage(image)) != 0
	}
	return false
}

func (ptr *QImageWriter) DestroyQImageWriter() {
	defer qt.Recovering("QImageWriter::~QImageWriter")

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

type QInputEvent struct {
	core.QEvent
}

type QInputEvent_ITF interface {
	core.QEvent_ITF
	QInputEvent_PTR() *QInputEvent
}

func PointerFromQInputEvent(ptr QInputEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QInputEvent_PTR().Pointer()
	}
	return nil
}

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

func newQInputEventFromPointer(ptr unsafe.Pointer) *QInputEvent {
	var n = NewQInputEventFromPointer(ptr)
	return n
}

func (ptr *QInputEvent) QInputEvent_PTR() *QInputEvent {
	return ptr
}

func (ptr *QInputEvent) Modifiers() core.Qt__KeyboardModifier {
	defer qt.Recovering("QInputEvent::modifiers")

	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QInputEvent_Modifiers(ptr.Pointer()))
	}
	return 0
}

type QInputMethod struct {
	core.QObject
}

type QInputMethod_ITF interface {
	core.QObject_ITF
	QInputMethod_PTR() *QInputMethod
}

func PointerFromQInputMethod(ptr QInputMethod_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QInputMethod_PTR().Pointer()
	}
	return nil
}

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

func newQInputMethodFromPointer(ptr unsafe.Pointer) *QInputMethod {
	var n = NewQInputMethodFromPointer(ptr)
	for len(n.ObjectName()) < len("QInputMethod_") {
		n.SetObjectName("QInputMethod_" + qt.Identifier())
	}
	return n
}

func (ptr *QInputMethod) QInputMethod_PTR() *QInputMethod {
	return ptr
}

//QInputMethod::Action
type QInputMethod__Action int64

const (
	QInputMethod__Click       = QInputMethod__Action(0)
	QInputMethod__ContextMenu = QInputMethod__Action(1)
)

func (ptr *QInputMethod) InputDirection() core.Qt__LayoutDirection {
	defer qt.Recovering("QInputMethod::inputDirection")

	if ptr.Pointer() != nil {
		return core.Qt__LayoutDirection(C.QInputMethod_InputDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QInputMethod) IsAnimating() bool {
	defer qt.Recovering("QInputMethod::isAnimating")

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

func (ptr *QInputMethod) IsVisible() bool {
	defer qt.Recovering("QInputMethod::isVisible")

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

func (ptr *QInputMethod) ConnectAnimatingChanged(f func()) {
	defer qt.Recovering("connect QInputMethod::animatingChanged")

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

func (ptr *QInputMethod) DisconnectAnimatingChanged() {
	defer qt.Recovering("disconnect QInputMethod::animatingChanged")

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

//export callbackQInputMethodAnimatingChanged
func callbackQInputMethodAnimatingChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QInputMethod::animatingChanged")

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

}

func (ptr *QInputMethod) AnimatingChanged() {
	defer qt.Recovering("QInputMethod::animatingChanged")

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

func (ptr *QInputMethod) Commit() {
	defer qt.Recovering("QInputMethod::commit")

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

func (ptr *QInputMethod) ConnectCursorRectangleChanged(f func()) {
	defer qt.Recovering("connect QInputMethod::cursorRectangleChanged")

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

func (ptr *QInputMethod) DisconnectCursorRectangleChanged() {
	defer qt.Recovering("disconnect QInputMethod::cursorRectangleChanged")

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

//export callbackQInputMethodCursorRectangleChanged
func callbackQInputMethodCursorRectangleChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QInputMethod::cursorRectangleChanged")

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

}

func (ptr *QInputMethod) CursorRectangleChanged() {
	defer qt.Recovering("QInputMethod::cursorRectangleChanged")

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

func (ptr *QInputMethod) Hide() {
	defer qt.Recovering("QInputMethod::hide")

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

func (ptr *QInputMethod) ConnectInputDirectionChanged(f func(newDirection core.Qt__LayoutDirection)) {
	defer qt.Recovering("connect QInputMethod::inputDirectionChanged")

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

func (ptr *QInputMethod) DisconnectInputDirectionChanged() {
	defer qt.Recovering("disconnect QInputMethod::inputDirectionChanged")

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

//export callbackQInputMethodInputDirectionChanged
func callbackQInputMethodInputDirectionChanged(ptr unsafe.Pointer, ptrName *C.char, newDirection C.int) {
	defer qt.Recovering("callback QInputMethod::inputDirectionChanged")

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

}

func (ptr *QInputMethod) InputDirectionChanged(newDirection core.Qt__LayoutDirection) {
	defer qt.Recovering("QInputMethod::inputDirectionChanged")

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

func (ptr *QInputMethod) InvokeAction(a QInputMethod__Action, cursorPosition int) {
	defer qt.Recovering("QInputMethod::invokeAction")

	if ptr.Pointer() != nil {
		C.QInputMethod_InvokeAction(ptr.Pointer(), C.int(a), C.int(cursorPosition))
	}
}

func (ptr *QInputMethod) ConnectKeyboardRectangleChanged(f func()) {
	defer qt.Recovering("connect QInputMethod::keyboardRectangleChanged")

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

func (ptr *QInputMethod) DisconnectKeyboardRectangleChanged() {
	defer qt.Recovering("disconnect QInputMethod::keyboardRectangleChanged")

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

//export callbackQInputMethodKeyboardRectangleChanged
func callbackQInputMethodKeyboardRectangleChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QInputMethod::keyboardRectangleChanged")

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

}

func (ptr *QInputMethod) KeyboardRectangleChanged() {
	defer qt.Recovering("QInputMethod::keyboardRectangleChanged")

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

func (ptr *QInputMethod) ConnectLocaleChanged(f func()) {
	defer qt.Recovering("connect QInputMethod::localeChanged")

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

func (ptr *QInputMethod) DisconnectLocaleChanged() {
	defer qt.Recovering("disconnect QInputMethod::localeChanged")

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

//export callbackQInputMethodLocaleChanged
func callbackQInputMethodLocaleChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QInputMethod::localeChanged")

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

}

func (ptr *QInputMethod) LocaleChanged() {
	defer qt.Recovering("QInputMethod::localeChanged")

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

func QInputMethod_QueryFocusObject(query core.Qt__InputMethodQuery, argument core.QVariant_ITF) *core.QVariant {
	defer qt.Recovering("QInputMethod::queryFocusObject")

	return core.NewQVariantFromPointer(C.QInputMethod_QInputMethod_QueryFocusObject(C.int(query), core.PointerFromQVariant(argument)))
}

func (ptr *QInputMethod) Reset() {
	defer qt.Recovering("QInputMethod::reset")

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

func (ptr *QInputMethod) SetInputItemRectangle(rect core.QRectF_ITF) {
	defer qt.Recovering("QInputMethod::setInputItemRectangle")

	if ptr.Pointer() != nil {
		C.QInputMethod_SetInputItemRectangle(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QInputMethod) SetInputItemTransform(transform QTransform_ITF) {
	defer qt.Recovering("QInputMethod::setInputItemTransform")

	if ptr.Pointer() != nil {
		C.QInputMethod_SetInputItemTransform(ptr.Pointer(), PointerFromQTransform(transform))
	}
}

func (ptr *QInputMethod) SetVisible(visible bool) {
	defer qt.Recovering("QInputMethod::setVisible")

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

func (ptr *QInputMethod) Show() {
	defer qt.Recovering("QInputMethod::show")

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

func (ptr *QInputMethod) Update(queries core.Qt__InputMethodQuery) {
	defer qt.Recovering("QInputMethod::update")

	if ptr.Pointer() != nil {
		C.QInputMethod_Update(ptr.Pointer(), C.int(queries))
	}
}

func (ptr *QInputMethod) ConnectVisibleChanged(f func()) {
	defer qt.Recovering("connect QInputMethod::visibleChanged")

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

func (ptr *QInputMethod) DisconnectVisibleChanged() {
	defer qt.Recovering("disconnect QInputMethod::visibleChanged")

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

//export callbackQInputMethodVisibleChanged
func callbackQInputMethodVisibleChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QInputMethod::visibleChanged")

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

}

func (ptr *QInputMethod) VisibleChanged() {
	defer qt.Recovering("QInputMethod::visibleChanged")

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

type QInputMethodEvent struct {
	core.QEvent
}

type QInputMethodEvent_ITF interface {
	core.QEvent_ITF
	QInputMethodEvent_PTR() *QInputMethodEvent
}

func PointerFromQInputMethodEvent(ptr QInputMethodEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QInputMethodEvent_PTR().Pointer()
	}
	return nil
}

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

func newQInputMethodEventFromPointer(ptr unsafe.Pointer) *QInputMethodEvent {
	var n = NewQInputMethodEventFromPointer(ptr)
	return n
}

func (ptr *QInputMethodEvent) QInputMethodEvent_PTR() *QInputMethodEvent {
	return ptr
}

//QInputMethodEvent::AttributeType
type QInputMethodEvent__AttributeType int64

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

func NewQInputMethodEvent() *QInputMethodEvent {
	defer qt.Recovering("QInputMethodEvent::QInputMethodEvent")

	return newQInputMethodEventFromPointer(C.QInputMethodEvent_NewQInputMethodEvent())
}

func NewQInputMethodEvent3(other QInputMethodEvent_ITF) *QInputMethodEvent {
	defer qt.Recovering("QInputMethodEvent::QInputMethodEvent")

	return newQInputMethodEventFromPointer(C.QInputMethodEvent_NewQInputMethodEvent3(PointerFromQInputMethodEvent(other)))
}

func (ptr *QInputMethodEvent) CommitString() string {
	defer qt.Recovering("QInputMethodEvent::commitString")

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

func (ptr *QInputMethodEvent) PreeditString() string {
	defer qt.Recovering("QInputMethodEvent::preeditString")

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

func (ptr *QInputMethodEvent) ReplacementLength() int {
	defer qt.Recovering("QInputMethodEvent::replacementLength")

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

func (ptr *QInputMethodEvent) ReplacementStart() int {
	defer qt.Recovering("QInputMethodEvent::replacementStart")

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

func (ptr *QInputMethodEvent) SetCommitString(commitString string, replaceFrom int, replaceLength int) {
	defer qt.Recovering("QInputMethodEvent::setCommitString")

	if ptr.Pointer() != nil {
		C.QInputMethodEvent_SetCommitString(ptr.Pointer(), C.CString(commitString), C.int(replaceFrom), C.int(replaceLength))
	}
}

type QInputMethodQueryEvent struct {
	core.QEvent
}

type QInputMethodQueryEvent_ITF interface {
	core.QEvent_ITF
	QInputMethodQueryEvent_PTR() *QInputMethodQueryEvent
}

func PointerFromQInputMethodQueryEvent(ptr QInputMethodQueryEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QInputMethodQueryEvent_PTR().Pointer()
	}
	return nil
}

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

func newQInputMethodQueryEventFromPointer(ptr unsafe.Pointer) *QInputMethodQueryEvent {
	var n = NewQInputMethodQueryEventFromPointer(ptr)
	return n
}

func (ptr *QInputMethodQueryEvent) QInputMethodQueryEvent_PTR() *QInputMethodQueryEvent {
	return ptr
}

func NewQInputMethodQueryEvent(queries core.Qt__InputMethodQuery) *QInputMethodQueryEvent {
	defer qt.Recovering("QInputMethodQueryEvent::QInputMethodQueryEvent")

	return newQInputMethodQueryEventFromPointer(C.QInputMethodQueryEvent_NewQInputMethodQueryEvent(C.int(queries)))
}

func (ptr *QInputMethodQueryEvent) Queries() core.Qt__InputMethodQuery {
	defer qt.Recovering("QInputMethodQueryEvent::queries")

	if ptr.Pointer() != nil {
		return core.Qt__InputMethodQuery(C.QInputMethodQueryEvent_Queries(ptr.Pointer()))
	}
	return 0
}

func (ptr *QInputMethodQueryEvent) SetValue(query core.Qt__InputMethodQuery, value core.QVariant_ITF) {
	defer qt.Recovering("QInputMethodQueryEvent::setValue")

	if ptr.Pointer() != nil {
		C.QInputMethodQueryEvent_SetValue(ptr.Pointer(), C.int(query), core.PointerFromQVariant(value))
	}
}

func (ptr *QInputMethodQueryEvent) Value(query core.Qt__InputMethodQuery) *core.QVariant {
	defer qt.Recovering("QInputMethodQueryEvent::value")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QInputMethodQueryEvent_Value(ptr.Pointer(), C.int(query)))
	}
	return nil
}

type QIntValidator struct {
	QValidator
}

type QIntValidator_ITF interface {
	QValidator_ITF
	QIntValidator_PTR() *QIntValidator
}

func PointerFromQIntValidator(ptr QIntValidator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QIntValidator_PTR().Pointer()
	}
	return nil
}

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

func newQIntValidatorFromPointer(ptr unsafe.Pointer) *QIntValidator {
	var n = NewQIntValidatorFromPointer(ptr)
	for len(n.ObjectName()) < len("QIntValidator_") {
		n.SetObjectName("QIntValidator_" + qt.Identifier())
	}
	return n
}

func (ptr *QIntValidator) QIntValidator_PTR() *QIntValidator {
	return ptr
}

func (ptr *QIntValidator) SetBottom(v int) {
	defer qt.Recovering("QIntValidator::setBottom")

	if ptr.Pointer() != nil {
		C.QIntValidator_SetBottom(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QIntValidator) SetTop(v int) {
	defer qt.Recovering("QIntValidator::setTop")

	if ptr.Pointer() != nil {
		C.QIntValidator_SetTop(ptr.Pointer(), C.int(v))
	}
}

func NewQIntValidator(parent core.QObject_ITF) *QIntValidator {
	defer qt.Recovering("QIntValidator::QIntValidator")

	return newQIntValidatorFromPointer(C.QIntValidator_NewQIntValidator(core.PointerFromQObject(parent)))
}

func NewQIntValidator2(minimum int, maximum int, parent core.QObject_ITF) *QIntValidator {
	defer qt.Recovering("QIntValidator::QIntValidator")

	return newQIntValidatorFromPointer(C.QIntValidator_NewQIntValidator2(C.int(minimum), C.int(maximum), core.PointerFromQObject(parent)))
}

func (ptr *QIntValidator) Bottom() int {
	defer qt.Recovering("QIntValidator::bottom")

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

func (ptr *QIntValidator) ConnectSetRange(f func(bottom int, top int)) {
	defer qt.Recovering("connect QIntValidator::setRange")

	if ptr.Pointer() != nil {

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

func (ptr *QIntValidator) DisconnectSetRange() {
	defer qt.Recovering("disconnect QIntValidator::setRange")

	if ptr.Pointer() != nil {

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

//export callbackQIntValidatorSetRange
func callbackQIntValidatorSetRange(ptr unsafe.Pointer, ptrName *C.char, bottom C.int, top C.int) {
	defer qt.Recovering("callback QIntValidator::setRange")

	if signal := qt.GetSignal(C.GoString(ptrName), "setRange"); signal != nil {
		signal.(func(int, int))(int(bottom), int(top))
	} else {
		NewQIntValidatorFromPointer(ptr).SetRangeDefault(int(bottom), int(top))
	}
}

func (ptr *QIntValidator) SetRange(bottom int, top int) {
	defer qt.Recovering("QIntValidator::setRange")

	if ptr.Pointer() != nil {
		C.QIntValidator_SetRange(ptr.Pointer(), C.int(bottom), C.int(top))
	}
}

func (ptr *QIntValidator) SetRangeDefault(bottom int, top int) {
	defer qt.Recovering("QIntValidator::setRange")

	if ptr.Pointer() != nil {
		C.QIntValidator_SetRangeDefault(ptr.Pointer(), C.int(bottom), C.int(top))
	}
}

func (ptr *QIntValidator) Top() int {
	defer qt.Recovering("QIntValidator::top")

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

func (ptr *QIntValidator) DestroyQIntValidator() {
	defer qt.Recovering("QIntValidator::~QIntValidator")

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

type QKeyEvent struct {
	QInputEvent
}

type QKeyEvent_ITF interface {
	QInputEvent_ITF
	QKeyEvent_PTR() *QKeyEvent
}

func PointerFromQKeyEvent(ptr QKeyEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QKeyEvent_PTR().Pointer()
	}
	return nil
}

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

func newQKeyEventFromPointer(ptr unsafe.Pointer) *QKeyEvent {
	var n = NewQKeyEventFromPointer(ptr)
	return n
}

func (ptr *QKeyEvent) QKeyEvent_PTR() *QKeyEvent {
	return ptr
}

func (ptr *QKeyEvent) Matches(key QKeySequence__StandardKey) bool {
	defer qt.Recovering("QKeyEvent::matches")

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

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

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

func (ptr *QKeyEvent) IsAutoRepeat() bool {
	defer qt.Recovering("QKeyEvent::isAutoRepeat")

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

func (ptr *QKeyEvent) Key() int {
	defer qt.Recovering("QKeyEvent::key")

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

func (ptr *QKeyEvent) Modifiers() core.Qt__KeyboardModifier {
	defer qt.Recovering("QKeyEvent::modifiers")

	if ptr.Pointer() != nil {
		return core.Qt__KeyboardModifier(C.QKeyEvent_Modifiers(ptr.Pointer()))
	}
	return 0
}

func (ptr *QKeyEvent) Text() string {
	defer qt.Recovering("QKeyEvent::text")

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

type QKeySequence struct {
	ptr unsafe.Pointer
}

type QKeySequence_ITF interface {
	QKeySequence_PTR() *QKeySequence
}

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

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

func PointerFromQKeySequence(ptr QKeySequence_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QKeySequence_PTR().Pointer()
	}
	return nil
}

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

func newQKeySequenceFromPointer(ptr unsafe.Pointer) *QKeySequence {
	var n = NewQKeySequenceFromPointer(ptr)
	return n
}

func (ptr *QKeySequence) QKeySequence_PTR() *QKeySequence {
	return ptr
}

//QKeySequence::SequenceFormat
type QKeySequence__SequenceFormat int64

const (
	QKeySequence__NativeText   = QKeySequence__SequenceFormat(0)
	QKeySequence__PortableText = QKeySequence__SequenceFormat(1)
)

//QKeySequence::SequenceMatch
type QKeySequence__SequenceMatch int64

const (
	QKeySequence__NoMatch      = QKeySequence__SequenceMatch(0)
	QKeySequence__PartialMatch = QKeySequence__SequenceMatch(1)
	QKeySequence__ExactMatch   = QKeySequence__SequenceMatch(2)
)

//QKeySequence::StandardKey
type QKeySequence__StandardKey int64

const (
	QKeySequence__UnknownKey               = QKeySequence__StandardKey(0)
	QKeySequence__HelpContents             = QKeySequence__StandardKey(1)
	QKeySequence__WhatsThis                = QKeySequence__StandardKey(2)
	QKeySequence__Open                     = QKeySequence__StandardKey(3)
	QKeySequence__Close                    = QKeySequence__StandardKey(4)
	QKeySequence__Save                     = QKeySequence__StandardKey(5)
	QKeySequence__New                      = QKeySequence__StandardKey(6)
	QKeySequence__Delete                   = QKeySequence__StandardKey(7)
	QKeySequence__Cut                      = QKeySequence__StandardKey(8)
	QKeySequence__Copy                     = QKeySequence__StandardKey(9)
	QKeySequence__Paste                    = QKeySequence__StandardKey(10)
	QKeySequence__Undo                     = QKeySequence__StandardKey(11)
	QKeySequence__Redo                     = QKeySequence__StandardKey(12)
	QKeySequence__Back                     = QKeySequence__StandardKey(13)
	QKeySequence__Forward                  = QKeySequence__StandardKey(14)
	QKeySequence__Refresh                  = QKeySequence__StandardKey(15)
	QKeySequence__ZoomIn                   = QKeySequence__StandardKey(16)
	QKeySequence__ZoomOut                  = QKeySequence__StandardKey(17)
	QKeySequence__Print                    = QKeySequence__StandardKey(18)
	QKeySequence__AddTab                   = QKeySequence__StandardKey(19)
	QKeySequence__NextChild                = QKeySequence__StandardKey(20)
	QKeySequence__PreviousChild            = QKeySequence__StandardKey(21)
	QKeySequence__Find                     = QKeySequence__StandardKey(22)
	QKeySequence__FindNext                 = QKeySequence__StandardKey(23)
	QKeySequence__FindPrevious             = QKeySequence__StandardKey(24)
	QKeySequence__Replace                  = QKeySequence__StandardKey(25)
	QKeySequence__SelectAll                = QKeySequence__StandardKey(26)
	QKeySequence__Bold                     = QKeySequence__StandardKey(27)
	QKeySequence__Italic                   = QKeySequence__StandardKey(28)
	QKeySequence__Underline                = QKeySequence__StandardKey(29)
	QKeySequence__MoveToNextChar           = QKeySequence__StandardKey(30)
	QKeySequence__MoveToPreviousChar       = QKeySequence__StandardKey(31)
	QKeySequence__MoveToNextWord           = QKeySequence__StandardKey(32)
	QKeySequence__MoveToPreviousWord       = QKeySequence__StandardKey(33)
	QKeySequence__MoveToNextLine           = QKeySequence__StandardKey(34)
	QKeySequence__MoveToPreviousLine       = QKeySequence__StandardKey(35)
	QKeySequence__MoveToNextPage           = QKeySequence__StandardKey(36)
	QKeySequence__MoveToPreviousPage       = QKeySequence__StandardKey(37)
	QKeySequence__MoveToStartOfLine        = QKeySequence__StandardKey(38)
	QKeySequence__MoveToEndOfLine          = QKeySequence__StandardKey(39)
	QKeySequence__MoveToStartOfBlock       = QKeySequence__StandardKey(40)
	QKeySequence__MoveToEndOfBlock         = QKeySequence__StandardKey(41)
	QKeySequence__MoveToStartOfDocument    = QKeySequence__StandardKey(42)
	QKeySequence__MoveToEndOfDocument      = QKeySequence__StandardKey(43)
	QKeySequence__SelectNextChar           = QKeySequence__StandardKey(44)
	QKeySequence__SelectPreviousChar       = QKeySequence__StandardKey(45)
	QKeySequence__SelectNextWord           = QKeySequence__StandardKey(46)
	QKeySequence__SelectPreviousWord       = QKeySequence__StandardKey(47)
	QKeySequence__SelectNextLine           = QKeySequence__StandardKey(48)
	QKeySequence__SelectPreviousLine       = QKeySequence__StandardKey(49)
	QKeySequence__SelectNextPage           = QKeySequence__StandardKey(50)
	QKeySequence__SelectPreviousPage       = QKeySequence__StandardKey(51)
	QKeySequence__SelectStartOfLine        = QKeySequence__StandardKey(52)
	QKeySequence__SelectEndOfLine          = QKeySequence__StandardKey(53)
	QKeySequence__SelectStartOfBlock       = QKeySequence__StandardKey(54)
	QKeySequence__SelectEndOfBlock         = QKeySequence__StandardKey(55)
	QKeySequence__SelectStartOfDocument    = QKeySequence__StandardKey(56)
	QKeySequence__SelectEndOfDocument      = QKeySequence__StandardKey(57)
	QKeySequence__DeleteStartOfWord        = QKeySequence__StandardKey(58)
	QKeySequence__DeleteEndOfWord          = QKeySequence__StandardKey(59)
	QKeySequence__DeleteEndOfLine          = QKeySequence__StandardKey(60)
	QKeySequence__InsertParagraphSeparator = QKeySequence__StandardKey(61)
	QKeySequence__InsertLineSeparator      = QKeySequence__StandardKey(62)
	QKeySequence__SaveAs                   = QKeySequence__StandardKey(63)
	QKeySequence__Preferences              = QKeySequence__StandardKey(64)
	QKeySequence__Quit                     = QKeySequence__StandardKey(65)
	QKeySequence__FullScreen               = QKeySequence__StandardKey(66)
	QKeySequence__Deselect                 = QKeySequence__StandardKey(67)
	QKeySequence__DeleteCompleteLine       = QKeySequence__StandardKey(68)
	QKeySequence__Backspace                = QKeySequence__StandardKey(69)
)

func NewQKeySequence() *QKeySequence {
	defer qt.Recovering("QKeySequence::QKeySequence")

	return newQKeySequenceFromPointer(C.QKeySequence_NewQKeySequence())
}

func NewQKeySequence5(key QKeySequence__StandardKey) *QKeySequence {
	defer qt.Recovering("QKeySequence::QKeySequence")

	return newQKeySequenceFromPointer(C.QKeySequence_NewQKeySequence5(C.int(key)))
}

func NewQKeySequence4(keysequence QKeySequence_ITF) *QKeySequence {
	defer qt.Recovering("QKeySequence::QKeySequence")

	return newQKeySequenceFromPointer(C.QKeySequence_NewQKeySequence4(PointerFromQKeySequence(keysequence)))
}

func NewQKeySequence2(key string, format QKeySequence__SequenceFormat) *QKeySequence {
	defer qt.Recovering("QKeySequence::QKeySequence")

	return newQKeySequenceFromPointer(C.QKeySequence_NewQKeySequence2(C.CString(key), C.int(format)))
}

func NewQKeySequence3(k1 int, k2 int, k3 int, k4 int) *QKeySequence {
	defer qt.Recovering("QKeySequence::QKeySequence")

	return newQKeySequenceFromPointer(C.QKeySequence_NewQKeySequence3(C.int(k1), C.int(k2), C.int(k3), C.int(k4)))
}

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

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

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

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

func (ptr *QKeySequence) Matches(seq QKeySequence_ITF) QKeySequence__SequenceMatch {
	defer qt.Recovering("QKeySequence::matches")

	if ptr.Pointer() != nil {
		return QKeySequence__SequenceMatch(C.QKeySequence_Matches(ptr.Pointer(), PointerFromQKeySequence(seq)))
	}
	return 0
}

func (ptr *QKeySequence) Swap(other QKeySequence_ITF) {
	defer qt.Recovering("QKeySequence::swap")

	if ptr.Pointer() != nil {
		C.QKeySequence_Swap(ptr.Pointer(), PointerFromQKeySequence(other))
	}
}

func (ptr *QKeySequence) ToString(format QKeySequence__SequenceFormat) string {
	defer qt.Recovering("QKeySequence::toString")

	if ptr.Pointer() != nil {
		return C.GoString(C.QKeySequence_ToString(ptr.Pointer(), C.int(format)))
	}
	return ""
}

func (ptr *QKeySequence) DestroyQKeySequence() {
	defer qt.Recovering("QKeySequence::~QKeySequence")

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

type QLinearGradient struct {
	QGradient
}

type QLinearGradient_ITF interface {
	QGradient_ITF
	QLinearGradient_PTR() *QLinearGradient
}

func PointerFromQLinearGradient(ptr QLinearGradient_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QLinearGradient_PTR().Pointer()
	}
	return nil
}

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

func newQLinearGradientFromPointer(ptr unsafe.Pointer) *QLinearGradient {
	var n = NewQLinearGradientFromPointer(ptr)
	return n
}

func (ptr *QLinearGradient) QLinearGradient_PTR() *QLinearGradient {
	return ptr
}

func NewQLinearGradient3(x1 float64, y1 float64, x2 float64, y2 float64) *QLinearGradient {
	defer qt.Recovering("QLinearGradient::QLinearGradient")

	return newQLinearGradientFromPointer(C.QLinearGradient_NewQLinearGradient3(C.double(x1), C.double(y1), C.double(x2), C.double(y2)))
}

func NewQLinearGradient() *QLinearGradient {
	defer qt.Recovering("QLinearGradient::QLinearGradient")

	return newQLinearGradientFromPointer(C.QLinearGradient_NewQLinearGradient())
}

func NewQLinearGradient2(start core.QPointF_ITF, finalStop core.QPointF_ITF) *QLinearGradient {
	defer qt.Recovering("QLinearGradient::QLinearGradient")

	return newQLinearGradientFromPointer(C.QLinearGradient_NewQLinearGradient2(core.PointerFromQPointF(start), core.PointerFromQPointF(finalStop)))
}

func (ptr *QLinearGradient) SetFinalStop(stop core.QPointF_ITF) {
	defer qt.Recovering("QLinearGradient::setFinalStop")

	if ptr.Pointer() != nil {
		C.QLinearGradient_SetFinalStop(ptr.Pointer(), core.PointerFromQPointF(stop))
	}
}

func (ptr *QLinearGradient) SetFinalStop2(x float64, y float64) {
	defer qt.Recovering("QLinearGradient::setFinalStop")

	if ptr.Pointer() != nil {
		C.QLinearGradient_SetFinalStop2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QLinearGradient) SetStart(start core.QPointF_ITF) {
	defer qt.Recovering("QLinearGradient::setStart")

	if ptr.Pointer() != nil {
		C.QLinearGradient_SetStart(ptr.Pointer(), core.PointerFromQPointF(start))
	}
}

func (ptr *QLinearGradient) SetStart2(x float64, y float64) {
	defer qt.Recovering("QLinearGradient::setStart")

	if ptr.Pointer() != nil {
		C.QLinearGradient_SetStart2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

type QMatrix4x4 struct {
	ptr unsafe.Pointer
}

type QMatrix4x4_ITF interface {
	QMatrix4x4_PTR() *QMatrix4x4
}

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

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

func PointerFromQMatrix4x4(ptr QMatrix4x4_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMatrix4x4_PTR().Pointer()
	}
	return nil
}

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

func newQMatrix4x4FromPointer(ptr unsafe.Pointer) *QMatrix4x4 {
	var n = NewQMatrix4x4FromPointer(ptr)
	return n
}

func (ptr *QMatrix4x4) QMatrix4x4_PTR() *QMatrix4x4 {
	return ptr
}

func NewQMatrix4x4() *QMatrix4x4 {
	defer qt.Recovering("QMatrix4x4::QMatrix4x4")

	return newQMatrix4x4FromPointer(C.QMatrix4x4_NewQMatrix4x4())
}

func NewQMatrix4x47(transform QTransform_ITF) *QMatrix4x4 {
	defer qt.Recovering("QMatrix4x4::QMatrix4x4")

	return newQMatrix4x4FromPointer(C.QMatrix4x4_NewQMatrix4x47(PointerFromQTransform(transform)))
}

func (ptr *QMatrix4x4) IsAffine() bool {
	defer qt.Recovering("QMatrix4x4::isAffine")

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

func (ptr *QMatrix4x4) IsIdentity() bool {
	defer qt.Recovering("QMatrix4x4::isIdentity")

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

func (ptr *QMatrix4x4) LookAt(eye QVector3D_ITF, center QVector3D_ITF, up QVector3D_ITF) {
	defer qt.Recovering("QMatrix4x4::lookAt")

	if ptr.Pointer() != nil {
		C.QMatrix4x4_LookAt(ptr.Pointer(), PointerFromQVector3D(eye), PointerFromQVector3D(center), PointerFromQVector3D(up))
	}
}

func (ptr *QMatrix4x4) Map(point core.QPoint_ITF) *core.QPoint {
	defer qt.Recovering("QMatrix4x4::map")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QMatrix4x4_Map(ptr.Pointer(), core.PointerFromQPoint(point)))
	}
	return nil
}

func (ptr *QMatrix4x4) MapRect(rect core.QRect_ITF) *core.QRect {
	defer qt.Recovering("QMatrix4x4::mapRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QMatrix4x4_MapRect(ptr.Pointer(), core.PointerFromQRect(rect)))
	}
	return nil
}

func (ptr *QMatrix4x4) Optimize() {
	defer qt.Recovering("QMatrix4x4::optimize")

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

func (ptr *QMatrix4x4) Ortho2(rect core.QRect_ITF) {
	defer qt.Recovering("QMatrix4x4::ortho")

	if ptr.Pointer() != nil {
		C.QMatrix4x4_Ortho2(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QMatrix4x4) Ortho3(rect core.QRectF_ITF) {
	defer qt.Recovering("QMatrix4x4::ortho")

	if ptr.Pointer() != nil {
		C.QMatrix4x4_Ortho3(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QMatrix4x4) Rotate2(quaternion QQuaternion_ITF) {
	defer qt.Recovering("QMatrix4x4::rotate")

	if ptr.Pointer() != nil {
		C.QMatrix4x4_Rotate2(ptr.Pointer(), PointerFromQQuaternion(quaternion))
	}
}

func (ptr *QMatrix4x4) Scale(vector QVector3D_ITF) {
	defer qt.Recovering("QMatrix4x4::scale")

	if ptr.Pointer() != nil {
		C.QMatrix4x4_Scale(ptr.Pointer(), PointerFromQVector3D(vector))
	}
}

func (ptr *QMatrix4x4) SetColumn(index int, value QVector4D_ITF) {
	defer qt.Recovering("QMatrix4x4::setColumn")

	if ptr.Pointer() != nil {
		C.QMatrix4x4_SetColumn(ptr.Pointer(), C.int(index), PointerFromQVector4D(value))
	}
}

func (ptr *QMatrix4x4) SetRow(index int, value QVector4D_ITF) {
	defer qt.Recovering("QMatrix4x4::setRow")

	if ptr.Pointer() != nil {
		C.QMatrix4x4_SetRow(ptr.Pointer(), C.int(index), PointerFromQVector4D(value))
	}
}

func (ptr *QMatrix4x4) SetToIdentity() {
	defer qt.Recovering("QMatrix4x4::setToIdentity")

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

func (ptr *QMatrix4x4) Translate(vector QVector3D_ITF) {
	defer qt.Recovering("QMatrix4x4::translate")

	if ptr.Pointer() != nil {
		C.QMatrix4x4_Translate(ptr.Pointer(), PointerFromQVector3D(vector))
	}
}

func (ptr *QMatrix4x4) Viewport2(rect core.QRectF_ITF) {
	defer qt.Recovering("QMatrix4x4::viewport")

	if ptr.Pointer() != nil {
		C.QMatrix4x4_Viewport2(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

type QMouseEvent struct {
	QInputEvent
}

type QMouseEvent_ITF interface {
	QInputEvent_ITF
	QMouseEvent_PTR() *QMouseEvent
}

func PointerFromQMouseEvent(ptr QMouseEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMouseEvent_PTR().Pointer()
	}
	return nil
}

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

func newQMouseEventFromPointer(ptr unsafe.Pointer) *QMouseEvent {
	var n = NewQMouseEventFromPointer(ptr)
	return n
}

func (ptr *QMouseEvent) QMouseEvent_PTR() *QMouseEvent {
	return ptr
}

func NewQMouseEvent(ty core.QEvent__Type, localPos core.QPointF_ITF, button core.Qt__MouseButton, buttons core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier) *QMouseEvent {
	defer qt.Recovering("QMouseEvent::QMouseEvent")

	return newQMouseEventFromPointer(C.QMouseEvent_NewQMouseEvent(C.int(ty), core.PointerFromQPointF(localPos), C.int(button), C.int(buttons), C.int(modifiers)))
}

func NewQMouseEvent2(ty core.QEvent__Type, localPos core.QPointF_ITF, screenPos core.QPointF_ITF, button core.Qt__MouseButton, buttons core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier) *QMouseEvent {
	defer qt.Recovering("QMouseEvent::QMouseEvent")

	return newQMouseEventFromPointer(C.QMouseEvent_NewQMouseEvent2(C.int(ty), core.PointerFromQPointF(localPos), core.PointerFromQPointF(screenPos), C.int(button), C.int(buttons), C.int(modifiers)))
}

func NewQMouseEvent3(ty core.QEvent__Type, localPos core.QPointF_ITF, windowPos core.QPointF_ITF, screenPos core.QPointF_ITF, button core.Qt__MouseButton, buttons core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier) *QMouseEvent {
	defer qt.Recovering("QMouseEvent::QMouseEvent")

	return newQMouseEventFromPointer(C.QMouseEvent_NewQMouseEvent3(C.int(ty), core.PointerFromQPointF(localPos), core.PointerFromQPointF(windowPos), core.PointerFromQPointF(screenPos), C.int(button), C.int(buttons), C.int(modifiers)))
}

func (ptr *QMouseEvent) Button() core.Qt__MouseButton {
	defer qt.Recovering("QMouseEvent::button")

	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QMouseEvent_Button(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMouseEvent) Buttons() core.Qt__MouseButton {
	defer qt.Recovering("QMouseEvent::buttons")

	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QMouseEvent_Buttons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMouseEvent) Flags() core.Qt__MouseEventFlag {
	defer qt.Recovering("QMouseEvent::flags")

	if ptr.Pointer() != nil {
		return core.Qt__MouseEventFlag(C.QMouseEvent_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMouseEvent) GlobalPos() *core.QPoint {
	defer qt.Recovering("QMouseEvent::globalPos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QMouseEvent_GlobalPos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMouseEvent) GlobalX() int {
	defer qt.Recovering("QMouseEvent::globalX")

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

func (ptr *QMouseEvent) GlobalY() int {
	defer qt.Recovering("QMouseEvent::globalY")

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

func (ptr *QMouseEvent) Pos() *core.QPoint {
	defer qt.Recovering("QMouseEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QMouseEvent_Pos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMouseEvent) Source() core.Qt__MouseEventSource {
	defer qt.Recovering("QMouseEvent::source")

	if ptr.Pointer() != nil {
		return core.Qt__MouseEventSource(C.QMouseEvent_Source(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMouseEvent) X() int {
	defer qt.Recovering("QMouseEvent::x")

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

func (ptr *QMouseEvent) Y() int {
	defer qt.Recovering("QMouseEvent::y")

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

type QMoveEvent struct {
	core.QEvent
}

type QMoveEvent_ITF interface {
	core.QEvent_ITF
	QMoveEvent_PTR() *QMoveEvent
}

func PointerFromQMoveEvent(ptr QMoveEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMoveEvent_PTR().Pointer()
	}
	return nil
}

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

func newQMoveEventFromPointer(ptr unsafe.Pointer) *QMoveEvent {
	var n = NewQMoveEventFromPointer(ptr)
	return n
}

func (ptr *QMoveEvent) QMoveEvent_PTR() *QMoveEvent {
	return ptr
}

func NewQMoveEvent(pos core.QPoint_ITF, oldPos core.QPoint_ITF) *QMoveEvent {
	defer qt.Recovering("QMoveEvent::QMoveEvent")

	return newQMoveEventFromPointer(C.QMoveEvent_NewQMoveEvent(core.PointerFromQPoint(pos), core.PointerFromQPoint(oldPos)))
}

func (ptr *QMoveEvent) OldPos() *core.QPoint {
	defer qt.Recovering("QMoveEvent::oldPos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QMoveEvent_OldPos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMoveEvent) Pos() *core.QPoint {
	defer qt.Recovering("QMoveEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QMoveEvent_Pos(ptr.Pointer()))
	}
	return nil
}

type QMovie struct {
	core.QObject
}

type QMovie_ITF interface {
	core.QObject_ITF
	QMovie_PTR() *QMovie
}

func PointerFromQMovie(ptr QMovie_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMovie_PTR().Pointer()
	}
	return nil
}

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

func newQMovieFromPointer(ptr unsafe.Pointer) *QMovie {
	var n = NewQMovieFromPointer(ptr)
	for len(n.ObjectName()) < len("QMovie_") {
		n.SetObjectName("QMovie_" + qt.Identifier())
	}
	return n
}

func (ptr *QMovie) QMovie_PTR() *QMovie {
	return ptr
}

//QMovie::CacheMode
type QMovie__CacheMode int64

const (
	QMovie__CacheNone = QMovie__CacheMode(0)
	QMovie__CacheAll  = QMovie__CacheMode(1)
)

//QMovie::MovieState
type QMovie__MovieState int64

const (
	QMovie__NotRunning = QMovie__MovieState(0)
	QMovie__Paused     = QMovie__MovieState(1)
	QMovie__Running    = QMovie__MovieState(2)
)

func (ptr *QMovie) CacheMode() QMovie__CacheMode {
	defer qt.Recovering("QMovie::cacheMode")

	if ptr.Pointer() != nil {
		return QMovie__CacheMode(C.QMovie_CacheMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMovie) SetCacheMode(mode QMovie__CacheMode) {
	defer qt.Recovering("QMovie::setCacheMode")

	if ptr.Pointer() != nil {
		C.QMovie_SetCacheMode(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QMovie) SetSpeed(percentSpeed int) {
	defer qt.Recovering("QMovie::setSpeed")

	if ptr.Pointer() != nil {
		C.QMovie_SetSpeed(ptr.Pointer(), C.int(percentSpeed))
	}
}

func (ptr *QMovie) Speed() int {
	defer qt.Recovering("QMovie::speed")

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

func NewQMovie2(device core.QIODevice_ITF, format core.QByteArray_ITF, parent core.QObject_ITF) *QMovie {
	defer qt.Recovering("QMovie::QMovie")

	return newQMovieFromPointer(C.QMovie_NewQMovie2(core.PointerFromQIODevice(device), core.PointerFromQByteArray(format), core.PointerFromQObject(parent)))
}

func NewQMovie(parent core.QObject_ITF) *QMovie {
	defer qt.Recovering("QMovie::QMovie")

	return newQMovieFromPointer(C.QMovie_NewQMovie(core.PointerFromQObject(parent)))
}

func NewQMovie3(fileName string, format core.QByteArray_ITF, parent core.QObject_ITF) *QMovie {
	defer qt.Recovering("QMovie::QMovie")

	return newQMovieFromPointer(C.QMovie_NewQMovie3(C.CString(fileName), core.PointerFromQByteArray(format), core.PointerFromQObject(parent)))
}

func (ptr *QMovie) BackgroundColor() *QColor {
	defer qt.Recovering("QMovie::backgroundColor")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QMovie_BackgroundColor(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMovie) CurrentFrameNumber() int {
	defer qt.Recovering("QMovie::currentFrameNumber")

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

func (ptr *QMovie) Device() *core.QIODevice {
	defer qt.Recovering("QMovie::device")

	if ptr.Pointer() != nil {
		return core.NewQIODeviceFromPointer(C.QMovie_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMovie) ConnectError(f func(error QImageReader__ImageReaderError)) {
	defer qt.Recovering("connect QMovie::error")

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

func (ptr *QMovie) DisconnectError() {
	defer qt.Recovering("disconnect QMovie::error")

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

//export callbackQMovieError
func callbackQMovieError(ptr unsafe.Pointer, ptrName *C.char, error C.int) {
	defer qt.Recovering("callback QMovie::error")

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

}

func (ptr *QMovie) Error(error QImageReader__ImageReaderError) {
	defer qt.Recovering("QMovie::error")

	if ptr.Pointer() != nil {
		C.QMovie_Error(ptr.Pointer(), C.int(error))
	}
}

func (ptr *QMovie) FileName() string {
	defer qt.Recovering("QMovie::fileName")

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

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

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

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

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

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

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

}

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

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

func (ptr *QMovie) Format() *core.QByteArray {
	defer qt.Recovering("QMovie::format")

	if ptr.Pointer() != nil {
		return core.NewQByteArrayFromPointer(C.QMovie_Format(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMovie) ConnectFrameChanged(f func(frameNumber int)) {
	defer qt.Recovering("connect QMovie::frameChanged")

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

func (ptr *QMovie) DisconnectFrameChanged() {
	defer qt.Recovering("disconnect QMovie::frameChanged")

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

//export callbackQMovieFrameChanged
func callbackQMovieFrameChanged(ptr unsafe.Pointer, ptrName *C.char, frameNumber C.int) {
	defer qt.Recovering("callback QMovie::frameChanged")

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

}

func (ptr *QMovie) FrameChanged(frameNumber int) {
	defer qt.Recovering("QMovie::frameChanged")

	if ptr.Pointer() != nil {
		C.QMovie_FrameChanged(ptr.Pointer(), C.int(frameNumber))
	}
}

func (ptr *QMovie) FrameCount() int {
	defer qt.Recovering("QMovie::frameCount")

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

func (ptr *QMovie) FrameRect() *core.QRect {
	defer qt.Recovering("QMovie::frameRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QMovie_FrameRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMovie) IsValid() bool {
	defer qt.Recovering("QMovie::isValid")

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

func (ptr *QMovie) JumpToFrame(frameNumber int) bool {
	defer qt.Recovering("QMovie::jumpToFrame")

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

func (ptr *QMovie) JumpToNextFrame() bool {
	defer qt.Recovering("QMovie::jumpToNextFrame")

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

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

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

func (ptr *QMovie) NextFrameDelay() int {
	defer qt.Recovering("QMovie::nextFrameDelay")

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

func (ptr *QMovie) ConnectResized(f func(size *core.QSize)) {
	defer qt.Recovering("connect QMovie::resized")

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

func (ptr *QMovie) DisconnectResized() {
	defer qt.Recovering("disconnect QMovie::resized")

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

//export callbackQMovieResized
func callbackQMovieResized(ptr unsafe.Pointer, ptrName *C.char, size unsafe.Pointer) {
	defer qt.Recovering("callback QMovie::resized")

	if signal := qt.GetSignal(C.GoString(ptrName), "resized"); signal != nil {
		signal.(func(*core.QSize))(core.NewQSizeFromPointer(size))
	}

}

func (ptr *QMovie) Resized(size core.QSize_ITF) {
	defer qt.Recovering("QMovie::resized")

	if ptr.Pointer() != nil {
		C.QMovie_Resized(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QMovie) ScaledSize() *core.QSize {
	defer qt.Recovering("QMovie::scaledSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QMovie_ScaledSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QMovie) SetBackgroundColor(color QColor_ITF) {
	defer qt.Recovering("QMovie::setBackgroundColor")

	if ptr.Pointer() != nil {
		C.QMovie_SetBackgroundColor(ptr.Pointer(), PointerFromQColor(color))
	}
}

func (ptr *QMovie) SetDevice(device core.QIODevice_ITF) {
	defer qt.Recovering("QMovie::setDevice")

	if ptr.Pointer() != nil {
		C.QMovie_SetDevice(ptr.Pointer(), core.PointerFromQIODevice(device))
	}
}

func (ptr *QMovie) SetFileName(fileName string) {
	defer qt.Recovering("QMovie::setFileName")

	if ptr.Pointer() != nil {
		C.QMovie_SetFileName(ptr.Pointer(), C.CString(fileName))
	}
}

func (ptr *QMovie) SetFormat(format core.QByteArray_ITF) {
	defer qt.Recovering("QMovie::setFormat")

	if ptr.Pointer() != nil {
		C.QMovie_SetFormat(ptr.Pointer(), core.PointerFromQByteArray(format))
	}
}

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

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

func (ptr *QMovie) SetScaledSize(size core.QSize_ITF) {
	defer qt.Recovering("QMovie::setScaledSize")

	if ptr.Pointer() != nil {
		C.QMovie_SetScaledSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QMovie) Start() {
	defer qt.Recovering("QMovie::start")

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

func (ptr *QMovie) ConnectStarted(f func()) {
	defer qt.Recovering("connect QMovie::started")

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

func (ptr *QMovie) DisconnectStarted() {
	defer qt.Recovering("disconnect QMovie::started")

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

//export callbackQMovieStarted
func callbackQMovieStarted(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QMovie::started")

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

}

func (ptr *QMovie) Started() {
	defer qt.Recovering("QMovie::started")

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

func (ptr *QMovie) State() QMovie__MovieState {
	defer qt.Recovering("QMovie::state")

	if ptr.Pointer() != nil {
		return QMovie__MovieState(C.QMovie_State(ptr.Pointer()))
	}
	return 0
}

func (ptr *QMovie) ConnectStateChanged(f func(state QMovie__MovieState)) {
	defer qt.Recovering("connect QMovie::stateChanged")

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

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

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

//export callbackQMovieStateChanged
func callbackQMovieStateChanged(ptr unsafe.Pointer, ptrName *C.char, state C.int) {
	defer qt.Recovering("callback QMovie::stateChanged")

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

}

func (ptr *QMovie) StateChanged(state QMovie__MovieState) {
	defer qt.Recovering("QMovie::stateChanged")

	if ptr.Pointer() != nil {
		C.QMovie_StateChanged(ptr.Pointer(), C.int(state))
	}
}

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

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

func (ptr *QMovie) ConnectUpdated(f func(rect *core.QRect)) {
	defer qt.Recovering("connect QMovie::updated")

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

func (ptr *QMovie) DisconnectUpdated() {
	defer qt.Recovering("disconnect QMovie::updated")

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

//export callbackQMovieUpdated
func callbackQMovieUpdated(ptr unsafe.Pointer, ptrName *C.char, rect unsafe.Pointer) {
	defer qt.Recovering("callback QMovie::updated")

	if signal := qt.GetSignal(C.GoString(ptrName), "updated"); signal != nil {
		signal.(func(*core.QRect))(core.NewQRectFromPointer(rect))
	}

}

func (ptr *QMovie) Updated(rect core.QRect_ITF) {
	defer qt.Recovering("QMovie::updated")

	if ptr.Pointer() != nil {
		C.QMovie_Updated(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QMovie) DestroyQMovie() {
	defer qt.Recovering("QMovie::~QMovie")

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

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

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

	if ptr.Pointer() != nil {

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

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

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

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

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

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

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

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

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QMovie) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QMovie::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQMovieCustomEvent
func callbackQMovieCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QMovie::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQMovieFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QMovie) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QMovie::customEvent")

	if ptr.Pointer() != nil {
		C.QMovie_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QMovie) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QMovie::customEvent")

	if ptr.Pointer() != nil {
		C.QMovie_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QNativeGestureEvent struct {
	QInputEvent
}

type QNativeGestureEvent_ITF interface {
	QInputEvent_ITF
	QNativeGestureEvent_PTR() *QNativeGestureEvent
}

func PointerFromQNativeGestureEvent(ptr QNativeGestureEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QNativeGestureEvent_PTR().Pointer()
	}
	return nil
}

func NewQNativeGestureEventFromPointer(ptr unsafe.Pointer) *QNativeGestureEvent {
	var n = new(QNativeGestureEvent)
	n.SetPointer(ptr)
	return n
}

func newQNativeGestureEventFromPointer(ptr unsafe.Pointer) *QNativeGestureEvent {
	var n = NewQNativeGestureEventFromPointer(ptr)
	return n
}

func (ptr *QNativeGestureEvent) QNativeGestureEvent_PTR() *QNativeGestureEvent {
	return ptr
}

func (ptr *QNativeGestureEvent) GestureType() core.Qt__NativeGestureType {
	defer qt.Recovering("QNativeGestureEvent::gestureType")

	if ptr.Pointer() != nil {
		return core.Qt__NativeGestureType(C.QNativeGestureEvent_GestureType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QNativeGestureEvent) GlobalPos() *core.QPoint {
	defer qt.Recovering("QNativeGestureEvent::globalPos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QNativeGestureEvent_GlobalPos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QNativeGestureEvent) Pos() *core.QPoint {
	defer qt.Recovering("QNativeGestureEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QNativeGestureEvent_Pos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QNativeGestureEvent) Value() float64 {
	defer qt.Recovering("QNativeGestureEvent::value")

	if ptr.Pointer() != nil {
		return float64(C.QNativeGestureEvent_Value(ptr.Pointer()))
	}
	return 0
}

type QOffscreenSurface struct {
	core.QObject
	QSurface
}

type QOffscreenSurface_ITF interface {
	core.QObject_ITF
	QSurface_ITF
	QOffscreenSurface_PTR() *QOffscreenSurface
}

func (p *QOffscreenSurface) Pointer() unsafe.Pointer {
	return p.QObject_PTR().Pointer()
}

func (p *QOffscreenSurface) SetPointer(ptr unsafe.Pointer) {
	p.QObject_PTR().SetPointer(ptr)
	p.QSurface_PTR().SetPointer(ptr)
}

func PointerFromQOffscreenSurface(ptr QOffscreenSurface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOffscreenSurface_PTR().Pointer()
	}
	return nil
}

func NewQOffscreenSurfaceFromPointer(ptr unsafe.Pointer) *QOffscreenSurface {
	var n = new(QOffscreenSurface)
	n.SetPointer(ptr)
	return n
}

func newQOffscreenSurfaceFromPointer(ptr unsafe.Pointer) *QOffscreenSurface {
	var n = NewQOffscreenSurfaceFromPointer(ptr)
	for len(n.ObjectName()) < len("QOffscreenSurface_") {
		n.SetObjectName("QOffscreenSurface_" + qt.Identifier())
	}
	return n
}

func (ptr *QOffscreenSurface) QOffscreenSurface_PTR() *QOffscreenSurface {
	return ptr
}

func NewQOffscreenSurface(targetScreen QScreen_ITF) *QOffscreenSurface {
	defer qt.Recovering("QOffscreenSurface::QOffscreenSurface")

	return newQOffscreenSurfaceFromPointer(C.QOffscreenSurface_NewQOffscreenSurface(PointerFromQScreen(targetScreen)))
}

func (ptr *QOffscreenSurface) Create() {
	defer qt.Recovering("QOffscreenSurface::create")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_Create(ptr.Pointer())
	}
}

func (ptr *QOffscreenSurface) Destroy() {
	defer qt.Recovering("QOffscreenSurface::destroy")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_Destroy(ptr.Pointer())
	}
}

func (ptr *QOffscreenSurface) IsValid() bool {
	defer qt.Recovering("QOffscreenSurface::isValid")

	if ptr.Pointer() != nil {
		return C.QOffscreenSurface_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QOffscreenSurface) Screen() *QScreen {
	defer qt.Recovering("QOffscreenSurface::screen")

	if ptr.Pointer() != nil {
		return NewQScreenFromPointer(C.QOffscreenSurface_Screen(ptr.Pointer()))
	}
	return nil
}

func (ptr *QOffscreenSurface) ConnectScreenChanged(f func(screen *QScreen)) {
	defer qt.Recovering("connect QOffscreenSurface::screenChanged")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_ConnectScreenChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "screenChanged", f)
	}
}

func (ptr *QOffscreenSurface) DisconnectScreenChanged() {
	defer qt.Recovering("disconnect QOffscreenSurface::screenChanged")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_DisconnectScreenChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "screenChanged")
	}
}

//export callbackQOffscreenSurfaceScreenChanged
func callbackQOffscreenSurfaceScreenChanged(ptr unsafe.Pointer, ptrName *C.char, screen unsafe.Pointer) {
	defer qt.Recovering("callback QOffscreenSurface::screenChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "screenChanged"); signal != nil {
		signal.(func(*QScreen))(NewQScreenFromPointer(screen))
	}

}

func (ptr *QOffscreenSurface) ScreenChanged(screen QScreen_ITF) {
	defer qt.Recovering("QOffscreenSurface::screenChanged")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_ScreenChanged(ptr.Pointer(), PointerFromQScreen(screen))
	}
}

func (ptr *QOffscreenSurface) SetFormat(format QSurfaceFormat_ITF) {
	defer qt.Recovering("QOffscreenSurface::setFormat")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_SetFormat(ptr.Pointer(), PointerFromQSurfaceFormat(format))
	}
}

func (ptr *QOffscreenSurface) SetScreen(newScreen QScreen_ITF) {
	defer qt.Recovering("QOffscreenSurface::setScreen")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_SetScreen(ptr.Pointer(), PointerFromQScreen(newScreen))
	}
}

func (ptr *QOffscreenSurface) Size() *core.QSize {
	defer qt.Recovering("QOffscreenSurface::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QOffscreenSurface_Size(ptr.Pointer()))
	}
	return nil
}

func (ptr *QOffscreenSurface) SurfaceType() QSurface__SurfaceType {
	defer qt.Recovering("QOffscreenSurface::surfaceType")

	if ptr.Pointer() != nil {
		return QSurface__SurfaceType(C.QOffscreenSurface_SurfaceType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QOffscreenSurface) DestroyQOffscreenSurface() {
	defer qt.Recovering("QOffscreenSurface::~QOffscreenSurface")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_DestroyQOffscreenSurface(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QOffscreenSurface) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QOffscreenSurface::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QOffscreenSurface) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QOffscreenSurface::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQOffscreenSurfaceTimerEvent
func callbackQOffscreenSurfaceTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QOffscreenSurface::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQOffscreenSurfaceFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QOffscreenSurface) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QOffscreenSurface::timerEvent")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QOffscreenSurface) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QOffscreenSurface::timerEvent")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QOffscreenSurface) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QOffscreenSurface::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QOffscreenSurface) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QOffscreenSurface::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQOffscreenSurfaceChildEvent
func callbackQOffscreenSurfaceChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QOffscreenSurface::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQOffscreenSurfaceFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QOffscreenSurface) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QOffscreenSurface::childEvent")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QOffscreenSurface) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QOffscreenSurface::childEvent")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QOffscreenSurface) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QOffscreenSurface::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QOffscreenSurface) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QOffscreenSurface::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQOffscreenSurfaceCustomEvent
func callbackQOffscreenSurfaceCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QOffscreenSurface::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQOffscreenSurfaceFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QOffscreenSurface) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QOffscreenSurface::customEvent")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QOffscreenSurface) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QOffscreenSurface::customEvent")

	if ptr.Pointer() != nil {
		C.QOffscreenSurface_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QOpenGLBuffer struct {
	ptr unsafe.Pointer
}

type QOpenGLBuffer_ITF interface {
	QOpenGLBuffer_PTR() *QOpenGLBuffer
}

func (p *QOpenGLBuffer) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QOpenGLBuffer) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQOpenGLBuffer(ptr QOpenGLBuffer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLBuffer_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLBufferFromPointer(ptr unsafe.Pointer) *QOpenGLBuffer {
	var n = new(QOpenGLBuffer)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLBufferFromPointer(ptr unsafe.Pointer) *QOpenGLBuffer {
	var n = NewQOpenGLBufferFromPointer(ptr)
	return n
}

func (ptr *QOpenGLBuffer) QOpenGLBuffer_PTR() *QOpenGLBuffer {
	return ptr
}

//QOpenGLBuffer::Access
type QOpenGLBuffer__Access int64

const (
	QOpenGLBuffer__ReadOnly  = QOpenGLBuffer__Access(0x88B8)
	QOpenGLBuffer__WriteOnly = QOpenGLBuffer__Access(0x88B9)
	QOpenGLBuffer__ReadWrite = QOpenGLBuffer__Access(0x88BA)
)

//QOpenGLBuffer::RangeAccessFlag
type QOpenGLBuffer__RangeAccessFlag int64

const (
	QOpenGLBuffer__RangeRead             = QOpenGLBuffer__RangeAccessFlag(0x0001)
	QOpenGLBuffer__RangeWrite            = QOpenGLBuffer__RangeAccessFlag(0x0002)
	QOpenGLBuffer__RangeInvalidate       = QOpenGLBuffer__RangeAccessFlag(0x0004)
	QOpenGLBuffer__RangeInvalidateBuffer = QOpenGLBuffer__RangeAccessFlag(0x0008)
	QOpenGLBuffer__RangeFlushExplicit    = QOpenGLBuffer__RangeAccessFlag(0x0010)
	QOpenGLBuffer__RangeUnsynchronized   = QOpenGLBuffer__RangeAccessFlag(0x0020)
)

//QOpenGLBuffer::Type
type QOpenGLBuffer__Type int64

const (
	QOpenGLBuffer__VertexBuffer      = QOpenGLBuffer__Type(0x8892)
	QOpenGLBuffer__IndexBuffer       = QOpenGLBuffer__Type(0x8893)
	QOpenGLBuffer__PixelPackBuffer   = QOpenGLBuffer__Type(0x88EB)
	QOpenGLBuffer__PixelUnpackBuffer = QOpenGLBuffer__Type(0x88EC)
)

//QOpenGLBuffer::UsagePattern
type QOpenGLBuffer__UsagePattern int64

const (
	QOpenGLBuffer__StreamDraw  = QOpenGLBuffer__UsagePattern(0x88E0)
	QOpenGLBuffer__StreamRead  = QOpenGLBuffer__UsagePattern(0x88E1)
	QOpenGLBuffer__StreamCopy  = QOpenGLBuffer__UsagePattern(0x88E2)
	QOpenGLBuffer__StaticDraw  = QOpenGLBuffer__UsagePattern(0x88E4)
	QOpenGLBuffer__StaticRead  = QOpenGLBuffer__UsagePattern(0x88E5)
	QOpenGLBuffer__StaticCopy  = QOpenGLBuffer__UsagePattern(0x88E6)
	QOpenGLBuffer__DynamicDraw = QOpenGLBuffer__UsagePattern(0x88E8)
	QOpenGLBuffer__DynamicRead = QOpenGLBuffer__UsagePattern(0x88E9)
	QOpenGLBuffer__DynamicCopy = QOpenGLBuffer__UsagePattern(0x88EA)
)

type QOpenGLContext struct {
	core.QObject
}

type QOpenGLContext_ITF interface {
	core.QObject_ITF
	QOpenGLContext_PTR() *QOpenGLContext
}

func PointerFromQOpenGLContext(ptr QOpenGLContext_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLContext_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLContextFromPointer(ptr unsafe.Pointer) *QOpenGLContext {
	var n = new(QOpenGLContext)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLContextFromPointer(ptr unsafe.Pointer) *QOpenGLContext {
	var n = NewQOpenGLContextFromPointer(ptr)
	for len(n.ObjectName()) < len("QOpenGLContext_") {
		n.SetObjectName("QOpenGLContext_" + qt.Identifier())
	}
	return n
}

func (ptr *QOpenGLContext) QOpenGLContext_PTR() *QOpenGLContext {
	return ptr
}

//QOpenGLContext::OpenGLModuleType
type QOpenGLContext__OpenGLModuleType int64

const (
	QOpenGLContext__LibGL   = QOpenGLContext__OpenGLModuleType(0)
	QOpenGLContext__LibGLES = QOpenGLContext__OpenGLModuleType(1)
)

type QOpenGLContextGroup struct {
	core.QObject
}

type QOpenGLContextGroup_ITF interface {
	core.QObject_ITF
	QOpenGLContextGroup_PTR() *QOpenGLContextGroup
}

func PointerFromQOpenGLContextGroup(ptr QOpenGLContextGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLContextGroup_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLContextGroupFromPointer(ptr unsafe.Pointer) *QOpenGLContextGroup {
	var n = new(QOpenGLContextGroup)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLContextGroupFromPointer(ptr unsafe.Pointer) *QOpenGLContextGroup {
	var n = NewQOpenGLContextGroupFromPointer(ptr)
	for len(n.ObjectName()) < len("QOpenGLContextGroup_") {
		n.SetObjectName("QOpenGLContextGroup_" + qt.Identifier())
	}
	return n
}

func (ptr *QOpenGLContextGroup) QOpenGLContextGroup_PTR() *QOpenGLContextGroup {
	return ptr
}

type QOpenGLDebugLogger struct {
	core.QObject
}

type QOpenGLDebugLogger_ITF interface {
	core.QObject_ITF
	QOpenGLDebugLogger_PTR() *QOpenGLDebugLogger
}

func PointerFromQOpenGLDebugLogger(ptr QOpenGLDebugLogger_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLDebugLogger_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLDebugLoggerFromPointer(ptr unsafe.Pointer) *QOpenGLDebugLogger {
	var n = new(QOpenGLDebugLogger)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLDebugLoggerFromPointer(ptr unsafe.Pointer) *QOpenGLDebugLogger {
	var n = NewQOpenGLDebugLoggerFromPointer(ptr)
	for len(n.ObjectName()) < len("QOpenGLDebugLogger_") {
		n.SetObjectName("QOpenGLDebugLogger_" + qt.Identifier())
	}
	return n
}

func (ptr *QOpenGLDebugLogger) QOpenGLDebugLogger_PTR() *QOpenGLDebugLogger {
	return ptr
}

//QOpenGLDebugLogger::LoggingMode
type QOpenGLDebugLogger__LoggingMode int64

const (
	QOpenGLDebugLogger__AsynchronousLogging = QOpenGLDebugLogger__LoggingMode(0)
	QOpenGLDebugLogger__SynchronousLogging  = QOpenGLDebugLogger__LoggingMode(1)
)

type QOpenGLDebugMessage struct {
	ptr unsafe.Pointer
}

type QOpenGLDebugMessage_ITF interface {
	QOpenGLDebugMessage_PTR() *QOpenGLDebugMessage
}

func (p *QOpenGLDebugMessage) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QOpenGLDebugMessage) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQOpenGLDebugMessage(ptr QOpenGLDebugMessage_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLDebugMessage_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLDebugMessageFromPointer(ptr unsafe.Pointer) *QOpenGLDebugMessage {
	var n = new(QOpenGLDebugMessage)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLDebugMessageFromPointer(ptr unsafe.Pointer) *QOpenGLDebugMessage {
	var n = NewQOpenGLDebugMessageFromPointer(ptr)
	return n
}

func (ptr *QOpenGLDebugMessage) QOpenGLDebugMessage_PTR() *QOpenGLDebugMessage {
	return ptr
}

//QOpenGLDebugMessage::Severity
type QOpenGLDebugMessage__Severity int64

const (
	QOpenGLDebugMessage__InvalidSeverity      = QOpenGLDebugMessage__Severity(0x00000000)
	QOpenGLDebugMessage__HighSeverity         = QOpenGLDebugMessage__Severity(0x00000001)
	QOpenGLDebugMessage__MediumSeverity       = QOpenGLDebugMessage__Severity(0x00000002)
	QOpenGLDebugMessage__LowSeverity          = QOpenGLDebugMessage__Severity(0x00000004)
	QOpenGLDebugMessage__NotificationSeverity = QOpenGLDebugMessage__Severity(0x00000008)
	QOpenGLDebugMessage__LastSeverity         = QOpenGLDebugMessage__Severity(QOpenGLDebugMessage__NotificationSeverity)
	QOpenGLDebugMessage__AnySeverity          = QOpenGLDebugMessage__Severity(0xffffffff)
)

//QOpenGLDebugMessage::Source
type QOpenGLDebugMessage__Source int64

const (
	QOpenGLDebugMessage__InvalidSource        = QOpenGLDebugMessage__Source(0x00000000)
	QOpenGLDebugMessage__APISource            = QOpenGLDebugMessage__Source(0x00000001)
	QOpenGLDebugMessage__WindowSystemSource   = QOpenGLDebugMessage__Source(0x00000002)
	QOpenGLDebugMessage__ShaderCompilerSource = QOpenGLDebugMessage__Source(0x00000004)
	QOpenGLDebugMessage__ThirdPartySource     = QOpenGLDebugMessage__Source(0x00000008)
	QOpenGLDebugMessage__ApplicationSource    = QOpenGLDebugMessage__Source(0x00000010)
	QOpenGLDebugMessage__OtherSource          = QOpenGLDebugMessage__Source(0x00000020)
	QOpenGLDebugMessage__LastSource           = QOpenGLDebugMessage__Source(QOpenGLDebugMessage__OtherSource)
	QOpenGLDebugMessage__AnySource            = QOpenGLDebugMessage__Source(0xffffffff)
)

//QOpenGLDebugMessage::Type
type QOpenGLDebugMessage__Type int64

const (
	QOpenGLDebugMessage__InvalidType            = QOpenGLDebugMessage__Type(0x00000000)
	QOpenGLDebugMessage__ErrorType              = QOpenGLDebugMessage__Type(0x00000001)
	QOpenGLDebugMessage__DeprecatedBehaviorType = QOpenGLDebugMessage__Type(0x00000002)
	QOpenGLDebugMessage__UndefinedBehaviorType  = QOpenGLDebugMessage__Type(0x00000004)
	QOpenGLDebugMessage__PortabilityType        = QOpenGLDebugMessage__Type(0x00000008)
	QOpenGLDebugMessage__PerformanceType        = QOpenGLDebugMessage__Type(0x00000010)
	QOpenGLDebugMessage__OtherType              = QOpenGLDebugMessage__Type(0x00000020)
	QOpenGLDebugMessage__MarkerType             = QOpenGLDebugMessage__Type(0x00000040)
	QOpenGLDebugMessage__GroupPushType          = QOpenGLDebugMessage__Type(0x00000080)
	QOpenGLDebugMessage__GroupPopType           = QOpenGLDebugMessage__Type(0x00000100)
	QOpenGLDebugMessage__LastType               = QOpenGLDebugMessage__Type(QOpenGLDebugMessage__GroupPopType)
	QOpenGLDebugMessage__AnyType                = QOpenGLDebugMessage__Type(0xffffffff)
)

type QOpenGLFramebufferObject struct {
	ptr unsafe.Pointer
}

type QOpenGLFramebufferObject_ITF interface {
	QOpenGLFramebufferObject_PTR() *QOpenGLFramebufferObject
}

func (p *QOpenGLFramebufferObject) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QOpenGLFramebufferObject) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQOpenGLFramebufferObject(ptr QOpenGLFramebufferObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFramebufferObject_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFramebufferObjectFromPointer(ptr unsafe.Pointer) *QOpenGLFramebufferObject {
	var n = new(QOpenGLFramebufferObject)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFramebufferObjectFromPointer(ptr unsafe.Pointer) *QOpenGLFramebufferObject {
	var n = NewQOpenGLFramebufferObjectFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFramebufferObject) QOpenGLFramebufferObject_PTR() *QOpenGLFramebufferObject {
	return ptr
}

//QOpenGLFramebufferObject::Attachment
type QOpenGLFramebufferObject__Attachment int64

const (
	QOpenGLFramebufferObject__NoAttachment         = QOpenGLFramebufferObject__Attachment(0)
	QOpenGLFramebufferObject__CombinedDepthStencil = QOpenGLFramebufferObject__Attachment(1)
	QOpenGLFramebufferObject__Depth                = QOpenGLFramebufferObject__Attachment(2)
)

type QOpenGLFramebufferObjectFormat struct {
	ptr unsafe.Pointer
}

type QOpenGLFramebufferObjectFormat_ITF interface {
	QOpenGLFramebufferObjectFormat_PTR() *QOpenGLFramebufferObjectFormat
}

func (p *QOpenGLFramebufferObjectFormat) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QOpenGLFramebufferObjectFormat) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQOpenGLFramebufferObjectFormat(ptr QOpenGLFramebufferObjectFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFramebufferObjectFormat_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFramebufferObjectFormatFromPointer(ptr unsafe.Pointer) *QOpenGLFramebufferObjectFormat {
	var n = new(QOpenGLFramebufferObjectFormat)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFramebufferObjectFormatFromPointer(ptr unsafe.Pointer) *QOpenGLFramebufferObjectFormat {
	var n = NewQOpenGLFramebufferObjectFormatFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFramebufferObjectFormat) QOpenGLFramebufferObjectFormat_PTR() *QOpenGLFramebufferObjectFormat {
	return ptr
}

type QOpenGLFunctions struct {
	ptr unsafe.Pointer
}

type QOpenGLFunctions_ITF interface {
	QOpenGLFunctions_PTR() *QOpenGLFunctions
}

func (p *QOpenGLFunctions) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QOpenGLFunctions) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQOpenGLFunctions(ptr QOpenGLFunctions_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctionsFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions {
	var n = new(QOpenGLFunctions)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctionsFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions {
	var n = NewQOpenGLFunctionsFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions) QOpenGLFunctions_PTR() *QOpenGLFunctions {
	return ptr
}

//QOpenGLFunctions::OpenGLFeature
type QOpenGLFunctions__OpenGLFeature int64

const (
	QOpenGLFunctions__Multitexture          = QOpenGLFunctions__OpenGLFeature(0x0001)
	QOpenGLFunctions__Shaders               = QOpenGLFunctions__OpenGLFeature(0x0002)
	QOpenGLFunctions__Buffers               = QOpenGLFunctions__OpenGLFeature(0x0004)
	QOpenGLFunctions__Framebuffers          = QOpenGLFunctions__OpenGLFeature(0x0008)
	QOpenGLFunctions__BlendColor            = QOpenGLFunctions__OpenGLFeature(0x0010)
	QOpenGLFunctions__BlendEquation         = QOpenGLFunctions__OpenGLFeature(0x0020)
	QOpenGLFunctions__BlendEquationSeparate = QOpenGLFunctions__OpenGLFeature(0x0040)
	QOpenGLFunctions__BlendFuncSeparate     = QOpenGLFunctions__OpenGLFeature(0x0080)
	QOpenGLFunctions__BlendSubtract         = QOpenGLFunctions__OpenGLFeature(0x0100)
	QOpenGLFunctions__CompressedTextures    = QOpenGLFunctions__OpenGLFeature(0x0200)
	QOpenGLFunctions__Multisample           = QOpenGLFunctions__OpenGLFeature(0x0400)
	QOpenGLFunctions__StencilSeparate       = QOpenGLFunctions__OpenGLFeature(0x0800)
	QOpenGLFunctions__NPOTTextures          = QOpenGLFunctions__OpenGLFeature(0x1000)
	QOpenGLFunctions__NPOTTextureRepeat     = QOpenGLFunctions__OpenGLFeature(0x2000)
	QOpenGLFunctions__FixedFunctionPipeline = QOpenGLFunctions__OpenGLFeature(0x4000)
	QOpenGLFunctions__TextureRGFormats      = QOpenGLFunctions__OpenGLFeature(0x8000)
)

type QOpenGLFunctions_1_0 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_1_0_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_1_0_PTR() *QOpenGLFunctions_1_0
}

func PointerFromQOpenGLFunctions_1_0(ptr QOpenGLFunctions_1_0_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_1_0_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_1_0FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_0 {
	var n = new(QOpenGLFunctions_1_0)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_1_0FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_0 {
	var n = NewQOpenGLFunctions_1_0FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_1_0) QOpenGLFunctions_1_0_PTR() *QOpenGLFunctions_1_0 {
	return ptr
}

type QOpenGLFunctions_1_1 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_1_1_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_1_1_PTR() *QOpenGLFunctions_1_1
}

func PointerFromQOpenGLFunctions_1_1(ptr QOpenGLFunctions_1_1_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_1_1_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_1_1FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_1 {
	var n = new(QOpenGLFunctions_1_1)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_1_1FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_1 {
	var n = NewQOpenGLFunctions_1_1FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_1_1) QOpenGLFunctions_1_1_PTR() *QOpenGLFunctions_1_1 {
	return ptr
}

type QOpenGLFunctions_1_2 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_1_2_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_1_2_PTR() *QOpenGLFunctions_1_2
}

func PointerFromQOpenGLFunctions_1_2(ptr QOpenGLFunctions_1_2_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_1_2_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_1_2FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_2 {
	var n = new(QOpenGLFunctions_1_2)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_1_2FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_2 {
	var n = NewQOpenGLFunctions_1_2FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_1_2) QOpenGLFunctions_1_2_PTR() *QOpenGLFunctions_1_2 {
	return ptr
}

type QOpenGLFunctions_1_3 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_1_3_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_1_3_PTR() *QOpenGLFunctions_1_3
}

func PointerFromQOpenGLFunctions_1_3(ptr QOpenGLFunctions_1_3_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_1_3_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_1_3FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_3 {
	var n = new(QOpenGLFunctions_1_3)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_1_3FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_3 {
	var n = NewQOpenGLFunctions_1_3FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_1_3) QOpenGLFunctions_1_3_PTR() *QOpenGLFunctions_1_3 {
	return ptr
}

type QOpenGLFunctions_1_4 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_1_4_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_1_4_PTR() *QOpenGLFunctions_1_4
}

func PointerFromQOpenGLFunctions_1_4(ptr QOpenGLFunctions_1_4_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_1_4_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_1_4FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_4 {
	var n = new(QOpenGLFunctions_1_4)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_1_4FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_4 {
	var n = NewQOpenGLFunctions_1_4FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_1_4) QOpenGLFunctions_1_4_PTR() *QOpenGLFunctions_1_4 {
	return ptr
}

type QOpenGLFunctions_1_5 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_1_5_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_1_5_PTR() *QOpenGLFunctions_1_5
}

func PointerFromQOpenGLFunctions_1_5(ptr QOpenGLFunctions_1_5_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_1_5_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_1_5FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_5 {
	var n = new(QOpenGLFunctions_1_5)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_1_5FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_1_5 {
	var n = NewQOpenGLFunctions_1_5FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_1_5) QOpenGLFunctions_1_5_PTR() *QOpenGLFunctions_1_5 {
	return ptr
}

type QOpenGLFunctions_2_0 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_2_0_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_2_0_PTR() *QOpenGLFunctions_2_0
}

func PointerFromQOpenGLFunctions_2_0(ptr QOpenGLFunctions_2_0_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_2_0_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_2_0FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_2_0 {
	var n = new(QOpenGLFunctions_2_0)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_2_0FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_2_0 {
	var n = NewQOpenGLFunctions_2_0FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_2_0) QOpenGLFunctions_2_0_PTR() *QOpenGLFunctions_2_0 {
	return ptr
}

type QOpenGLFunctions_2_1 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_2_1_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_2_1_PTR() *QOpenGLFunctions_2_1
}

func PointerFromQOpenGLFunctions_2_1(ptr QOpenGLFunctions_2_1_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_2_1_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_2_1FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_2_1 {
	var n = new(QOpenGLFunctions_2_1)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_2_1FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_2_1 {
	var n = NewQOpenGLFunctions_2_1FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_2_1) QOpenGLFunctions_2_1_PTR() *QOpenGLFunctions_2_1 {
	return ptr
}

type QOpenGLFunctions_3_0 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_3_0_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_3_0_PTR() *QOpenGLFunctions_3_0
}

func PointerFromQOpenGLFunctions_3_0(ptr QOpenGLFunctions_3_0_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_3_0_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_3_0FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_0 {
	var n = new(QOpenGLFunctions_3_0)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_3_0FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_0 {
	var n = NewQOpenGLFunctions_3_0FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_3_0) QOpenGLFunctions_3_0_PTR() *QOpenGLFunctions_3_0 {
	return ptr
}

type QOpenGLFunctions_3_1 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_3_1_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_3_1_PTR() *QOpenGLFunctions_3_1
}

func PointerFromQOpenGLFunctions_3_1(ptr QOpenGLFunctions_3_1_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_3_1_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_3_1FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_1 {
	var n = new(QOpenGLFunctions_3_1)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_3_1FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_1 {
	var n = NewQOpenGLFunctions_3_1FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_3_1) QOpenGLFunctions_3_1_PTR() *QOpenGLFunctions_3_1 {
	return ptr
}

type QOpenGLFunctions_3_2_Compatibility struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_3_2_Compatibility_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_3_2_Compatibility_PTR() *QOpenGLFunctions_3_2_Compatibility
}

func PointerFromQOpenGLFunctions_3_2_Compatibility(ptr QOpenGLFunctions_3_2_Compatibility_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_3_2_Compatibility_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_3_2_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_2_Compatibility {
	var n = new(QOpenGLFunctions_3_2_Compatibility)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_3_2_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_2_Compatibility {
	var n = NewQOpenGLFunctions_3_2_CompatibilityFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_3_2_Compatibility) QOpenGLFunctions_3_2_Compatibility_PTR() *QOpenGLFunctions_3_2_Compatibility {
	return ptr
}

type QOpenGLFunctions_3_2_Core struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_3_2_Core_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_3_2_Core_PTR() *QOpenGLFunctions_3_2_Core
}

func PointerFromQOpenGLFunctions_3_2_Core(ptr QOpenGLFunctions_3_2_Core_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_3_2_Core_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_3_2_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_2_Core {
	var n = new(QOpenGLFunctions_3_2_Core)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_3_2_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_2_Core {
	var n = NewQOpenGLFunctions_3_2_CoreFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_3_2_Core) QOpenGLFunctions_3_2_Core_PTR() *QOpenGLFunctions_3_2_Core {
	return ptr
}

type QOpenGLFunctions_3_3_Compatibility struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_3_3_Compatibility_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_3_3_Compatibility_PTR() *QOpenGLFunctions_3_3_Compatibility
}

func PointerFromQOpenGLFunctions_3_3_Compatibility(ptr QOpenGLFunctions_3_3_Compatibility_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_3_3_Compatibility_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_3_3_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_3_Compatibility {
	var n = new(QOpenGLFunctions_3_3_Compatibility)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_3_3_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_3_Compatibility {
	var n = NewQOpenGLFunctions_3_3_CompatibilityFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_3_3_Compatibility) QOpenGLFunctions_3_3_Compatibility_PTR() *QOpenGLFunctions_3_3_Compatibility {
	return ptr
}

type QOpenGLFunctions_3_3_Core struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_3_3_Core_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_3_3_Core_PTR() *QOpenGLFunctions_3_3_Core
}

func PointerFromQOpenGLFunctions_3_3_Core(ptr QOpenGLFunctions_3_3_Core_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_3_3_Core_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_3_3_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_3_Core {
	var n = new(QOpenGLFunctions_3_3_Core)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_3_3_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_3_3_Core {
	var n = NewQOpenGLFunctions_3_3_CoreFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_3_3_Core) QOpenGLFunctions_3_3_Core_PTR() *QOpenGLFunctions_3_3_Core {
	return ptr
}

type QOpenGLFunctions_4_0_Compatibility struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_0_Compatibility_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_0_Compatibility_PTR() *QOpenGLFunctions_4_0_Compatibility
}

func PointerFromQOpenGLFunctions_4_0_Compatibility(ptr QOpenGLFunctions_4_0_Compatibility_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_0_Compatibility_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_0_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_0_Compatibility {
	var n = new(QOpenGLFunctions_4_0_Compatibility)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_0_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_0_Compatibility {
	var n = NewQOpenGLFunctions_4_0_CompatibilityFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_0_Compatibility) QOpenGLFunctions_4_0_Compatibility_PTR() *QOpenGLFunctions_4_0_Compatibility {
	return ptr
}

type QOpenGLFunctions_4_0_Core struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_0_Core_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_0_Core_PTR() *QOpenGLFunctions_4_0_Core
}

func PointerFromQOpenGLFunctions_4_0_Core(ptr QOpenGLFunctions_4_0_Core_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_0_Core_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_0_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_0_Core {
	var n = new(QOpenGLFunctions_4_0_Core)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_0_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_0_Core {
	var n = NewQOpenGLFunctions_4_0_CoreFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_0_Core) QOpenGLFunctions_4_0_Core_PTR() *QOpenGLFunctions_4_0_Core {
	return ptr
}

type QOpenGLFunctions_4_1_Compatibility struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_1_Compatibility_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_1_Compatibility_PTR() *QOpenGLFunctions_4_1_Compatibility
}

func PointerFromQOpenGLFunctions_4_1_Compatibility(ptr QOpenGLFunctions_4_1_Compatibility_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_1_Compatibility_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_1_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_1_Compatibility {
	var n = new(QOpenGLFunctions_4_1_Compatibility)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_1_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_1_Compatibility {
	var n = NewQOpenGLFunctions_4_1_CompatibilityFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_1_Compatibility) QOpenGLFunctions_4_1_Compatibility_PTR() *QOpenGLFunctions_4_1_Compatibility {
	return ptr
}

type QOpenGLFunctions_4_1_Core struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_1_Core_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_1_Core_PTR() *QOpenGLFunctions_4_1_Core
}

func PointerFromQOpenGLFunctions_4_1_Core(ptr QOpenGLFunctions_4_1_Core_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_1_Core_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_1_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_1_Core {
	var n = new(QOpenGLFunctions_4_1_Core)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_1_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_1_Core {
	var n = NewQOpenGLFunctions_4_1_CoreFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_1_Core) QOpenGLFunctions_4_1_Core_PTR() *QOpenGLFunctions_4_1_Core {
	return ptr
}

type QOpenGLFunctions_4_2_Compatibility struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_2_Compatibility_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_2_Compatibility_PTR() *QOpenGLFunctions_4_2_Compatibility
}

func PointerFromQOpenGLFunctions_4_2_Compatibility(ptr QOpenGLFunctions_4_2_Compatibility_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_2_Compatibility_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_2_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_2_Compatibility {
	var n = new(QOpenGLFunctions_4_2_Compatibility)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_2_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_2_Compatibility {
	var n = NewQOpenGLFunctions_4_2_CompatibilityFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_2_Compatibility) QOpenGLFunctions_4_2_Compatibility_PTR() *QOpenGLFunctions_4_2_Compatibility {
	return ptr
}

type QOpenGLFunctions_4_2_Core struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_2_Core_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_2_Core_PTR() *QOpenGLFunctions_4_2_Core
}

func PointerFromQOpenGLFunctions_4_2_Core(ptr QOpenGLFunctions_4_2_Core_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_2_Core_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_2_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_2_Core {
	var n = new(QOpenGLFunctions_4_2_Core)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_2_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_2_Core {
	var n = NewQOpenGLFunctions_4_2_CoreFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_2_Core) QOpenGLFunctions_4_2_Core_PTR() *QOpenGLFunctions_4_2_Core {
	return ptr
}

type QOpenGLFunctions_4_3_Compatibility struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_3_Compatibility_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_3_Compatibility_PTR() *QOpenGLFunctions_4_3_Compatibility
}

func PointerFromQOpenGLFunctions_4_3_Compatibility(ptr QOpenGLFunctions_4_3_Compatibility_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_3_Compatibility_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_3_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_3_Compatibility {
	var n = new(QOpenGLFunctions_4_3_Compatibility)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_3_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_3_Compatibility {
	var n = NewQOpenGLFunctions_4_3_CompatibilityFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_3_Compatibility) QOpenGLFunctions_4_3_Compatibility_PTR() *QOpenGLFunctions_4_3_Compatibility {
	return ptr
}

type QOpenGLFunctions_4_3_Core struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_3_Core_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_3_Core_PTR() *QOpenGLFunctions_4_3_Core
}

func PointerFromQOpenGLFunctions_4_3_Core(ptr QOpenGLFunctions_4_3_Core_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_3_Core_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_3_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_3_Core {
	var n = new(QOpenGLFunctions_4_3_Core)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_3_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_3_Core {
	var n = NewQOpenGLFunctions_4_3_CoreFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_3_Core) QOpenGLFunctions_4_3_Core_PTR() *QOpenGLFunctions_4_3_Core {
	return ptr
}

type QOpenGLFunctions_4_4_Compatibility struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_4_Compatibility_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_4_Compatibility_PTR() *QOpenGLFunctions_4_4_Compatibility
}

func PointerFromQOpenGLFunctions_4_4_Compatibility(ptr QOpenGLFunctions_4_4_Compatibility_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_4_Compatibility_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_4_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_4_Compatibility {
	var n = new(QOpenGLFunctions_4_4_Compatibility)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_4_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_4_Compatibility {
	var n = NewQOpenGLFunctions_4_4_CompatibilityFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_4_Compatibility) QOpenGLFunctions_4_4_Compatibility_PTR() *QOpenGLFunctions_4_4_Compatibility {
	return ptr
}

type QOpenGLFunctions_4_4_Core struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_4_Core_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_4_Core_PTR() *QOpenGLFunctions_4_4_Core
}

func PointerFromQOpenGLFunctions_4_4_Core(ptr QOpenGLFunctions_4_4_Core_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_4_Core_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_4_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_4_Core {
	var n = new(QOpenGLFunctions_4_4_Core)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_4_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_4_Core {
	var n = NewQOpenGLFunctions_4_4_CoreFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_4_Core) QOpenGLFunctions_4_4_Core_PTR() *QOpenGLFunctions_4_4_Core {
	return ptr
}

type QOpenGLFunctions_4_5_Compatibility struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_5_Compatibility_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_5_Compatibility_PTR() *QOpenGLFunctions_4_5_Compatibility
}

func PointerFromQOpenGLFunctions_4_5_Compatibility(ptr QOpenGLFunctions_4_5_Compatibility_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_5_Compatibility_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_5_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_5_Compatibility {
	var n = new(QOpenGLFunctions_4_5_Compatibility)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_5_CompatibilityFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_5_Compatibility {
	var n = NewQOpenGLFunctions_4_5_CompatibilityFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_5_Compatibility) QOpenGLFunctions_4_5_Compatibility_PTR() *QOpenGLFunctions_4_5_Compatibility {
	return ptr
}

type QOpenGLFunctions_4_5_Core struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_4_5_Core_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_4_5_Core_PTR() *QOpenGLFunctions_4_5_Core
}

func PointerFromQOpenGLFunctions_4_5_Core(ptr QOpenGLFunctions_4_5_Core_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_4_5_Core_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_4_5_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_5_Core {
	var n = new(QOpenGLFunctions_4_5_Core)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_4_5_CoreFromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_4_5_Core {
	var n = NewQOpenGLFunctions_4_5_CoreFromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_4_5_Core) QOpenGLFunctions_4_5_Core_PTR() *QOpenGLFunctions_4_5_Core {
	return ptr
}

type QOpenGLFunctions_ES2 struct {
	QAbstractOpenGLFunctions
}

type QOpenGLFunctions_ES2_ITF interface {
	QAbstractOpenGLFunctions_ITF
	QOpenGLFunctions_ES2_PTR() *QOpenGLFunctions_ES2
}

func PointerFromQOpenGLFunctions_ES2(ptr QOpenGLFunctions_ES2_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLFunctions_ES2_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLFunctions_ES2FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_ES2 {
	var n = new(QOpenGLFunctions_ES2)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLFunctions_ES2FromPointer(ptr unsafe.Pointer) *QOpenGLFunctions_ES2 {
	var n = NewQOpenGLFunctions_ES2FromPointer(ptr)
	return n
}

func (ptr *QOpenGLFunctions_ES2) QOpenGLFunctions_ES2_PTR() *QOpenGLFunctions_ES2 {
	return ptr
}

type QOpenGLPaintDevice struct {
	QPaintDevice
}

type QOpenGLPaintDevice_ITF interface {
	QPaintDevice_ITF
	QOpenGLPaintDevice_PTR() *QOpenGLPaintDevice
}

func PointerFromQOpenGLPaintDevice(ptr QOpenGLPaintDevice_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLPaintDevice_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLPaintDeviceFromPointer(ptr unsafe.Pointer) *QOpenGLPaintDevice {
	var n = new(QOpenGLPaintDevice)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLPaintDeviceFromPointer(ptr unsafe.Pointer) *QOpenGLPaintDevice {
	var n = NewQOpenGLPaintDeviceFromPointer(ptr)
	return n
}

func (ptr *QOpenGLPaintDevice) QOpenGLPaintDevice_PTR() *QOpenGLPaintDevice {
	return ptr
}

type QOpenGLPixelTransferOptions struct {
	ptr unsafe.Pointer
}

type QOpenGLPixelTransferOptions_ITF interface {
	QOpenGLPixelTransferOptions_PTR() *QOpenGLPixelTransferOptions
}

func (p *QOpenGLPixelTransferOptions) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QOpenGLPixelTransferOptions) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQOpenGLPixelTransferOptions(ptr QOpenGLPixelTransferOptions_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLPixelTransferOptions_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLPixelTransferOptionsFromPointer(ptr unsafe.Pointer) *QOpenGLPixelTransferOptions {
	var n = new(QOpenGLPixelTransferOptions)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLPixelTransferOptionsFromPointer(ptr unsafe.Pointer) *QOpenGLPixelTransferOptions {
	var n = NewQOpenGLPixelTransferOptionsFromPointer(ptr)
	return n
}

func (ptr *QOpenGLPixelTransferOptions) QOpenGLPixelTransferOptions_PTR() *QOpenGLPixelTransferOptions {
	return ptr
}

type QOpenGLShader struct {
	core.QObject
}

type QOpenGLShader_ITF interface {
	core.QObject_ITF
	QOpenGLShader_PTR() *QOpenGLShader
}

func PointerFromQOpenGLShader(ptr QOpenGLShader_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLShader_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLShaderFromPointer(ptr unsafe.Pointer) *QOpenGLShader {
	var n = new(QOpenGLShader)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLShaderFromPointer(ptr unsafe.Pointer) *QOpenGLShader {
	var n = NewQOpenGLShaderFromPointer(ptr)
	for len(n.ObjectName()) < len("QOpenGLShader_") {
		n.SetObjectName("QOpenGLShader_" + qt.Identifier())
	}
	return n
}

func (ptr *QOpenGLShader) QOpenGLShader_PTR() *QOpenGLShader {
	return ptr
}

//QOpenGLShader::ShaderTypeBit
type QOpenGLShader__ShaderTypeBit int64

const (
	QOpenGLShader__Vertex                 = QOpenGLShader__ShaderTypeBit(0x0001)
	QOpenGLShader__Fragment               = QOpenGLShader__ShaderTypeBit(0x0002)
	QOpenGLShader__Geometry               = QOpenGLShader__ShaderTypeBit(0x0004)
	QOpenGLShader__TessellationControl    = QOpenGLShader__ShaderTypeBit(0x0008)
	QOpenGLShader__TessellationEvaluation = QOpenGLShader__ShaderTypeBit(0x0010)
	QOpenGLShader__Compute                = QOpenGLShader__ShaderTypeBit(0x0020)
)

type QOpenGLShaderProgram struct {
	core.QObject
}

type QOpenGLShaderProgram_ITF interface {
	core.QObject_ITF
	QOpenGLShaderProgram_PTR() *QOpenGLShaderProgram
}

func PointerFromQOpenGLShaderProgram(ptr QOpenGLShaderProgram_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLShaderProgram_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLShaderProgramFromPointer(ptr unsafe.Pointer) *QOpenGLShaderProgram {
	var n = new(QOpenGLShaderProgram)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLShaderProgramFromPointer(ptr unsafe.Pointer) *QOpenGLShaderProgram {
	var n = NewQOpenGLShaderProgramFromPointer(ptr)
	for len(n.ObjectName()) < len("QOpenGLShaderProgram_") {
		n.SetObjectName("QOpenGLShaderProgram_" + qt.Identifier())
	}
	return n
}

func (ptr *QOpenGLShaderProgram) QOpenGLShaderProgram_PTR() *QOpenGLShaderProgram {
	return ptr
}

type QOpenGLTexture struct {
	ptr unsafe.Pointer
}

type QOpenGLTexture_ITF interface {
	QOpenGLTexture_PTR() *QOpenGLTexture
}

func (p *QOpenGLTexture) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QOpenGLTexture) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQOpenGLTexture(ptr QOpenGLTexture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLTexture_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLTextureFromPointer(ptr unsafe.Pointer) *QOpenGLTexture {
	var n = new(QOpenGLTexture)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLTextureFromPointer(ptr unsafe.Pointer) *QOpenGLTexture {
	var n = NewQOpenGLTextureFromPointer(ptr)
	return n
}

func (ptr *QOpenGLTexture) QOpenGLTexture_PTR() *QOpenGLTexture {
	return ptr
}

//QOpenGLTexture::BindingTarget
type QOpenGLTexture__BindingTarget int64

const (
	QOpenGLTexture__BindingTarget1D                 = QOpenGLTexture__BindingTarget(0x8068)
	QOpenGLTexture__BindingTarget1DArray            = QOpenGLTexture__BindingTarget(0x8C1C)
	QOpenGLTexture__BindingTarget2D                 = QOpenGLTexture__BindingTarget(0x8069)
	QOpenGLTexture__BindingTarget2DArray            = QOpenGLTexture__BindingTarget(0x8C1D)
	QOpenGLTexture__BindingTarget3D                 = QOpenGLTexture__BindingTarget(0x806A)
	QOpenGLTexture__BindingTargetCubeMap            = QOpenGLTexture__BindingTarget(0x8514)
	QOpenGLTexture__BindingTargetCubeMapArray       = QOpenGLTexture__BindingTarget(0x900A)
	QOpenGLTexture__BindingTarget2DMultisample      = QOpenGLTexture__BindingTarget(0x9104)
	QOpenGLTexture__BindingTarget2DMultisampleArray = QOpenGLTexture__BindingTarget(0x9105)
	QOpenGLTexture__BindingTargetRectangle          = QOpenGLTexture__BindingTarget(0x84F6)
	QOpenGLTexture__BindingTargetBuffer             = QOpenGLTexture__BindingTarget(0x8C2C)
)

//QOpenGLTexture::ComparisonFunction
type QOpenGLTexture__ComparisonFunction int64

const (
	QOpenGLTexture__CompareLessEqual    = QOpenGLTexture__ComparisonFunction(0x0203)
	QOpenGLTexture__CompareGreaterEqual = QOpenGLTexture__ComparisonFunction(0x0206)
	QOpenGLTexture__CompareLess         = QOpenGLTexture__ComparisonFunction(0x0201)
	QOpenGLTexture__CompareGreater      = QOpenGLTexture__ComparisonFunction(0x0204)
	QOpenGLTexture__CompareEqual        = QOpenGLTexture__ComparisonFunction(0x0202)
	QOpenGLTexture__CommpareNotEqual    = QOpenGLTexture__ComparisonFunction(0x0205)
	QOpenGLTexture__CompareAlways       = QOpenGLTexture__ComparisonFunction(0x0207)
	QOpenGLTexture__CompareNever        = QOpenGLTexture__ComparisonFunction(0x0200)
)

//QOpenGLTexture::ComparisonMode
type QOpenGLTexture__ComparisonMode int64

const (
	QOpenGLTexture__CompareRefToTexture = QOpenGLTexture__ComparisonMode(0x884E)
	QOpenGLTexture__CompareNone         = QOpenGLTexture__ComparisonMode(0x0000)
)

//QOpenGLTexture::CoordinateDirection
type QOpenGLTexture__CoordinateDirection int64

const (
	QOpenGLTexture__DirectionS = QOpenGLTexture__CoordinateDirection(0x2802)
	QOpenGLTexture__DirectionT = QOpenGLTexture__CoordinateDirection(0x2803)
	QOpenGLTexture__DirectionR = QOpenGLTexture__CoordinateDirection(0x8072)
)

//QOpenGLTexture::CubeMapFace
type QOpenGLTexture__CubeMapFace int64

const (
	QOpenGLTexture__CubeMapPositiveX = QOpenGLTexture__CubeMapFace(0x8515)
	QOpenGLTexture__CubeMapNegativeX = QOpenGLTexture__CubeMapFace(0x8516)
	QOpenGLTexture__CubeMapPositiveY = QOpenGLTexture__CubeMapFace(0x8517)
	QOpenGLTexture__CubeMapNegativeY = QOpenGLTexture__CubeMapFace(0x8518)
	QOpenGLTexture__CubeMapPositiveZ = QOpenGLTexture__CubeMapFace(0x8519)
	QOpenGLTexture__CubeMapNegativeZ = QOpenGLTexture__CubeMapFace(0x851A)
)

//QOpenGLTexture::DepthStencilMode
type QOpenGLTexture__DepthStencilMode int64

const (
	QOpenGLTexture__DepthMode   = QOpenGLTexture__DepthStencilMode(0x1902)
	QOpenGLTexture__StencilMode = QOpenGLTexture__DepthStencilMode(0x1901)
)

//QOpenGLTexture::Feature
type QOpenGLTexture__Feature int64

const (
	QOpenGLTexture__ImmutableStorage            = QOpenGLTexture__Feature(0x00000001)
	QOpenGLTexture__ImmutableMultisampleStorage = QOpenGLTexture__Feature(0x00000002)
	QOpenGLTexture__TextureRectangle            = QOpenGLTexture__Feature(0x00000004)
	QOpenGLTexture__TextureArrays               = QOpenGLTexture__Feature(0x00000008)
	QOpenGLTexture__Texture3D                   = QOpenGLTexture__Feature(0x00000010)
	QOpenGLTexture__TextureMultisample          = QOpenGLTexture__Feature(0x00000020)
	QOpenGLTexture__TextureBuffer               = QOpenGLTexture__Feature(0x00000040)
	QOpenGLTexture__TextureCubeMapArrays        = QOpenGLTexture__Feature(0x00000080)
	QOpenGLTexture__Swizzle                     = QOpenGLTexture__Feature(0x00000100)
	QOpenGLTexture__StencilTexturing            = QOpenGLTexture__Feature(0x00000200)
	QOpenGLTexture__AnisotropicFiltering        = QOpenGLTexture__Feature(0x00000400)
	QOpenGLTexture__NPOTTextures                = QOpenGLTexture__Feature(0x00000800)
	QOpenGLTexture__NPOTTextureRepeat           = QOpenGLTexture__Feature(0x00001000)
	QOpenGLTexture__Texture1D                   = QOpenGLTexture__Feature(0x00002000)
	QOpenGLTexture__TextureComparisonOperators  = QOpenGLTexture__Feature(0x00004000)
	QOpenGLTexture__TextureMipMapLevel          = QOpenGLTexture__Feature(0x00008000)
)

//QOpenGLTexture::Filter
type QOpenGLTexture__Filter int64

const (
	QOpenGLTexture__Nearest              = QOpenGLTexture__Filter(0x2600)
	QOpenGLTexture__Linear               = QOpenGLTexture__Filter(0x2601)
	QOpenGLTexture__NearestMipMapNearest = QOpenGLTexture__Filter(0x2700)
	QOpenGLTexture__NearestMipMapLinear  = QOpenGLTexture__Filter(0x2702)
	QOpenGLTexture__LinearMipMapNearest  = QOpenGLTexture__Filter(0x2701)
	QOpenGLTexture__LinearMipMapLinear   = QOpenGLTexture__Filter(0x2703)
)

//QOpenGLTexture::MipMapGeneration
type QOpenGLTexture__MipMapGeneration int64

const (
	QOpenGLTexture__GenerateMipMaps     = QOpenGLTexture__MipMapGeneration(0)
	QOpenGLTexture__DontGenerateMipMaps = QOpenGLTexture__MipMapGeneration(1)
)

//QOpenGLTexture::PixelFormat
type QOpenGLTexture__PixelFormat int64

const (
	QOpenGLTexture__NoSourceFormat = QOpenGLTexture__PixelFormat(0)
	QOpenGLTexture__Red            = QOpenGLTexture__PixelFormat(0x1903)
	QOpenGLTexture__RG             = QOpenGLTexture__PixelFormat(0x8227)
	QOpenGLTexture__RGB            = QOpenGLTexture__PixelFormat(0x1907)
	QOpenGLTexture__BGR            = QOpenGLTexture__PixelFormat(0x80E0)
	QOpenGLTexture__RGBA           = QOpenGLTexture__PixelFormat(0x1908)
	QOpenGLTexture__BGRA           = QOpenGLTexture__PixelFormat(0x80E1)
	QOpenGLTexture__Red_Integer    = QOpenGLTexture__PixelFormat(0x8D94)
	QOpenGLTexture__RG_Integer     = QOpenGLTexture__PixelFormat(0x8228)
	QOpenGLTexture__RGB_Integer    = QOpenGLTexture__PixelFormat(0x8D98)
	QOpenGLTexture__BGR_Integer    = QOpenGLTexture__PixelFormat(0x8D9A)
	QOpenGLTexture__RGBA_Integer   = QOpenGLTexture__PixelFormat(0x8D99)
	QOpenGLTexture__BGRA_Integer   = QOpenGLTexture__PixelFormat(0x8D9B)
	QOpenGLTexture__Stencil        = QOpenGLTexture__PixelFormat(0x1901)
	QOpenGLTexture__Depth          = QOpenGLTexture__PixelFormat(0x1902)
	QOpenGLTexture__DepthStencil   = QOpenGLTexture__PixelFormat(0x84F9)
	QOpenGLTexture__Alpha          = QOpenGLTexture__PixelFormat(0x1906)
	QOpenGLTexture__Luminance      = QOpenGLTexture__PixelFormat(0x1909)
	QOpenGLTexture__LuminanceAlpha = QOpenGLTexture__PixelFormat(0x190A)
)

//QOpenGLTexture::PixelType
type QOpenGLTexture__PixelType int64

const (
	QOpenGLTexture__NoPixelType               = QOpenGLTexture__PixelType(0)
	QOpenGLTexture__Int8                      = QOpenGLTexture__PixelType(0x1400)
	QOpenGLTexture__UInt8                     = QOpenGLTexture__PixelType(0x1401)
	QOpenGLTexture__Int16                     = QOpenGLTexture__PixelType(0x1402)
	QOpenGLTexture__UInt16                    = QOpenGLTexture__PixelType(0x1403)
	QOpenGLTexture__Int32                     = QOpenGLTexture__PixelType(0x1404)
	QOpenGLTexture__UInt32                    = QOpenGLTexture__PixelType(0x1405)
	QOpenGLTexture__Float16                   = QOpenGLTexture__PixelType(0x140B)
	QOpenGLTexture__Float16OES                = QOpenGLTexture__PixelType(0x8D61)
	QOpenGLTexture__Float32                   = QOpenGLTexture__PixelType(0x1406)
	QOpenGLTexture__UInt32_RGB9_E5            = QOpenGLTexture__PixelType(0x8C3E)
	QOpenGLTexture__UInt32_RG11B10F           = QOpenGLTexture__PixelType(0x8C3B)
	QOpenGLTexture__UInt8_RG3B2               = QOpenGLTexture__PixelType(0x8032)
	QOpenGLTexture__UInt8_RG3B2_Rev           = QOpenGLTexture__PixelType(0x8362)
	QOpenGLTexture__UInt16_RGB5A1             = QOpenGLTexture__PixelType(0x8034)
	QOpenGLTexture__UInt16_RGB5A1_Rev         = QOpenGLTexture__PixelType(0x8366)
	QOpenGLTexture__UInt16_R5G6B5             = QOpenGLTexture__PixelType(0x8363)
	QOpenGLTexture__UInt16_R5G6B5_Rev         = QOpenGLTexture__PixelType(0x8364)
	QOpenGLTexture__UInt16_RGBA4              = QOpenGLTexture__PixelType(0x8033)
	QOpenGLTexture__UInt16_RGBA4_Rev          = QOpenGLTexture__PixelType(0x8365)
	QOpenGLTexture__UInt32_RGBA8              = QOpenGLTexture__PixelType(0x8035)
	QOpenGLTexture__UInt32_RGBA8_Rev          = QOpenGLTexture__PixelType(0x8367)
	QOpenGLTexture__UInt32_RGB10A2            = QOpenGLTexture__PixelType(0x8036)
	QOpenGLTexture__UInt32_RGB10A2_Rev        = QOpenGLTexture__PixelType(0x8368)
	QOpenGLTexture__UInt32_D24S8              = QOpenGLTexture__PixelType(0x84FA)
	QOpenGLTexture__Float32_D32_UInt32_S8_X24 = QOpenGLTexture__PixelType(0x8DAD)
)

//QOpenGLTexture::SwizzleComponent
type QOpenGLTexture__SwizzleComponent int64

const (
	QOpenGLTexture__SwizzleRed   = QOpenGLTexture__SwizzleComponent(0x8E42)
	QOpenGLTexture__SwizzleGreen = QOpenGLTexture__SwizzleComponent(0x8E43)
	QOpenGLTexture__SwizzleBlue  = QOpenGLTexture__SwizzleComponent(0x8E44)
	QOpenGLTexture__SwizzleAlpha = QOpenGLTexture__SwizzleComponent(0x8E45)
)

//QOpenGLTexture::SwizzleValue
type QOpenGLTexture__SwizzleValue int64

const (
	QOpenGLTexture__RedValue   = QOpenGLTexture__SwizzleValue(0x1903)
	QOpenGLTexture__GreenValue = QOpenGLTexture__SwizzleValue(0x1904)
	QOpenGLTexture__BlueValue  = QOpenGLTexture__SwizzleValue(0x1905)
	QOpenGLTexture__AlphaValue = QOpenGLTexture__SwizzleValue(0x1906)
	QOpenGLTexture__ZeroValue  = QOpenGLTexture__SwizzleValue(0)
	QOpenGLTexture__OneValue   = QOpenGLTexture__SwizzleValue(1)
)

//QOpenGLTexture::Target
type QOpenGLTexture__Target int64

const (
	QOpenGLTexture__Target1D                 = QOpenGLTexture__Target(0x0DE0)
	QOpenGLTexture__Target1DArray            = QOpenGLTexture__Target(0x8C18)
	QOpenGLTexture__Target2D                 = QOpenGLTexture__Target(0x0DE1)
	QOpenGLTexture__Target2DArray            = QOpenGLTexture__Target(0x8C1A)
	QOpenGLTexture__Target3D                 = QOpenGLTexture__Target(0x806F)
	QOpenGLTexture__TargetCubeMap            = QOpenGLTexture__Target(0x8513)
	QOpenGLTexture__TargetCubeMapArray       = QOpenGLTexture__Target(0x9009)
	QOpenGLTexture__Target2DMultisample      = QOpenGLTexture__Target(0x9100)
	QOpenGLTexture__Target2DMultisampleArray = QOpenGLTexture__Target(0x9102)
	QOpenGLTexture__TargetRectangle          = QOpenGLTexture__Target(0x84F5)
	QOpenGLTexture__TargetBuffer             = QOpenGLTexture__Target(0x8C2A)
)

//QOpenGLTexture::TextureFormat
type QOpenGLTexture__TextureFormat int64

const (
	QOpenGLTexture__NoFormat                       = QOpenGLTexture__TextureFormat(0)
	QOpenGLTexture__R8_UNorm                       = QOpenGLTexture__TextureFormat(0x8229)
	QOpenGLTexture__RG8_UNorm                      = QOpenGLTexture__TextureFormat(0x822B)
	QOpenGLTexture__RGB8_UNorm                     = QOpenGLTexture__TextureFormat(0x8051)
	QOpenGLTexture__RGBA8_UNorm                    = QOpenGLTexture__TextureFormat(0x8058)
	QOpenGLTexture__R16_UNorm                      = QOpenGLTexture__TextureFormat(0x822A)
	QOpenGLTexture__RG16_UNorm                     = QOpenGLTexture__TextureFormat(0x822C)
	QOpenGLTexture__RGB16_UNorm                    = QOpenGLTexture__TextureFormat(0x8054)
	QOpenGLTexture__RGBA16_UNorm                   = QOpenGLTexture__TextureFormat(0x805B)
	QOpenGLTexture__R8_SNorm                       = QOpenGLTexture__TextureFormat(0x8F94)
	QOpenGLTexture__RG8_SNorm                      = QOpenGLTexture__TextureFormat(0x8F95)
	QOpenGLTexture__RGB8_SNorm                     = QOpenGLTexture__TextureFormat(0x8F96)
	QOpenGLTexture__RGBA8_SNorm                    = QOpenGLTexture__TextureFormat(0x8F97)
	QOpenGLTexture__R16_SNorm                      = QOpenGLTexture__TextureFormat(0x8F98)
	QOpenGLTexture__RG16_SNorm                     = QOpenGLTexture__TextureFormat(0x8F99)
	QOpenGLTexture__RGB16_SNorm                    = QOpenGLTexture__TextureFormat(0x8F9A)
	QOpenGLTexture__RGBA16_SNorm                   = QOpenGLTexture__TextureFormat(0x8F9B)
	QOpenGLTexture__R8U                            = QOpenGLTexture__TextureFormat(0x8232)
	QOpenGLTexture__RG8U                           = QOpenGLTexture__TextureFormat(0x8238)
	QOpenGLTexture__RGB8U                          = QOpenGLTexture__TextureFormat(0x8D7D)
	QOpenGLTexture__RGBA8U                         = QOpenGLTexture__TextureFormat(0x8D7C)
	QOpenGLTexture__R16U                           = QOpenGLTexture__TextureFormat(0x8234)
	QOpenGLTexture__RG16U                          = QOpenGLTexture__TextureFormat(0x823A)
	QOpenGLTexture__RGB16U                         = QOpenGLTexture__TextureFormat(0x8D77)
	QOpenGLTexture__RGBA16U                        = QOpenGLTexture__TextureFormat(0x8D76)
	QOpenGLTexture__R32U                           = QOpenGLTexture__TextureFormat(0x8236)
	QOpenGLTexture__RG32U                          = QOpenGLTexture__TextureFormat(0x823C)
	QOpenGLTexture__RGB32U                         = QOpenGLTexture__TextureFormat(0x8D71)
	QOpenGLTexture__RGBA32U                        = QOpenGLTexture__TextureFormat(0x8D70)
	QOpenGLTexture__R8I                            = QOpenGLTexture__TextureFormat(0x8231)
	QOpenGLTexture__RG8I                           = QOpenGLTexture__TextureFormat(0x8237)
	QOpenGLTexture__RGB8I                          = QOpenGLTexture__TextureFormat(0x8D8F)
	QOpenGLTexture__RGBA8I                         = QOpenGLTexture__TextureFormat(0x8D8E)
	QOpenGLTexture__R16I                           = QOpenGLTexture__TextureFormat(0x8233)
	QOpenGLTexture__RG16I                          = QOpenGLTexture__TextureFormat(0x8239)
	QOpenGLTexture__RGB16I                         = QOpenGLTexture__TextureFormat(0x8D89)
	QOpenGLTexture__RGBA16I                        = QOpenGLTexture__TextureFormat(0x8D88)
	QOpenGLTexture__R32I                           = QOpenGLTexture__TextureFormat(0x8235)
	QOpenGLTexture__RG32I                          = QOpenGLTexture__TextureFormat(0x823B)
	QOpenGLTexture__RGB32I                         = QOpenGLTexture__TextureFormat(0x8D83)
	QOpenGLTexture__RGBA32I                        = QOpenGLTexture__TextureFormat(0x8D82)
	QOpenGLTexture__R16F                           = QOpenGLTexture__TextureFormat(0x822D)
	QOpenGLTexture__RG16F                          = QOpenGLTexture__TextureFormat(0x822F)
	QOpenGLTexture__RGB16F                         = QOpenGLTexture__TextureFormat(0x881B)
	QOpenGLTexture__RGBA16F                        = QOpenGLTexture__TextureFormat(0x881A)
	QOpenGLTexture__R32F                           = QOpenGLTexture__TextureFormat(0x822E)
	QOpenGLTexture__RG32F                          = QOpenGLTexture__TextureFormat(0x8230)
	QOpenGLTexture__RGB32F                         = QOpenGLTexture__TextureFormat(0x8815)
	QOpenGLTexture__RGBA32F                        = QOpenGLTexture__TextureFormat(0x8814)
	QOpenGLTexture__RGB9E5                         = QOpenGLTexture__TextureFormat(0x8C3D)
	QOpenGLTexture__RG11B10F                       = QOpenGLTexture__TextureFormat(0x8C3A)
	QOpenGLTexture__RG3B2                          = QOpenGLTexture__TextureFormat(0x2A10)
	QOpenGLTexture__R5G6B5                         = QOpenGLTexture__TextureFormat(0x8D62)
	QOpenGLTexture__RGB5A1                         = QOpenGLTexture__TextureFormat(0x8057)
	QOpenGLTexture__RGBA4                          = QOpenGLTexture__TextureFormat(0x8056)
	QOpenGLTexture__RGB10A2                        = QOpenGLTexture__TextureFormat(0x906F)
	QOpenGLTexture__D16                            = QOpenGLTexture__TextureFormat(0x81A5)
	QOpenGLTexture__D24                            = QOpenGLTexture__TextureFormat(0x81A6)
	QOpenGLTexture__D24S8                          = QOpenGLTexture__TextureFormat(0x88F0)
	QOpenGLTexture__D32                            = QOpenGLTexture__TextureFormat(0x81A7)
	QOpenGLTexture__D32F                           = QOpenGLTexture__TextureFormat(0x8CAC)
	QOpenGLTexture__D32FS8X24                      = QOpenGLTexture__TextureFormat(0x8CAD)
	QOpenGLTexture__S8                             = QOpenGLTexture__TextureFormat(0x8D48)
	QOpenGLTexture__RGB_DXT1                       = QOpenGLTexture__TextureFormat(0x83F0)
	QOpenGLTexture__RGBA_DXT1                      = QOpenGLTexture__TextureFormat(0x83F1)
	QOpenGLTexture__RGBA_DXT3                      = QOpenGLTexture__TextureFormat(0x83F2)
	QOpenGLTexture__RGBA_DXT5                      = QOpenGLTexture__TextureFormat(0x83F3)
	QOpenGLTexture__R_ATI1N_UNorm                  = QOpenGLTexture__TextureFormat(0x8DBB)
	QOpenGLTexture__R_ATI1N_SNorm                  = QOpenGLTexture__TextureFormat(0x8DBC)
	QOpenGLTexture__RG_ATI2N_UNorm                 = QOpenGLTexture__TextureFormat(0x8DBD)
	QOpenGLTexture__RG_ATI2N_SNorm                 = QOpenGLTexture__TextureFormat(0x8DBE)
	QOpenGLTexture__RGB_BP_UNSIGNED_FLOAT          = QOpenGLTexture__TextureFormat(0x8E8F)
	QOpenGLTexture__RGB_BP_SIGNED_FLOAT            = QOpenGLTexture__TextureFormat(0x8E8E)
	QOpenGLTexture__RGB_BP_UNorm                   = QOpenGLTexture__TextureFormat(0x8E8C)
	QOpenGLTexture__R11_EAC_UNorm                  = QOpenGLTexture__TextureFormat(0x9270)
	QOpenGLTexture__R11_EAC_SNorm                  = QOpenGLTexture__TextureFormat(0x9271)
	QOpenGLTexture__RG11_EAC_UNorm                 = QOpenGLTexture__TextureFormat(0x9272)
	QOpenGLTexture__RG11_EAC_SNorm                 = QOpenGLTexture__TextureFormat(0x9273)
	QOpenGLTexture__RGB8_ETC2                      = QOpenGLTexture__TextureFormat(0x9274)
	QOpenGLTexture__SRGB8_ETC2                     = QOpenGLTexture__TextureFormat(0x9275)
	QOpenGLTexture__RGB8_PunchThrough_Alpha1_ETC2  = QOpenGLTexture__TextureFormat(0x9276)
	QOpenGLTexture__SRGB8_PunchThrough_Alpha1_ETC2 = QOpenGLTexture__TextureFormat(0x9277)
	QOpenGLTexture__RGBA8_ETC2_EAC                 = QOpenGLTexture__TextureFormat(0x9278)
	QOpenGLTexture__SRGB8_Alpha8_ETC2_EAC          = QOpenGLTexture__TextureFormat(0x9279)
	QOpenGLTexture__SRGB8                          = QOpenGLTexture__TextureFormat(0x8C41)
	QOpenGLTexture__SRGB8_Alpha8                   = QOpenGLTexture__TextureFormat(0x8C43)
	QOpenGLTexture__SRGB_DXT1                      = QOpenGLTexture__TextureFormat(0x8C4C)
	QOpenGLTexture__SRGB_Alpha_DXT1                = QOpenGLTexture__TextureFormat(0x8C4D)
	QOpenGLTexture__SRGB_Alpha_DXT3                = QOpenGLTexture__TextureFormat(0x8C4E)
	QOpenGLTexture__SRGB_Alpha_DXT5                = QOpenGLTexture__TextureFormat(0x8C4F)
	QOpenGLTexture__SRGB_BP_UNorm                  = QOpenGLTexture__TextureFormat(0x8E8D)
	QOpenGLTexture__DepthFormat                    = QOpenGLTexture__TextureFormat(0x1902)
	QOpenGLTexture__AlphaFormat                    = QOpenGLTexture__TextureFormat(0x1906)
	QOpenGLTexture__RGBFormat                      = QOpenGLTexture__TextureFormat(0x1907)
	QOpenGLTexture__RGBAFormat                     = QOpenGLTexture__TextureFormat(0x1908)
	QOpenGLTexture__LuminanceFormat                = QOpenGLTexture__TextureFormat(0x1909)
	QOpenGLTexture__LuminanceAlphaFormat           = QOpenGLTexture__TextureFormat(0x190A)
)

//QOpenGLTexture::TextureUnitReset
type QOpenGLTexture__TextureUnitReset int64

const (
	QOpenGLTexture__ResetTextureUnit     = QOpenGLTexture__TextureUnitReset(0)
	QOpenGLTexture__DontResetTextureUnit = QOpenGLTexture__TextureUnitReset(1)
)

//QOpenGLTexture::WrapMode
type QOpenGLTexture__WrapMode int64

const (
	QOpenGLTexture__Repeat         = QOpenGLTexture__WrapMode(0x2901)
	QOpenGLTexture__MirroredRepeat = QOpenGLTexture__WrapMode(0x8370)
	QOpenGLTexture__ClampToEdge    = QOpenGLTexture__WrapMode(0x812F)
	QOpenGLTexture__ClampToBorder  = QOpenGLTexture__WrapMode(0x812D)
)

type QOpenGLTimeMonitor struct {
	core.QObject
}

type QOpenGLTimeMonitor_ITF interface {
	core.QObject_ITF
	QOpenGLTimeMonitor_PTR() *QOpenGLTimeMonitor
}

func PointerFromQOpenGLTimeMonitor(ptr QOpenGLTimeMonitor_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLTimeMonitor_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLTimeMonitorFromPointer(ptr unsafe.Pointer) *QOpenGLTimeMonitor {
	var n = new(QOpenGLTimeMonitor)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLTimeMonitorFromPointer(ptr unsafe.Pointer) *QOpenGLTimeMonitor {
	var n = NewQOpenGLTimeMonitorFromPointer(ptr)
	for len(n.ObjectName()) < len("QOpenGLTimeMonitor_") {
		n.SetObjectName("QOpenGLTimeMonitor_" + qt.Identifier())
	}
	return n
}

func (ptr *QOpenGLTimeMonitor) QOpenGLTimeMonitor_PTR() *QOpenGLTimeMonitor {
	return ptr
}

type QOpenGLTimerQuery struct {
	core.QObject
}

type QOpenGLTimerQuery_ITF interface {
	core.QObject_ITF
	QOpenGLTimerQuery_PTR() *QOpenGLTimerQuery
}

func PointerFromQOpenGLTimerQuery(ptr QOpenGLTimerQuery_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLTimerQuery_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLTimerQueryFromPointer(ptr unsafe.Pointer) *QOpenGLTimerQuery {
	var n = new(QOpenGLTimerQuery)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLTimerQueryFromPointer(ptr unsafe.Pointer) *QOpenGLTimerQuery {
	var n = NewQOpenGLTimerQueryFromPointer(ptr)
	for len(n.ObjectName()) < len("QOpenGLTimerQuery_") {
		n.SetObjectName("QOpenGLTimerQuery_" + qt.Identifier())
	}
	return n
}

func (ptr *QOpenGLTimerQuery) QOpenGLTimerQuery_PTR() *QOpenGLTimerQuery {
	return ptr
}

type QOpenGLVersionProfile struct {
	ptr unsafe.Pointer
}

type QOpenGLVersionProfile_ITF interface {
	QOpenGLVersionProfile_PTR() *QOpenGLVersionProfile
}

func (p *QOpenGLVersionProfile) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QOpenGLVersionProfile) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQOpenGLVersionProfile(ptr QOpenGLVersionProfile_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLVersionProfile_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLVersionProfileFromPointer(ptr unsafe.Pointer) *QOpenGLVersionProfile {
	var n = new(QOpenGLVersionProfile)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLVersionProfileFromPointer(ptr unsafe.Pointer) *QOpenGLVersionProfile {
	var n = NewQOpenGLVersionProfileFromPointer(ptr)
	return n
}

func (ptr *QOpenGLVersionProfile) QOpenGLVersionProfile_PTR() *QOpenGLVersionProfile {
	return ptr
}

type QOpenGLVertexArrayObject struct {
	core.QObject
}

type QOpenGLVertexArrayObject_ITF interface {
	core.QObject_ITF
	QOpenGLVertexArrayObject_PTR() *QOpenGLVertexArrayObject
}

func PointerFromQOpenGLVertexArrayObject(ptr QOpenGLVertexArrayObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLVertexArrayObject_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLVertexArrayObjectFromPointer(ptr unsafe.Pointer) *QOpenGLVertexArrayObject {
	var n = new(QOpenGLVertexArrayObject)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLVertexArrayObjectFromPointer(ptr unsafe.Pointer) *QOpenGLVertexArrayObject {
	var n = NewQOpenGLVertexArrayObjectFromPointer(ptr)
	for len(n.ObjectName()) < len("QOpenGLVertexArrayObject_") {
		n.SetObjectName("QOpenGLVertexArrayObject_" + qt.Identifier())
	}
	return n
}

func (ptr *QOpenGLVertexArrayObject) QOpenGLVertexArrayObject_PTR() *QOpenGLVertexArrayObject {
	return ptr
}

type QOpenGLWindow struct {
	QPaintDeviceWindow
}

type QOpenGLWindow_ITF interface {
	QPaintDeviceWindow_ITF
	QOpenGLWindow_PTR() *QOpenGLWindow
}

func PointerFromQOpenGLWindow(ptr QOpenGLWindow_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QOpenGLWindow_PTR().Pointer()
	}
	return nil
}

func NewQOpenGLWindowFromPointer(ptr unsafe.Pointer) *QOpenGLWindow {
	var n = new(QOpenGLWindow)
	n.SetPointer(ptr)
	return n
}

func newQOpenGLWindowFromPointer(ptr unsafe.Pointer) *QOpenGLWindow {
	var n = NewQOpenGLWindowFromPointer(ptr)
	for len(n.ObjectName()) < len("QOpenGLWindow_") {
		n.SetObjectName("QOpenGLWindow_" + qt.Identifier())
	}
	return n
}

func (ptr *QOpenGLWindow) QOpenGLWindow_PTR() *QOpenGLWindow {
	return ptr
}

//QOpenGLWindow::UpdateBehavior
type QOpenGLWindow__UpdateBehavior int64

const (
	QOpenGLWindow__NoPartialUpdate    = QOpenGLWindow__UpdateBehavior(0)
	QOpenGLWindow__PartialUpdateBlit  = QOpenGLWindow__UpdateBehavior(1)
	QOpenGLWindow__PartialUpdateBlend = QOpenGLWindow__UpdateBehavior(2)
)

type QPageLayout struct {
	ptr unsafe.Pointer
}

type QPageLayout_ITF interface {
	QPageLayout_PTR() *QPageLayout
}

func (p *QPageLayout) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPageLayout) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPageLayout(ptr QPageLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPageLayout_PTR().Pointer()
	}
	return nil
}

func NewQPageLayoutFromPointer(ptr unsafe.Pointer) *QPageLayout {
	var n = new(QPageLayout)
	n.SetPointer(ptr)
	return n
}

func newQPageLayoutFromPointer(ptr unsafe.Pointer) *QPageLayout {
	var n = NewQPageLayoutFromPointer(ptr)
	return n
}

func (ptr *QPageLayout) QPageLayout_PTR() *QPageLayout {
	return ptr
}

//QPageLayout::Mode
type QPageLayout__Mode int64

const (
	QPageLayout__StandardMode = QPageLayout__Mode(0)
	QPageLayout__FullPageMode = QPageLayout__Mode(1)
)

//QPageLayout::Orientation
type QPageLayout__Orientation int64

const (
	QPageLayout__Portrait  = QPageLayout__Orientation(0)
	QPageLayout__Landscape = QPageLayout__Orientation(1)
)

//QPageLayout::Unit
type QPageLayout__Unit int64

const (
	QPageLayout__Millimeter = QPageLayout__Unit(0)
	QPageLayout__Point      = QPageLayout__Unit(1)
	QPageLayout__Inch       = QPageLayout__Unit(2)
	QPageLayout__Pica       = QPageLayout__Unit(3)
	QPageLayout__Didot      = QPageLayout__Unit(4)
	QPageLayout__Cicero     = QPageLayout__Unit(5)
)

func NewQPageLayout() *QPageLayout {
	defer qt.Recovering("QPageLayout::QPageLayout")

	return newQPageLayoutFromPointer(C.QPageLayout_NewQPageLayout())
}

func NewQPageLayout3(other QPageLayout_ITF) *QPageLayout {
	defer qt.Recovering("QPageLayout::QPageLayout")

	return newQPageLayoutFromPointer(C.QPageLayout_NewQPageLayout3(PointerFromQPageLayout(other)))
}

func NewQPageLayout2(pageSize QPageSize_ITF, orientation QPageLayout__Orientation, margins core.QMarginsF_ITF, units QPageLayout__Unit, minMargins core.QMarginsF_ITF) *QPageLayout {
	defer qt.Recovering("QPageLayout::QPageLayout")

	return newQPageLayoutFromPointer(C.QPageLayout_NewQPageLayout2(PointerFromQPageSize(pageSize), C.int(orientation), core.PointerFromQMarginsF(margins), C.int(units), core.PointerFromQMarginsF(minMargins)))
}

func (ptr *QPageLayout) FullRectPixels(resolution int) *core.QRect {
	defer qt.Recovering("QPageLayout::fullRectPixels")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPageLayout_FullRectPixels(ptr.Pointer(), C.int(resolution)))
	}
	return nil
}

func (ptr *QPageLayout) FullRectPoints() *core.QRect {
	defer qt.Recovering("QPageLayout::fullRectPoints")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPageLayout_FullRectPoints(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPageLayout) IsEquivalentTo(other QPageLayout_ITF) bool {
	defer qt.Recovering("QPageLayout::isEquivalentTo")

	if ptr.Pointer() != nil {
		return C.QPageLayout_IsEquivalentTo(ptr.Pointer(), PointerFromQPageLayout(other)) != 0
	}
	return false
}

func (ptr *QPageLayout) IsValid() bool {
	defer qt.Recovering("QPageLayout::isValid")

	if ptr.Pointer() != nil {
		return C.QPageLayout_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPageLayout) Mode() QPageLayout__Mode {
	defer qt.Recovering("QPageLayout::mode")

	if ptr.Pointer() != nil {
		return QPageLayout__Mode(C.QPageLayout_Mode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPageLayout) Orientation() QPageLayout__Orientation {
	defer qt.Recovering("QPageLayout::orientation")

	if ptr.Pointer() != nil {
		return QPageLayout__Orientation(C.QPageLayout_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPageLayout) PaintRectPixels(resolution int) *core.QRect {
	defer qt.Recovering("QPageLayout::paintRectPixels")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPageLayout_PaintRectPixels(ptr.Pointer(), C.int(resolution)))
	}
	return nil
}

func (ptr *QPageLayout) PaintRectPoints() *core.QRect {
	defer qt.Recovering("QPageLayout::paintRectPoints")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPageLayout_PaintRectPoints(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPageLayout) SetBottomMargin(bottomMargin float64) bool {
	defer qt.Recovering("QPageLayout::setBottomMargin")

	if ptr.Pointer() != nil {
		return C.QPageLayout_SetBottomMargin(ptr.Pointer(), C.double(bottomMargin)) != 0
	}
	return false
}

func (ptr *QPageLayout) SetLeftMargin(leftMargin float64) bool {
	defer qt.Recovering("QPageLayout::setLeftMargin")

	if ptr.Pointer() != nil {
		return C.QPageLayout_SetLeftMargin(ptr.Pointer(), C.double(leftMargin)) != 0
	}
	return false
}

func (ptr *QPageLayout) SetMargins(margins core.QMarginsF_ITF) bool {
	defer qt.Recovering("QPageLayout::setMargins")

	if ptr.Pointer() != nil {
		return C.QPageLayout_SetMargins(ptr.Pointer(), core.PointerFromQMarginsF(margins)) != 0
	}
	return false
}

func (ptr *QPageLayout) SetMinimumMargins(minMargins core.QMarginsF_ITF) {
	defer qt.Recovering("QPageLayout::setMinimumMargins")

	if ptr.Pointer() != nil {
		C.QPageLayout_SetMinimumMargins(ptr.Pointer(), core.PointerFromQMarginsF(minMargins))
	}
}

func (ptr *QPageLayout) SetMode(mode QPageLayout__Mode) {
	defer qt.Recovering("QPageLayout::setMode")

	if ptr.Pointer() != nil {
		C.QPageLayout_SetMode(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QPageLayout) SetOrientation(orientation QPageLayout__Orientation) {
	defer qt.Recovering("QPageLayout::setOrientation")

	if ptr.Pointer() != nil {
		C.QPageLayout_SetOrientation(ptr.Pointer(), C.int(orientation))
	}
}

func (ptr *QPageLayout) SetPageSize(pageSize QPageSize_ITF, minMargins core.QMarginsF_ITF) {
	defer qt.Recovering("QPageLayout::setPageSize")

	if ptr.Pointer() != nil {
		C.QPageLayout_SetPageSize(ptr.Pointer(), PointerFromQPageSize(pageSize), core.PointerFromQMarginsF(minMargins))
	}
}

func (ptr *QPageLayout) SetRightMargin(rightMargin float64) bool {
	defer qt.Recovering("QPageLayout::setRightMargin")

	if ptr.Pointer() != nil {
		return C.QPageLayout_SetRightMargin(ptr.Pointer(), C.double(rightMargin)) != 0
	}
	return false
}

func (ptr *QPageLayout) SetTopMargin(topMargin float64) bool {
	defer qt.Recovering("QPageLayout::setTopMargin")

	if ptr.Pointer() != nil {
		return C.QPageLayout_SetTopMargin(ptr.Pointer(), C.double(topMargin)) != 0
	}
	return false
}

func (ptr *QPageLayout) SetUnits(units QPageLayout__Unit) {
	defer qt.Recovering("QPageLayout::setUnits")

	if ptr.Pointer() != nil {
		C.QPageLayout_SetUnits(ptr.Pointer(), C.int(units))
	}
}

func (ptr *QPageLayout) Swap(other QPageLayout_ITF) {
	defer qt.Recovering("QPageLayout::swap")

	if ptr.Pointer() != nil {
		C.QPageLayout_Swap(ptr.Pointer(), PointerFromQPageLayout(other))
	}
}

func (ptr *QPageLayout) Units() QPageLayout__Unit {
	defer qt.Recovering("QPageLayout::units")

	if ptr.Pointer() != nil {
		return QPageLayout__Unit(C.QPageLayout_Units(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPageLayout) DestroyQPageLayout() {
	defer qt.Recovering("QPageLayout::~QPageLayout")

	if ptr.Pointer() != nil {
		C.QPageLayout_DestroyQPageLayout(ptr.Pointer())
	}
}

type QPageSize struct {
	ptr unsafe.Pointer
}

type QPageSize_ITF interface {
	QPageSize_PTR() *QPageSize
}

func (p *QPageSize) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPageSize) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPageSize(ptr QPageSize_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPageSize_PTR().Pointer()
	}
	return nil
}

func NewQPageSizeFromPointer(ptr unsafe.Pointer) *QPageSize {
	var n = new(QPageSize)
	n.SetPointer(ptr)
	return n
}

func newQPageSizeFromPointer(ptr unsafe.Pointer) *QPageSize {
	var n = NewQPageSizeFromPointer(ptr)
	return n
}

func (ptr *QPageSize) QPageSize_PTR() *QPageSize {
	return ptr
}

//QPageSize::PageSizeId
type QPageSize__PageSizeId int64

const (
	QPageSize__A4                 = QPageSize__PageSizeId(0)
	QPageSize__B5                 = QPageSize__PageSizeId(1)
	QPageSize__Letter             = QPageSize__PageSizeId(2)
	QPageSize__Legal              = QPageSize__PageSizeId(3)
	QPageSize__Executive          = QPageSize__PageSizeId(4)
	QPageSize__A0                 = QPageSize__PageSizeId(5)
	QPageSize__A1                 = QPageSize__PageSizeId(6)
	QPageSize__A2                 = QPageSize__PageSizeId(7)
	QPageSize__A3                 = QPageSize__PageSizeId(8)
	QPageSize__A5                 = QPageSize__PageSizeId(9)
	QPageSize__A6                 = QPageSize__PageSizeId(10)
	QPageSize__A7                 = QPageSize__PageSizeId(11)
	QPageSize__A8                 = QPageSize__PageSizeId(12)
	QPageSize__A9                 = QPageSize__PageSizeId(13)
	QPageSize__B0                 = QPageSize__PageSizeId(14)
	QPageSize__B1                 = QPageSize__PageSizeId(15)
	QPageSize__B10                = QPageSize__PageSizeId(16)
	QPageSize__B2                 = QPageSize__PageSizeId(17)
	QPageSize__B3                 = QPageSize__PageSizeId(18)
	QPageSize__B4                 = QPageSize__PageSizeId(19)
	QPageSize__B6                 = QPageSize__PageSizeId(20)
	QPageSize__B7                 = QPageSize__PageSizeId(21)
	QPageSize__B8                 = QPageSize__PageSizeId(22)
	QPageSize__B9                 = QPageSize__PageSizeId(23)
	QPageSize__C5E                = QPageSize__PageSizeId(24)
	QPageSize__Comm10E            = QPageSize__PageSizeId(25)
	QPageSize__DLE                = QPageSize__PageSizeId(26)
	QPageSize__Folio              = QPageSize__PageSizeId(27)
	QPageSize__Ledger             = QPageSize__PageSizeId(28)
	QPageSize__Tabloid            = QPageSize__PageSizeId(29)
	QPageSize__Custom             = QPageSize__PageSizeId(30)
	QPageSize__A10                = QPageSize__PageSizeId(31)
	QPageSize__A3Extra            = QPageSize__PageSizeId(32)
	QPageSize__A4Extra            = QPageSize__PageSizeId(33)
	QPageSize__A4Plus             = QPageSize__PageSizeId(34)
	QPageSize__A4Small            = QPageSize__PageSizeId(35)
	QPageSize__A5Extra            = QPageSize__PageSizeId(36)
	QPageSize__B5Extra            = QPageSize__PageSizeId(37)
	QPageSize__JisB0              = QPageSize__PageSizeId(38)
	QPageSize__JisB1              = QPageSize__PageSizeId(39)
	QPageSize__JisB2              = QPageSize__PageSizeId(40)
	QPageSize__JisB3              = QPageSize__PageSizeId(41)
	QPageSize__JisB4              = QPageSize__PageSizeId(42)
	QPageSize__JisB5              = QPageSize__PageSizeId(43)
	QPageSize__JisB6              = QPageSize__PageSizeId(44)
	QPageSize__JisB7              = QPageSize__PageSizeId(45)
	QPageSize__JisB8              = QPageSize__PageSizeId(46)
	QPageSize__JisB9              = QPageSize__PageSizeId(47)
	QPageSize__JisB10             = QPageSize__PageSizeId(48)
	QPageSize__AnsiC              = QPageSize__PageSizeId(49)
	QPageSize__AnsiD              = QPageSize__PageSizeId(50)
	QPageSize__AnsiE              = QPageSize__PageSizeId(51)
	QPageSize__LegalExtra         = QPageSize__PageSizeId(52)
	QPageSize__LetterExtra        = QPageSize__PageSizeId(53)
	QPageSize__LetterPlus         = QPageSize__PageSizeId(54)
	QPageSize__LetterSmall        = QPageSize__PageSizeId(55)
	QPageSize__TabloidExtra       = QPageSize__PageSizeId(56)
	QPageSize__ArchA              = QPageSize__PageSizeId(57)
	QPageSize__ArchB              = QPageSize__PageSizeId(58)
	QPageSize__ArchC              = QPageSize__PageSizeId(59)
	QPageSize__ArchD              = QPageSize__PageSizeId(60)
	QPageSize__ArchE              = QPageSize__PageSizeId(61)
	QPageSize__Imperial7x9        = QPageSize__PageSizeId(62)
	QPageSize__Imperial8x10       = QPageSize__PageSizeId(63)
	QPageSize__Imperial9x11       = QPageSize__PageSizeId(64)
	QPageSize__Imperial9x12       = QPageSize__PageSizeId(65)
	QPageSize__Imperial10x11      = QPageSize__PageSizeId(66)
	QPageSize__Imperial10x13      = QPageSize__PageSizeId(67)
	QPageSize__Imperial10x14      = QPageSize__PageSizeId(68)
	QPageSize__Imperial12x11      = QPageSize__PageSizeId(69)
	QPageSize__Imperial15x11      = QPageSize__PageSizeId(70)
	QPageSize__ExecutiveStandard  = QPageSize__PageSizeId(71)
	QPageSize__Note               = QPageSize__PageSizeId(72)
	QPageSize__Quarto             = QPageSize__PageSizeId(73)
	QPageSize__Statement          = QPageSize__PageSizeId(74)
	QPageSize__SuperA             = QPageSize__PageSizeId(75)
	QPageSize__SuperB             = QPageSize__PageSizeId(76)
	QPageSize__Postcard           = QPageSize__PageSizeId(77)
	QPageSize__DoublePostcard     = QPageSize__PageSizeId(78)
	QPageSize__Prc16K             = QPageSize__PageSizeId(79)
	QPageSize__Prc32K             = QPageSize__PageSizeId(80)
	QPageSize__Prc32KBig          = QPageSize__PageSizeId(81)
	QPageSize__FanFoldUS          = QPageSize__PageSizeId(82)
	QPageSize__FanFoldGerman      = QPageSize__PageSizeId(83)
	QPageSize__FanFoldGermanLegal = QPageSize__PageSizeId(84)
	QPageSize__EnvelopeB4         = QPageSize__PageSizeId(85)
	QPageSize__EnvelopeB5         = QPageSize__PageSizeId(86)
	QPageSize__EnvelopeB6         = QPageSize__PageSizeId(87)
	QPageSize__EnvelopeC0         = QPageSize__PageSizeId(88)
	QPageSize__EnvelopeC1         = QPageSize__PageSizeId(89)
	QPageSize__EnvelopeC2         = QPageSize__PageSizeId(90)
	QPageSize__EnvelopeC3         = QPageSize__PageSizeId(91)
	QPageSize__EnvelopeC4         = QPageSize__PageSizeId(92)
	QPageSize__EnvelopeC6         = QPageSize__PageSizeId(93)
	QPageSize__EnvelopeC65        = QPageSize__PageSizeId(94)
	QPageSize__EnvelopeC7         = QPageSize__PageSizeId(95)
	QPageSize__Envelope9          = QPageSize__PageSizeId(96)
	QPageSize__Envelope11         = QPageSize__PageSizeId(97)
	QPageSize__Envelope12         = QPageSize__PageSizeId(98)
	QPageSize__Envelope14         = QPageSize__PageSizeId(99)
	QPageSize__EnvelopeMonarch    = QPageSize__PageSizeId(100)
	QPageSize__EnvelopePersonal   = QPageSize__PageSizeId(101)
	QPageSize__EnvelopeChou3      = QPageSize__PageSizeId(102)
	QPageSize__EnvelopeChou4      = QPageSize__PageSizeId(103)
	QPageSize__EnvelopeInvite     = QPageSize__PageSizeId(104)
	QPageSize__EnvelopeItalian    = QPageSize__PageSizeId(105)
	QPageSize__EnvelopeKaku2      = QPageSize__PageSizeId(106)
	QPageSize__EnvelopeKaku3      = QPageSize__PageSizeId(107)
	QPageSize__EnvelopePrc1       = QPageSize__PageSizeId(108)
	QPageSize__EnvelopePrc2       = QPageSize__PageSizeId(109)
	QPageSize__EnvelopePrc3       = QPageSize__PageSizeId(110)
	QPageSize__EnvelopePrc4       = QPageSize__PageSizeId(111)
	QPageSize__EnvelopePrc5       = QPageSize__PageSizeId(112)
	QPageSize__EnvelopePrc6       = QPageSize__PageSizeId(113)
	QPageSize__EnvelopePrc7       = QPageSize__PageSizeId(114)
	QPageSize__EnvelopePrc8       = QPageSize__PageSizeId(115)
	QPageSize__EnvelopePrc9       = QPageSize__PageSizeId(116)
	QPageSize__EnvelopePrc10      = QPageSize__PageSizeId(117)
	QPageSize__EnvelopeYou4       = QPageSize__PageSizeId(118)
	QPageSize__LastPageSize       = QPageSize__PageSizeId(QPageSize__EnvelopeYou4)
	QPageSize__NPageSize          = QPageSize__PageSizeId(QPageSize__LastPageSize)
	QPageSize__NPaperSize         = QPageSize__PageSizeId(QPageSize__LastPageSize)
	QPageSize__AnsiA              = QPageSize__PageSizeId(QPageSize__Letter)
	QPageSize__AnsiB              = QPageSize__PageSizeId(QPageSize__Ledger)
	QPageSize__EnvelopeC5         = QPageSize__PageSizeId(QPageSize__C5E)
	QPageSize__EnvelopeDL         = QPageSize__PageSizeId(QPageSize__DLE)
	QPageSize__Envelope10         = QPageSize__PageSizeId(QPageSize__Comm10E)
)

//QPageSize::SizeMatchPolicy
type QPageSize__SizeMatchPolicy int64

const (
	QPageSize__FuzzyMatch            = QPageSize__SizeMatchPolicy(0)
	QPageSize__FuzzyOrientationMatch = QPageSize__SizeMatchPolicy(1)
	QPageSize__ExactMatch            = QPageSize__SizeMatchPolicy(2)
)

//QPageSize::Unit
type QPageSize__Unit int64

const (
	QPageSize__Millimeter = QPageSize__Unit(0)
	QPageSize__Point      = QPageSize__Unit(1)
	QPageSize__Inch       = QPageSize__Unit(2)
	QPageSize__Pica       = QPageSize__Unit(3)
	QPageSize__Didot      = QPageSize__Unit(4)
	QPageSize__Cicero     = QPageSize__Unit(5)
)

func NewQPageSize() *QPageSize {
	defer qt.Recovering("QPageSize::QPageSize")

	return newQPageSizeFromPointer(C.QPageSize_NewQPageSize())
}

func NewQPageSize2(pageSize QPageSize__PageSizeId) *QPageSize {
	defer qt.Recovering("QPageSize::QPageSize")

	return newQPageSizeFromPointer(C.QPageSize_NewQPageSize2(C.int(pageSize)))
}

func NewQPageSize5(other QPageSize_ITF) *QPageSize {
	defer qt.Recovering("QPageSize::QPageSize")

	return newQPageSizeFromPointer(C.QPageSize_NewQPageSize5(PointerFromQPageSize(other)))
}

func NewQPageSize3(pointSize core.QSize_ITF, name string, matchPolicy QPageSize__SizeMatchPolicy) *QPageSize {
	defer qt.Recovering("QPageSize::QPageSize")

	return newQPageSizeFromPointer(C.QPageSize_NewQPageSize3(core.PointerFromQSize(pointSize), C.CString(name), C.int(matchPolicy)))
}

func NewQPageSize4(size core.QSizeF_ITF, units QPageSize__Unit, name string, matchPolicy QPageSize__SizeMatchPolicy) *QPageSize {
	defer qt.Recovering("QPageSize::QPageSize")

	return newQPageSizeFromPointer(C.QPageSize_NewQPageSize4(core.PointerFromQSizeF(size), C.int(units), C.CString(name), C.int(matchPolicy)))
}

func QPageSize_DefinitionUnits2(pageSizeId QPageSize__PageSizeId) QPageSize__Unit {
	defer qt.Recovering("QPageSize::definitionUnits")

	return QPageSize__Unit(C.QPageSize_QPageSize_DefinitionUnits2(C.int(pageSizeId)))
}

func (ptr *QPageSize) DefinitionUnits() QPageSize__Unit {
	defer qt.Recovering("QPageSize::definitionUnits")

	if ptr.Pointer() != nil {
		return QPageSize__Unit(C.QPageSize_DefinitionUnits(ptr.Pointer()))
	}
	return 0
}

func QPageSize_Id2(pointSize core.QSize_ITF, matchPolicy QPageSize__SizeMatchPolicy) QPageSize__PageSizeId {
	defer qt.Recovering("QPageSize::id")

	return QPageSize__PageSizeId(C.QPageSize_QPageSize_Id2(core.PointerFromQSize(pointSize), C.int(matchPolicy)))
}

func QPageSize_Id3(size core.QSizeF_ITF, units QPageSize__Unit, matchPolicy QPageSize__SizeMatchPolicy) QPageSize__PageSizeId {
	defer qt.Recovering("QPageSize::id")

	return QPageSize__PageSizeId(C.QPageSize_QPageSize_Id3(core.PointerFromQSizeF(size), C.int(units), C.int(matchPolicy)))
}

func QPageSize_Id4(windowsId int) QPageSize__PageSizeId {
	defer qt.Recovering("QPageSize::id")

	return QPageSize__PageSizeId(C.QPageSize_QPageSize_Id4(C.int(windowsId)))
}

func (ptr *QPageSize) Id() QPageSize__PageSizeId {
	defer qt.Recovering("QPageSize::id")

	if ptr.Pointer() != nil {
		return QPageSize__PageSizeId(C.QPageSize_Id(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPageSize) IsEquivalentTo(other QPageSize_ITF) bool {
	defer qt.Recovering("QPageSize::isEquivalentTo")

	if ptr.Pointer() != nil {
		return C.QPageSize_IsEquivalentTo(ptr.Pointer(), PointerFromQPageSize(other)) != 0
	}
	return false
}

func (ptr *QPageSize) IsValid() bool {
	defer qt.Recovering("QPageSize::isValid")

	if ptr.Pointer() != nil {
		return C.QPageSize_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func QPageSize_Key2(pageSizeId QPageSize__PageSizeId) string {
	defer qt.Recovering("QPageSize::key")

	return C.GoString(C.QPageSize_QPageSize_Key2(C.int(pageSizeId)))
}

func (ptr *QPageSize) Key() string {
	defer qt.Recovering("QPageSize::key")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPageSize_Key(ptr.Pointer()))
	}
	return ""
}

func QPageSize_Name2(pageSizeId QPageSize__PageSizeId) string {
	defer qt.Recovering("QPageSize::name")

	return C.GoString(C.QPageSize_QPageSize_Name2(C.int(pageSizeId)))
}

func (ptr *QPageSize) Name() string {
	defer qt.Recovering("QPageSize::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPageSize_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPageSize) RectPixels(resolution int) *core.QRect {
	defer qt.Recovering("QPageSize::rectPixels")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPageSize_RectPixels(ptr.Pointer(), C.int(resolution)))
	}
	return nil
}

func (ptr *QPageSize) RectPoints() *core.QRect {
	defer qt.Recovering("QPageSize::rectPoints")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPageSize_RectPoints(ptr.Pointer()))
	}
	return nil
}

func QPageSize_SizePixels2(pageSizeId QPageSize__PageSizeId, resolution int) *core.QSize {
	defer qt.Recovering("QPageSize::sizePixels")

	return core.NewQSizeFromPointer(C.QPageSize_QPageSize_SizePixels2(C.int(pageSizeId), C.int(resolution)))
}

func (ptr *QPageSize) SizePixels(resolution int) *core.QSize {
	defer qt.Recovering("QPageSize::sizePixels")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QPageSize_SizePixels(ptr.Pointer(), C.int(resolution)))
	}
	return nil
}

func QPageSize_SizePoints2(pageSizeId QPageSize__PageSizeId) *core.QSize {
	defer qt.Recovering("QPageSize::sizePoints")

	return core.NewQSizeFromPointer(C.QPageSize_QPageSize_SizePoints2(C.int(pageSizeId)))
}

func (ptr *QPageSize) SizePoints() *core.QSize {
	defer qt.Recovering("QPageSize::sizePoints")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QPageSize_SizePoints(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPageSize) Swap(other QPageSize_ITF) {
	defer qt.Recovering("QPageSize::swap")

	if ptr.Pointer() != nil {
		C.QPageSize_Swap(ptr.Pointer(), PointerFromQPageSize(other))
	}
}

func QPageSize_WindowsId2(pageSizeId QPageSize__PageSizeId) int {
	defer qt.Recovering("QPageSize::windowsId")

	return int(C.QPageSize_QPageSize_WindowsId2(C.int(pageSizeId)))
}

func (ptr *QPageSize) WindowsId() int {
	defer qt.Recovering("QPageSize::windowsId")

	if ptr.Pointer() != nil {
		return int(C.QPageSize_WindowsId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPageSize) DestroyQPageSize() {
	defer qt.Recovering("QPageSize::~QPageSize")

	if ptr.Pointer() != nil {
		C.QPageSize_DestroyQPageSize(ptr.Pointer())
	}
}

type QPagedPaintDevice struct {
	QPaintDevice
}

type QPagedPaintDevice_ITF interface {
	QPaintDevice_ITF
	QPagedPaintDevice_PTR() *QPagedPaintDevice
}

func PointerFromQPagedPaintDevice(ptr QPagedPaintDevice_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPagedPaintDevice_PTR().Pointer()
	}
	return nil
}

func NewQPagedPaintDeviceFromPointer(ptr unsafe.Pointer) *QPagedPaintDevice {
	var n = new(QPagedPaintDevice)
	n.SetPointer(ptr)
	return n
}

func newQPagedPaintDeviceFromPointer(ptr unsafe.Pointer) *QPagedPaintDevice {
	var n = NewQPagedPaintDeviceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QPagedPaintDevice_") {
		n.SetObjectNameAbs("QPagedPaintDevice_" + qt.Identifier())
	}
	return n
}

func (ptr *QPagedPaintDevice) QPagedPaintDevice_PTR() *QPagedPaintDevice {
	return ptr
}

//QPagedPaintDevice::PageSize
type QPagedPaintDevice__PageSize int64

const (
	QPagedPaintDevice__A4                 = QPagedPaintDevice__PageSize(0)
	QPagedPaintDevice__B5                 = QPagedPaintDevice__PageSize(1)
	QPagedPaintDevice__Letter             = QPagedPaintDevice__PageSize(2)
	QPagedPaintDevice__Legal              = QPagedPaintDevice__PageSize(3)
	QPagedPaintDevice__Executive          = QPagedPaintDevice__PageSize(4)
	QPagedPaintDevice__A0                 = QPagedPaintDevice__PageSize(5)
	QPagedPaintDevice__A1                 = QPagedPaintDevice__PageSize(6)
	QPagedPaintDevice__A2                 = QPagedPaintDevice__PageSize(7)
	QPagedPaintDevice__A3                 = QPagedPaintDevice__PageSize(8)
	QPagedPaintDevice__A5                 = QPagedPaintDevice__PageSize(9)
	QPagedPaintDevice__A6                 = QPagedPaintDevice__PageSize(10)
	QPagedPaintDevice__A7                 = QPagedPaintDevice__PageSize(11)
	QPagedPaintDevice__A8                 = QPagedPaintDevice__PageSize(12)
	QPagedPaintDevice__A9                 = QPagedPaintDevice__PageSize(13)
	QPagedPaintDevice__B0                 = QPagedPaintDevice__PageSize(14)
	QPagedPaintDevice__B1                 = QPagedPaintDevice__PageSize(15)
	QPagedPaintDevice__B10                = QPagedPaintDevice__PageSize(16)
	QPagedPaintDevice__B2                 = QPagedPaintDevice__PageSize(17)
	QPagedPaintDevice__B3                 = QPagedPaintDevice__PageSize(18)
	QPagedPaintDevice__B4                 = QPagedPaintDevice__PageSize(19)
	QPagedPaintDevice__B6                 = QPagedPaintDevice__PageSize(20)
	QPagedPaintDevice__B7                 = QPagedPaintDevice__PageSize(21)
	QPagedPaintDevice__B8                 = QPagedPaintDevice__PageSize(22)
	QPagedPaintDevice__B9                 = QPagedPaintDevice__PageSize(23)
	QPagedPaintDevice__C5E                = QPagedPaintDevice__PageSize(24)
	QPagedPaintDevice__Comm10E            = QPagedPaintDevice__PageSize(25)
	QPagedPaintDevice__DLE                = QPagedPaintDevice__PageSize(26)
	QPagedPaintDevice__Folio              = QPagedPaintDevice__PageSize(27)
	QPagedPaintDevice__Ledger             = QPagedPaintDevice__PageSize(28)
	QPagedPaintDevice__Tabloid            = QPagedPaintDevice__PageSize(29)
	QPagedPaintDevice__Custom             = QPagedPaintDevice__PageSize(30)
	QPagedPaintDevice__A10                = QPagedPaintDevice__PageSize(31)
	QPagedPaintDevice__A3Extra            = QPagedPaintDevice__PageSize(32)
	QPagedPaintDevice__A4Extra            = QPagedPaintDevice__PageSize(33)
	QPagedPaintDevice__A4Plus             = QPagedPaintDevice__PageSize(34)
	QPagedPaintDevice__A4Small            = QPagedPaintDevice__PageSize(35)
	QPagedPaintDevice__A5Extra            = QPagedPaintDevice__PageSize(36)
	QPagedPaintDevice__B5Extra            = QPagedPaintDevice__PageSize(37)
	QPagedPaintDevice__JisB0              = QPagedPaintDevice__PageSize(38)
	QPagedPaintDevice__JisB1              = QPagedPaintDevice__PageSize(39)
	QPagedPaintDevice__JisB2              = QPagedPaintDevice__PageSize(40)
	QPagedPaintDevice__JisB3              = QPagedPaintDevice__PageSize(41)
	QPagedPaintDevice__JisB4              = QPagedPaintDevice__PageSize(42)
	QPagedPaintDevice__JisB5              = QPagedPaintDevice__PageSize(43)
	QPagedPaintDevice__JisB6              = QPagedPaintDevice__PageSize(44)
	QPagedPaintDevice__JisB7              = QPagedPaintDevice__PageSize(45)
	QPagedPaintDevice__JisB8              = QPagedPaintDevice__PageSize(46)
	QPagedPaintDevice__JisB9              = QPagedPaintDevice__PageSize(47)
	QPagedPaintDevice__JisB10             = QPagedPaintDevice__PageSize(48)
	QPagedPaintDevice__AnsiC              = QPagedPaintDevice__PageSize(49)
	QPagedPaintDevice__AnsiD              = QPagedPaintDevice__PageSize(50)
	QPagedPaintDevice__AnsiE              = QPagedPaintDevice__PageSize(51)
	QPagedPaintDevice__LegalExtra         = QPagedPaintDevice__PageSize(52)
	QPagedPaintDevice__LetterExtra        = QPagedPaintDevice__PageSize(53)
	QPagedPaintDevice__LetterPlus         = QPagedPaintDevice__PageSize(54)
	QPagedPaintDevice__LetterSmall        = QPagedPaintDevice__PageSize(55)
	QPagedPaintDevice__TabloidExtra       = QPagedPaintDevice__PageSize(56)
	QPagedPaintDevice__ArchA              = QPagedPaintDevice__PageSize(57)
	QPagedPaintDevice__ArchB              = QPagedPaintDevice__PageSize(58)
	QPagedPaintDevice__ArchC              = QPagedPaintDevice__PageSize(59)
	QPagedPaintDevice__ArchD              = QPagedPaintDevice__PageSize(60)
	QPagedPaintDevice__ArchE              = QPagedPaintDevice__PageSize(61)
	QPagedPaintDevice__Imperial7x9        = QPagedPaintDevice__PageSize(62)
	QPagedPaintDevice__Imperial8x10       = QPagedPaintDevice__PageSize(63)
	QPagedPaintDevice__Imperial9x11       = QPagedPaintDevice__PageSize(64)
	QPagedPaintDevice__Imperial9x12       = QPagedPaintDevice__PageSize(65)
	QPagedPaintDevice__Imperial10x11      = QPagedPaintDevice__PageSize(66)
	QPagedPaintDevice__Imperial10x13      = QPagedPaintDevice__PageSize(67)
	QPagedPaintDevice__Imperial10x14      = QPagedPaintDevice__PageSize(68)
	QPagedPaintDevice__Imperial12x11      = QPagedPaintDevice__PageSize(69)
	QPagedPaintDevice__Imperial15x11      = QPagedPaintDevice__PageSize(70)
	QPagedPaintDevice__ExecutiveStandard  = QPagedPaintDevice__PageSize(71)
	QPagedPaintDevice__Note               = QPagedPaintDevice__PageSize(72)
	QPagedPaintDevice__Quarto             = QPagedPaintDevice__PageSize(73)
	QPagedPaintDevice__Statement          = QPagedPaintDevice__PageSize(74)
	QPagedPaintDevice__SuperA             = QPagedPaintDevice__PageSize(75)
	QPagedPaintDevice__SuperB             = QPagedPaintDevice__PageSize(76)
	QPagedPaintDevice__Postcard           = QPagedPaintDevice__PageSize(77)
	QPagedPaintDevice__DoublePostcard     = QPagedPaintDevice__PageSize(78)
	QPagedPaintDevice__Prc16K             = QPagedPaintDevice__PageSize(79)
	QPagedPaintDevice__Prc32K             = QPagedPaintDevice__PageSize(80)
	QPagedPaintDevice__Prc32KBig          = QPagedPaintDevice__PageSize(81)
	QPagedPaintDevice__FanFoldUS          = QPagedPaintDevice__PageSize(82)
	QPagedPaintDevice__FanFoldGerman      = QPagedPaintDevice__PageSize(83)
	QPagedPaintDevice__FanFoldGermanLegal = QPagedPaintDevice__PageSize(84)
	QPagedPaintDevice__EnvelopeB4         = QPagedPaintDevice__PageSize(85)
	QPagedPaintDevice__EnvelopeB5         = QPagedPaintDevice__PageSize(86)
	QPagedPaintDevice__EnvelopeB6         = QPagedPaintDevice__PageSize(87)
	QPagedPaintDevice__EnvelopeC0         = QPagedPaintDevice__PageSize(88)
	QPagedPaintDevice__EnvelopeC1         = QPagedPaintDevice__PageSize(89)
	QPagedPaintDevice__EnvelopeC2         = QPagedPaintDevice__PageSize(90)
	QPagedPaintDevice__EnvelopeC3         = QPagedPaintDevice__PageSize(91)
	QPagedPaintDevice__EnvelopeC4         = QPagedPaintDevice__PageSize(92)
	QPagedPaintDevice__EnvelopeC6         = QPagedPaintDevice__PageSize(93)
	QPagedPaintDevice__EnvelopeC65        = QPagedPaintDevice__PageSize(94)
	QPagedPaintDevice__EnvelopeC7         = QPagedPaintDevice__PageSize(95)
	QPagedPaintDevice__Envelope9          = QPagedPaintDevice__PageSize(96)
	QPagedPaintDevice__Envelope11         = QPagedPaintDevice__PageSize(97)
	QPagedPaintDevice__Envelope12         = QPagedPaintDevice__PageSize(98)
	QPagedPaintDevice__Envelope14         = QPagedPaintDevice__PageSize(99)
	QPagedPaintDevice__EnvelopeMonarch    = QPagedPaintDevice__PageSize(100)
	QPagedPaintDevice__EnvelopePersonal   = QPagedPaintDevice__PageSize(101)
	QPagedPaintDevice__EnvelopeChou3      = QPagedPaintDevice__PageSize(102)
	QPagedPaintDevice__EnvelopeChou4      = QPagedPaintDevice__PageSize(103)
	QPagedPaintDevice__EnvelopeInvite     = QPagedPaintDevice__PageSize(104)
	QPagedPaintDevice__EnvelopeItalian    = QPagedPaintDevice__PageSize(105)
	QPagedPaintDevice__EnvelopeKaku2      = QPagedPaintDevice__PageSize(106)
	QPagedPaintDevice__EnvelopeKaku3      = QPagedPaintDevice__PageSize(107)
	QPagedPaintDevice__EnvelopePrc1       = QPagedPaintDevice__PageSize(108)
	QPagedPaintDevice__EnvelopePrc2       = QPagedPaintDevice__PageSize(109)
	QPagedPaintDevice__EnvelopePrc3       = QPagedPaintDevice__PageSize(110)
	QPagedPaintDevice__EnvelopePrc4       = QPagedPaintDevice__PageSize(111)
	QPagedPaintDevice__EnvelopePrc5       = QPagedPaintDevice__PageSize(112)
	QPagedPaintDevice__EnvelopePrc6       = QPagedPaintDevice__PageSize(113)
	QPagedPaintDevice__EnvelopePrc7       = QPagedPaintDevice__PageSize(114)
	QPagedPaintDevice__EnvelopePrc8       = QPagedPaintDevice__PageSize(115)
	QPagedPaintDevice__EnvelopePrc9       = QPagedPaintDevice__PageSize(116)
	QPagedPaintDevice__EnvelopePrc10      = QPagedPaintDevice__PageSize(117)
	QPagedPaintDevice__EnvelopeYou4       = QPagedPaintDevice__PageSize(118)
	QPagedPaintDevice__LastPageSize       = QPagedPaintDevice__PageSize(QPagedPaintDevice__EnvelopeYou4)
	QPagedPaintDevice__NPageSize          = QPagedPaintDevice__PageSize(QPagedPaintDevice__LastPageSize)
	QPagedPaintDevice__NPaperSize         = QPagedPaintDevice__PageSize(QPagedPaintDevice__LastPageSize)
	QPagedPaintDevice__AnsiA              = QPagedPaintDevice__PageSize(QPagedPaintDevice__Letter)
	QPagedPaintDevice__AnsiB              = QPagedPaintDevice__PageSize(QPagedPaintDevice__Ledger)
	QPagedPaintDevice__EnvelopeC5         = QPagedPaintDevice__PageSize(QPagedPaintDevice__C5E)
	QPagedPaintDevice__EnvelopeDL         = QPagedPaintDevice__PageSize(QPagedPaintDevice__DLE)
	QPagedPaintDevice__Envelope10         = QPagedPaintDevice__PageSize(QPagedPaintDevice__Comm10E)
)

func (ptr *QPagedPaintDevice) NewPage() bool {
	defer qt.Recovering("QPagedPaintDevice::newPage")

	if ptr.Pointer() != nil {
		return C.QPagedPaintDevice_NewPage(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPagedPaintDevice) PageSize() QPagedPaintDevice__PageSize {
	defer qt.Recovering("QPagedPaintDevice::pageSize")

	if ptr.Pointer() != nil {
		return QPagedPaintDevice__PageSize(C.QPagedPaintDevice_PageSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPagedPaintDevice) SetPageLayout(newPageLayout QPageLayout_ITF) bool {
	defer qt.Recovering("QPagedPaintDevice::setPageLayout")

	if ptr.Pointer() != nil {
		return C.QPagedPaintDevice_SetPageLayout(ptr.Pointer(), PointerFromQPageLayout(newPageLayout)) != 0
	}
	return false
}

func (ptr *QPagedPaintDevice) SetPageMargins(margins core.QMarginsF_ITF) bool {
	defer qt.Recovering("QPagedPaintDevice::setPageMargins")

	if ptr.Pointer() != nil {
		return C.QPagedPaintDevice_SetPageMargins(ptr.Pointer(), core.PointerFromQMarginsF(margins)) != 0
	}
	return false
}

func (ptr *QPagedPaintDevice) SetPageMargins2(margins core.QMarginsF_ITF, units QPageLayout__Unit) bool {
	defer qt.Recovering("QPagedPaintDevice::setPageMargins")

	if ptr.Pointer() != nil {
		return C.QPagedPaintDevice_SetPageMargins2(ptr.Pointer(), core.PointerFromQMarginsF(margins), C.int(units)) != 0
	}
	return false
}

func (ptr *QPagedPaintDevice) SetPageOrientation(orientation QPageLayout__Orientation) bool {
	defer qt.Recovering("QPagedPaintDevice::setPageOrientation")

	if ptr.Pointer() != nil {
		return C.QPagedPaintDevice_SetPageOrientation(ptr.Pointer(), C.int(orientation)) != 0
	}
	return false
}

func (ptr *QPagedPaintDevice) SetPageSize(pageSize QPageSize_ITF) bool {
	defer qt.Recovering("QPagedPaintDevice::setPageSize")

	if ptr.Pointer() != nil {
		return C.QPagedPaintDevice_SetPageSize(ptr.Pointer(), PointerFromQPageSize(pageSize)) != 0
	}
	return false
}

func (ptr *QPagedPaintDevice) DestroyQPagedPaintDevice() {
	defer qt.Recovering("QPagedPaintDevice::~QPagedPaintDevice")

	if ptr.Pointer() != nil {
		C.QPagedPaintDevice_DestroyQPagedPaintDevice(ptr.Pointer())
	}
}

func (ptr *QPagedPaintDevice) ObjectNameAbs() string {
	defer qt.Recovering("QPagedPaintDevice::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPagedPaintDevice_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPagedPaintDevice) SetObjectNameAbs(name string) {
	defer qt.Recovering("QPagedPaintDevice::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QPagedPaintDevice_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QPaintDevice struct {
	ptr unsafe.Pointer
}

type QPaintDevice_ITF interface {
	QPaintDevice_PTR() *QPaintDevice
}

func (p *QPaintDevice) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPaintDevice) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPaintDevice(ptr QPaintDevice_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPaintDevice_PTR().Pointer()
	}
	return nil
}

func NewQPaintDeviceFromPointer(ptr unsafe.Pointer) *QPaintDevice {
	var n = new(QPaintDevice)
	n.SetPointer(ptr)
	return n
}

func newQPaintDeviceFromPointer(ptr unsafe.Pointer) *QPaintDevice {
	var n = NewQPaintDeviceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QPaintDevice_") {
		n.SetObjectNameAbs("QPaintDevice_" + qt.Identifier())
	}
	return n
}

func (ptr *QPaintDevice) QPaintDevice_PTR() *QPaintDevice {
	return ptr
}

//QPaintDevice::PaintDeviceMetric
type QPaintDevice__PaintDeviceMetric int64

const (
	QPaintDevice__PdmWidth            = QPaintDevice__PaintDeviceMetric(1)
	QPaintDevice__PdmHeight           = QPaintDevice__PaintDeviceMetric(2)
	QPaintDevice__PdmWidthMM          = QPaintDevice__PaintDeviceMetric(3)
	QPaintDevice__PdmHeightMM         = QPaintDevice__PaintDeviceMetric(4)
	QPaintDevice__PdmNumColors        = QPaintDevice__PaintDeviceMetric(5)
	QPaintDevice__PdmDepth            = QPaintDevice__PaintDeviceMetric(6)
	QPaintDevice__PdmDpiX             = QPaintDevice__PaintDeviceMetric(7)
	QPaintDevice__PdmDpiY             = QPaintDevice__PaintDeviceMetric(8)
	QPaintDevice__PdmPhysicalDpiX     = QPaintDevice__PaintDeviceMetric(9)
	QPaintDevice__PdmPhysicalDpiY     = QPaintDevice__PaintDeviceMetric(10)
	QPaintDevice__PdmDevicePixelRatio = QPaintDevice__PaintDeviceMetric(11)
)

func (ptr *QPaintDevice) Metric(metric QPaintDevice__PaintDeviceMetric) int {
	defer qt.Recovering("QPaintDevice::metric")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_Metric(ptr.Pointer(), C.int(metric)))
	}
	return 0
}

func (ptr *QPaintDevice) DestroyQPaintDevice() {
	defer qt.Recovering("QPaintDevice::~QPaintDevice")

	if ptr.Pointer() != nil {
		C.QPaintDevice_DestroyQPaintDevice(ptr.Pointer())
	}
}

func (ptr *QPaintDevice) ColorCount() int {
	defer qt.Recovering("QPaintDevice::colorCount")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_ColorCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) Depth() int {
	defer qt.Recovering("QPaintDevice::depth")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_Depth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) DevicePixelRatio() int {
	defer qt.Recovering("QPaintDevice::devicePixelRatio")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_DevicePixelRatio(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) Height() int {
	defer qt.Recovering("QPaintDevice::height")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) HeightMM() int {
	defer qt.Recovering("QPaintDevice::heightMM")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_HeightMM(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) LogicalDpiX() int {
	defer qt.Recovering("QPaintDevice::logicalDpiX")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_LogicalDpiX(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) LogicalDpiY() int {
	defer qt.Recovering("QPaintDevice::logicalDpiY")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_LogicalDpiY(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) PaintEngine() *QPaintEngine {
	defer qt.Recovering("QPaintDevice::paintEngine")

	if ptr.Pointer() != nil {
		return NewQPaintEngineFromPointer(C.QPaintDevice_PaintEngine(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPaintDevice) PaintingActive() bool {
	defer qt.Recovering("QPaintDevice::paintingActive")

	if ptr.Pointer() != nil {
		return C.QPaintDevice_PaintingActive(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPaintDevice) PhysicalDpiX() int {
	defer qt.Recovering("QPaintDevice::physicalDpiX")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_PhysicalDpiX(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) PhysicalDpiY() int {
	defer qt.Recovering("QPaintDevice::physicalDpiY")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_PhysicalDpiY(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) Width() int {
	defer qt.Recovering("QPaintDevice::width")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_Width(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) WidthMM() int {
	defer qt.Recovering("QPaintDevice::widthMM")

	if ptr.Pointer() != nil {
		return int(C.QPaintDevice_WidthMM(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintDevice) ObjectNameAbs() string {
	defer qt.Recovering("QPaintDevice::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPaintDevice_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPaintDevice) SetObjectNameAbs(name string) {
	defer qt.Recovering("QPaintDevice::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QPaintDevice_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QPaintDeviceWindow struct {
	QWindow
	QPaintDevice
}

type QPaintDeviceWindow_ITF interface {
	QWindow_ITF
	QPaintDevice_ITF
	QPaintDeviceWindow_PTR() *QPaintDeviceWindow
}

func (p *QPaintDeviceWindow) Pointer() unsafe.Pointer {
	return p.QWindow_PTR().Pointer()
}

func (p *QPaintDeviceWindow) SetPointer(ptr unsafe.Pointer) {
	p.QWindow_PTR().SetPointer(ptr)
	p.QPaintDevice_PTR().SetPointer(ptr)
}

func PointerFromQPaintDeviceWindow(ptr QPaintDeviceWindow_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPaintDeviceWindow_PTR().Pointer()
	}
	return nil
}

func NewQPaintDeviceWindowFromPointer(ptr unsafe.Pointer) *QPaintDeviceWindow {
	var n = new(QPaintDeviceWindow)
	n.SetPointer(ptr)
	return n
}

func newQPaintDeviceWindowFromPointer(ptr unsafe.Pointer) *QPaintDeviceWindow {
	var n = NewQPaintDeviceWindowFromPointer(ptr)
	for len(n.ObjectName()) < len("QPaintDeviceWindow_") {
		n.SetObjectName("QPaintDeviceWindow_" + qt.Identifier())
	}
	return n
}

func (ptr *QPaintDeviceWindow) QPaintDeviceWindow_PTR() *QPaintDeviceWindow {
	return ptr
}

func (ptr *QPaintDeviceWindow) ConnectPaintEvent(f func(event *QPaintEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::paintEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "paintEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectPaintEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::paintEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "paintEvent")
	}
}

//export callbackQPaintDeviceWindowPaintEvent
func callbackQPaintDeviceWindowPaintEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::paintEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "paintEvent"); signal != nil {
		signal.(func(*QPaintEvent))(NewQPaintEventFromPointer(event))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).PaintEventDefault(NewQPaintEventFromPointer(event))
	}
}

func (ptr *QPaintDeviceWindow) PaintEvent(event QPaintEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::paintEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_PaintEvent(ptr.Pointer(), PointerFromQPaintEvent(event))
	}
}

func (ptr *QPaintDeviceWindow) PaintEventDefault(event QPaintEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::paintEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_PaintEventDefault(ptr.Pointer(), PointerFromQPaintEvent(event))
	}
}

func (ptr *QPaintDeviceWindow) Update3() {
	defer qt.Recovering("QPaintDeviceWindow::update")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_Update3(ptr.Pointer())
	}
}

func (ptr *QPaintDeviceWindow) Update(rect core.QRect_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::update")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_Update(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QPaintDeviceWindow) Update2(region QRegion_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::update")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_Update2(ptr.Pointer(), PointerFromQRegion(region))
	}
}

func (ptr *QPaintDeviceWindow) ConnectExposeEvent(f func(ev *QExposeEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::exposeEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "exposeEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectExposeEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::exposeEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "exposeEvent")
	}
}

//export callbackQPaintDeviceWindowExposeEvent
func callbackQPaintDeviceWindowExposeEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::exposeEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "exposeEvent"); signal != nil {
		signal.(func(*QExposeEvent))(NewQExposeEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).ExposeEventDefault(NewQExposeEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) ExposeEvent(ev QExposeEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::exposeEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_ExposeEvent(ptr.Pointer(), PointerFromQExposeEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ExposeEventDefault(ev QExposeEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::exposeEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_ExposeEventDefault(ptr.Pointer(), PointerFromQExposeEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectFocusInEvent(f func(ev *QFocusEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::focusInEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "focusInEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectFocusInEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::focusInEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "focusInEvent")
	}
}

//export callbackQPaintDeviceWindowFocusInEvent
func callbackQPaintDeviceWindowFocusInEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::focusInEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "focusInEvent"); signal != nil {
		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).FocusInEventDefault(NewQFocusEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) FocusInEvent(ev QFocusEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::focusInEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_FocusInEvent(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) FocusInEventDefault(ev QFocusEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::focusInEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_FocusInEventDefault(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectFocusOutEvent(f func(ev *QFocusEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::focusOutEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "focusOutEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectFocusOutEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::focusOutEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "focusOutEvent")
	}
}

//export callbackQPaintDeviceWindowFocusOutEvent
func callbackQPaintDeviceWindowFocusOutEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::focusOutEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "focusOutEvent"); signal != nil {
		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).FocusOutEventDefault(NewQFocusEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) FocusOutEvent(ev QFocusEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::focusOutEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_FocusOutEvent(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) FocusOutEventDefault(ev QFocusEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::focusOutEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_FocusOutEventDefault(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectHideEvent(f func(ev *QHideEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::hideEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "hideEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectHideEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::hideEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "hideEvent")
	}
}

//export callbackQPaintDeviceWindowHideEvent
func callbackQPaintDeviceWindowHideEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::hideEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "hideEvent"); signal != nil {
		signal.(func(*QHideEvent))(NewQHideEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).HideEventDefault(NewQHideEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) HideEvent(ev QHideEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::hideEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_HideEvent(ptr.Pointer(), PointerFromQHideEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) HideEventDefault(ev QHideEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::hideEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_HideEventDefault(ptr.Pointer(), PointerFromQHideEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectKeyPressEvent(f func(ev *QKeyEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::keyPressEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "keyPressEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectKeyPressEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::keyPressEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "keyPressEvent")
	}
}

//export callbackQPaintDeviceWindowKeyPressEvent
func callbackQPaintDeviceWindowKeyPressEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::keyPressEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "keyPressEvent"); signal != nil {
		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).KeyPressEventDefault(NewQKeyEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) KeyPressEvent(ev QKeyEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::keyPressEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_KeyPressEvent(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) KeyPressEventDefault(ev QKeyEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::keyPressEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_KeyPressEventDefault(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectKeyReleaseEvent(f func(ev *QKeyEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "keyReleaseEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectKeyReleaseEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "keyReleaseEvent")
	}
}

//export callbackQPaintDeviceWindowKeyReleaseEvent
func callbackQPaintDeviceWindowKeyReleaseEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::keyReleaseEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "keyReleaseEvent"); signal != nil {
		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).KeyReleaseEventDefault(NewQKeyEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) KeyReleaseEvent(ev QKeyEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_KeyReleaseEvent(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) KeyReleaseEventDefault(ev QKeyEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_KeyReleaseEventDefault(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectMouseDoubleClickEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectMouseDoubleClickEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent")
	}
}

//export callbackQPaintDeviceWindowMouseDoubleClickEvent
func callbackQPaintDeviceWindowMouseDoubleClickEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::mouseDoubleClickEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseDoubleClickEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).MouseDoubleClickEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) MouseDoubleClickEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MouseDoubleClickEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) MouseDoubleClickEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MouseDoubleClickEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectMouseMoveEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mouseMoveEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectMouseMoveEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mouseMoveEvent")
	}
}

//export callbackQPaintDeviceWindowMouseMoveEvent
func callbackQPaintDeviceWindowMouseMoveEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::mouseMoveEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseMoveEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).MouseMoveEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) MouseMoveEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MouseMoveEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) MouseMoveEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MouseMoveEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectMousePressEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::mousePressEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mousePressEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectMousePressEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::mousePressEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mousePressEvent")
	}
}

//export callbackQPaintDeviceWindowMousePressEvent
func callbackQPaintDeviceWindowMousePressEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::mousePressEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mousePressEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).MousePressEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) MousePressEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::mousePressEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MousePressEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) MousePressEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::mousePressEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MousePressEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectMouseReleaseEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mouseReleaseEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectMouseReleaseEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mouseReleaseEvent")
	}
}

//export callbackQPaintDeviceWindowMouseReleaseEvent
func callbackQPaintDeviceWindowMouseReleaseEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::mouseReleaseEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseReleaseEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).MouseReleaseEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) MouseReleaseEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MouseReleaseEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) MouseReleaseEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MouseReleaseEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectMoveEvent(f func(ev *QMoveEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::moveEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "moveEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectMoveEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::moveEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "moveEvent")
	}
}

//export callbackQPaintDeviceWindowMoveEvent
func callbackQPaintDeviceWindowMoveEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::moveEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "moveEvent"); signal != nil {
		signal.(func(*QMoveEvent))(NewQMoveEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).MoveEventDefault(NewQMoveEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) MoveEvent(ev QMoveEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::moveEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MoveEvent(ptr.Pointer(), PointerFromQMoveEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) MoveEventDefault(ev QMoveEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::moveEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_MoveEventDefault(ptr.Pointer(), PointerFromQMoveEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectResizeEvent(f func(ev *QResizeEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::resizeEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "resizeEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectResizeEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::resizeEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "resizeEvent")
	}
}

//export callbackQPaintDeviceWindowResizeEvent
func callbackQPaintDeviceWindowResizeEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::resizeEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "resizeEvent"); signal != nil {
		signal.(func(*QResizeEvent))(NewQResizeEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).ResizeEventDefault(NewQResizeEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) ResizeEvent(ev QResizeEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::resizeEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_ResizeEvent(ptr.Pointer(), PointerFromQResizeEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ResizeEventDefault(ev QResizeEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::resizeEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_ResizeEventDefault(ptr.Pointer(), PointerFromQResizeEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectShowEvent(f func(ev *QShowEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::showEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "showEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectShowEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::showEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "showEvent")
	}
}

//export callbackQPaintDeviceWindowShowEvent
func callbackQPaintDeviceWindowShowEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::showEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "showEvent"); signal != nil {
		signal.(func(*QShowEvent))(NewQShowEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).ShowEventDefault(NewQShowEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) ShowEvent(ev QShowEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::showEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_ShowEvent(ptr.Pointer(), PointerFromQShowEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ShowEventDefault(ev QShowEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::showEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_ShowEventDefault(ptr.Pointer(), PointerFromQShowEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectTabletEvent(f func(ev *QTabletEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::tabletEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "tabletEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectTabletEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::tabletEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "tabletEvent")
	}
}

//export callbackQPaintDeviceWindowTabletEvent
func callbackQPaintDeviceWindowTabletEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::tabletEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "tabletEvent"); signal != nil {
		signal.(func(*QTabletEvent))(NewQTabletEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).TabletEventDefault(NewQTabletEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) TabletEvent(ev QTabletEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::tabletEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_TabletEvent(ptr.Pointer(), PointerFromQTabletEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) TabletEventDefault(ev QTabletEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::tabletEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_TabletEventDefault(ptr.Pointer(), PointerFromQTabletEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectTouchEvent(f func(ev *QTouchEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::touchEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "touchEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectTouchEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::touchEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "touchEvent")
	}
}

//export callbackQPaintDeviceWindowTouchEvent
func callbackQPaintDeviceWindowTouchEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::touchEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "touchEvent"); signal != nil {
		signal.(func(*QTouchEvent))(NewQTouchEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).TouchEventDefault(NewQTouchEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) TouchEvent(ev QTouchEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::touchEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_TouchEvent(ptr.Pointer(), PointerFromQTouchEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) TouchEventDefault(ev QTouchEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::touchEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_TouchEventDefault(ptr.Pointer(), PointerFromQTouchEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectWheelEvent(f func(ev *QWheelEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::wheelEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "wheelEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectWheelEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::wheelEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "wheelEvent")
	}
}

//export callbackQPaintDeviceWindowWheelEvent
func callbackQPaintDeviceWindowWheelEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::wheelEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "wheelEvent"); signal != nil {
		signal.(func(*QWheelEvent))(NewQWheelEventFromPointer(ev))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).WheelEventDefault(NewQWheelEventFromPointer(ev))
	}
}

func (ptr *QPaintDeviceWindow) WheelEvent(ev QWheelEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::wheelEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_WheelEvent(ptr.Pointer(), PointerFromQWheelEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) WheelEventDefault(ev QWheelEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::wheelEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_WheelEventDefault(ptr.Pointer(), PointerFromQWheelEvent(ev))
	}
}

func (ptr *QPaintDeviceWindow) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQPaintDeviceWindowTimerEvent
func callbackQPaintDeviceWindowTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QPaintDeviceWindow) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::timerEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QPaintDeviceWindow) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::timerEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QPaintDeviceWindow) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQPaintDeviceWindowChildEvent
func callbackQPaintDeviceWindowChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QPaintDeviceWindow) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::childEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QPaintDeviceWindow) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::childEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QPaintDeviceWindow) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QPaintDeviceWindow::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QPaintDeviceWindow) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QPaintDeviceWindow::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQPaintDeviceWindowCustomEvent
func callbackQPaintDeviceWindowCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPaintDeviceWindow::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQPaintDeviceWindowFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QPaintDeviceWindow) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::customEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QPaintDeviceWindow) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QPaintDeviceWindow::customEvent")

	if ptr.Pointer() != nil {
		C.QPaintDeviceWindow_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QPaintEngine struct {
	ptr unsafe.Pointer
}

type QPaintEngine_ITF interface {
	QPaintEngine_PTR() *QPaintEngine
}

func (p *QPaintEngine) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPaintEngine) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPaintEngine(ptr QPaintEngine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPaintEngine_PTR().Pointer()
	}
	return nil
}

func NewQPaintEngineFromPointer(ptr unsafe.Pointer) *QPaintEngine {
	var n = new(QPaintEngine)
	n.SetPointer(ptr)
	return n
}

func newQPaintEngineFromPointer(ptr unsafe.Pointer) *QPaintEngine {
	var n = NewQPaintEngineFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QPaintEngine_") {
		n.SetObjectNameAbs("QPaintEngine_" + qt.Identifier())
	}
	return n
}

func (ptr *QPaintEngine) QPaintEngine_PTR() *QPaintEngine {
	return ptr
}

//QPaintEngine::DirtyFlag
type QPaintEngine__DirtyFlag int64

const (
	QPaintEngine__DirtyPen             = QPaintEngine__DirtyFlag(0x0001)
	QPaintEngine__DirtyBrush           = QPaintEngine__DirtyFlag(0x0002)
	QPaintEngine__DirtyBrushOrigin     = QPaintEngine__DirtyFlag(0x0004)
	QPaintEngine__DirtyFont            = QPaintEngine__DirtyFlag(0x0008)
	QPaintEngine__DirtyBackground      = QPaintEngine__DirtyFlag(0x0010)
	QPaintEngine__DirtyBackgroundMode  = QPaintEngine__DirtyFlag(0x0020)
	QPaintEngine__DirtyTransform       = QPaintEngine__DirtyFlag(0x0040)
	QPaintEngine__DirtyClipRegion      = QPaintEngine__DirtyFlag(0x0080)
	QPaintEngine__DirtyClipPath        = QPaintEngine__DirtyFlag(0x0100)
	QPaintEngine__DirtyHints           = QPaintEngine__DirtyFlag(0x0200)
	QPaintEngine__DirtyCompositionMode = QPaintEngine__DirtyFlag(0x0400)
	QPaintEngine__DirtyClipEnabled     = QPaintEngine__DirtyFlag(0x0800)
	QPaintEngine__DirtyOpacity         = QPaintEngine__DirtyFlag(0x1000)
	QPaintEngine__AllDirty             = QPaintEngine__DirtyFlag(0xffff)
)

//QPaintEngine::PaintEngineFeature
type QPaintEngine__PaintEngineFeature int64

const (
	QPaintEngine__PrimitiveTransform          = QPaintEngine__PaintEngineFeature(0x00000001)
	QPaintEngine__PatternTransform            = QPaintEngine__PaintEngineFeature(0x00000002)
	QPaintEngine__PixmapTransform             = QPaintEngine__PaintEngineFeature(0x00000004)
	QPaintEngine__PatternBrush                = QPaintEngine__PaintEngineFeature(0x00000008)
	QPaintEngine__LinearGradientFill          = QPaintEngine__PaintEngineFeature(0x00000010)
	QPaintEngine__RadialGradientFill          = QPaintEngine__PaintEngineFeature(0x00000020)
	QPaintEngine__ConicalGradientFill         = QPaintEngine__PaintEngineFeature(0x00000040)
	QPaintEngine__AlphaBlend                  = QPaintEngine__PaintEngineFeature(0x00000080)
	QPaintEngine__PorterDuff                  = QPaintEngine__PaintEngineFeature(0x00000100)
	QPaintEngine__PainterPaths                = QPaintEngine__PaintEngineFeature(0x00000200)
	QPaintEngine__Antialiasing                = QPaintEngine__PaintEngineFeature(0x00000400)
	QPaintEngine__BrushStroke                 = QPaintEngine__PaintEngineFeature(0x00000800)
	QPaintEngine__ConstantOpacity             = QPaintEngine__PaintEngineFeature(0x00001000)
	QPaintEngine__MaskedBrush                 = QPaintEngine__PaintEngineFeature(0x00002000)
	QPaintEngine__PerspectiveTransform        = QPaintEngine__PaintEngineFeature(0x00004000)
	QPaintEngine__BlendModes                  = QPaintEngine__PaintEngineFeature(0x00008000)
	QPaintEngine__ObjectBoundingModeGradients = QPaintEngine__PaintEngineFeature(0x00010000)
	QPaintEngine__RasterOpModes               = QPaintEngine__PaintEngineFeature(0x00020000)
	QPaintEngine__PaintOutsidePaintEvent      = QPaintEngine__PaintEngineFeature(0x20000000)
	QPaintEngine__AllFeatures                 = QPaintEngine__PaintEngineFeature(0xffffffff)
)

//QPaintEngine::PolygonDrawMode
type QPaintEngine__PolygonDrawMode int64

const (
	QPaintEngine__OddEvenMode  = QPaintEngine__PolygonDrawMode(0)
	QPaintEngine__WindingMode  = QPaintEngine__PolygonDrawMode(1)
	QPaintEngine__ConvexMode   = QPaintEngine__PolygonDrawMode(2)
	QPaintEngine__PolylineMode = QPaintEngine__PolygonDrawMode(3)
)

//QPaintEngine::Type
type QPaintEngine__Type int64

const (
	QPaintEngine__X11           = QPaintEngine__Type(0)
	QPaintEngine__Windows       = QPaintEngine__Type(1)
	QPaintEngine__QuickDraw     = QPaintEngine__Type(2)
	QPaintEngine__CoreGraphics  = QPaintEngine__Type(3)
	QPaintEngine__MacPrinter    = QPaintEngine__Type(4)
	QPaintEngine__QWindowSystem = QPaintEngine__Type(5)
	QPaintEngine__PostScript    = QPaintEngine__Type(6)
	QPaintEngine__OpenGL        = QPaintEngine__Type(7)
	QPaintEngine__Picture       = QPaintEngine__Type(8)
	QPaintEngine__SVG           = QPaintEngine__Type(9)
	QPaintEngine__Raster        = QPaintEngine__Type(10)
	QPaintEngine__Direct3D      = QPaintEngine__Type(11)
	QPaintEngine__Pdf           = QPaintEngine__Type(12)
	QPaintEngine__OpenVG        = QPaintEngine__Type(13)
	QPaintEngine__OpenGL2       = QPaintEngine__Type(14)
	QPaintEngine__PaintBuffer   = QPaintEngine__Type(15)
	QPaintEngine__Blitter       = QPaintEngine__Type(16)
	QPaintEngine__Direct2D      = QPaintEngine__Type(17)
	QPaintEngine__User          = QPaintEngine__Type(50)
	QPaintEngine__MaxUser       = QPaintEngine__Type(100)
)

func (ptr *QPaintEngine) ConnectDrawPolygon(f func(points *core.QPointF, pointCount int, mode QPaintEngine__PolygonDrawMode)) {
	defer qt.Recovering("connect QPaintEngine::drawPolygon")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectNameAbs(), "drawPolygon", f)
	}
}

func (ptr *QPaintEngine) DisconnectDrawPolygon() {
	defer qt.Recovering("disconnect QPaintEngine::drawPolygon")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectNameAbs(), "drawPolygon")
	}
}

//export callbackQPaintEngineDrawPolygon
func callbackQPaintEngineDrawPolygon(ptr unsafe.Pointer, ptrName *C.char, points unsafe.Pointer, pointCount C.int, mode C.int) {
	defer qt.Recovering("callback QPaintEngine::drawPolygon")

	if signal := qt.GetSignal(C.GoString(ptrName), "drawPolygon"); signal != nil {
		signal.(func(*core.QPointF, int, QPaintEngine__PolygonDrawMode))(core.NewQPointFFromPointer(points), int(pointCount), QPaintEngine__PolygonDrawMode(mode))
	} else {
		NewQPaintEngineFromPointer(ptr).DrawPolygonDefault(core.NewQPointFFromPointer(points), int(pointCount), QPaintEngine__PolygonDrawMode(mode))
	}
}

func (ptr *QPaintEngine) DrawPolygon(points core.QPointF_ITF, pointCount int, mode QPaintEngine__PolygonDrawMode) {
	defer qt.Recovering("QPaintEngine::drawPolygon")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DrawPolygon(ptr.Pointer(), core.PointerFromQPointF(points), C.int(pointCount), C.int(mode))
	}
}

func (ptr *QPaintEngine) DrawPolygonDefault(points core.QPointF_ITF, pointCount int, mode QPaintEngine__PolygonDrawMode) {
	defer qt.Recovering("QPaintEngine::drawPolygon")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DrawPolygonDefault(ptr.Pointer(), core.PointerFromQPointF(points), C.int(pointCount), C.int(mode))
	}
}

func (ptr *QPaintEngine) Begin(pdev QPaintDevice_ITF) bool {
	defer qt.Recovering("QPaintEngine::begin")

	if ptr.Pointer() != nil {
		return C.QPaintEngine_Begin(ptr.Pointer(), PointerFromQPaintDevice(pdev)) != 0
	}
	return false
}

func (ptr *QPaintEngine) ConnectDrawLines(f func(lines *core.QLineF, lineCount int)) {
	defer qt.Recovering("connect QPaintEngine::drawLines")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectNameAbs(), "drawLines", f)
	}
}

func (ptr *QPaintEngine) DisconnectDrawLines() {
	defer qt.Recovering("disconnect QPaintEngine::drawLines")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectNameAbs(), "drawLines")
	}
}

//export callbackQPaintEngineDrawLines
func callbackQPaintEngineDrawLines(ptr unsafe.Pointer, ptrName *C.char, lines unsafe.Pointer, lineCount C.int) {
	defer qt.Recovering("callback QPaintEngine::drawLines")

	if signal := qt.GetSignal(C.GoString(ptrName), "drawLines"); signal != nil {
		signal.(func(*core.QLineF, int))(core.NewQLineFFromPointer(lines), int(lineCount))
	} else {
		NewQPaintEngineFromPointer(ptr).DrawLinesDefault(core.NewQLineFFromPointer(lines), int(lineCount))
	}
}

func (ptr *QPaintEngine) DrawLines(lines core.QLineF_ITF, lineCount int) {
	defer qt.Recovering("QPaintEngine::drawLines")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DrawLines(ptr.Pointer(), core.PointerFromQLineF(lines), C.int(lineCount))
	}
}

func (ptr *QPaintEngine) DrawLinesDefault(lines core.QLineF_ITF, lineCount int) {
	defer qt.Recovering("QPaintEngine::drawLines")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DrawLinesDefault(ptr.Pointer(), core.PointerFromQLineF(lines), C.int(lineCount))
	}
}

func (ptr *QPaintEngine) DrawPixmap(r core.QRectF_ITF, pm QPixmap_ITF, sr core.QRectF_ITF) {
	defer qt.Recovering("QPaintEngine::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DrawPixmap(ptr.Pointer(), core.PointerFromQRectF(r), PointerFromQPixmap(pm), core.PointerFromQRectF(sr))
	}
}

func (ptr *QPaintEngine) ConnectDrawPoints(f func(points *core.QPointF, pointCount int)) {
	defer qt.Recovering("connect QPaintEngine::drawPoints")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectNameAbs(), "drawPoints", f)
	}
}

func (ptr *QPaintEngine) DisconnectDrawPoints() {
	defer qt.Recovering("disconnect QPaintEngine::drawPoints")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectNameAbs(), "drawPoints")
	}
}

//export callbackQPaintEngineDrawPoints
func callbackQPaintEngineDrawPoints(ptr unsafe.Pointer, ptrName *C.char, points unsafe.Pointer, pointCount C.int) {
	defer qt.Recovering("callback QPaintEngine::drawPoints")

	if signal := qt.GetSignal(C.GoString(ptrName), "drawPoints"); signal != nil {
		signal.(func(*core.QPointF, int))(core.NewQPointFFromPointer(points), int(pointCount))
	} else {
		NewQPaintEngineFromPointer(ptr).DrawPointsDefault(core.NewQPointFFromPointer(points), int(pointCount))
	}
}

func (ptr *QPaintEngine) DrawPoints(points core.QPointF_ITF, pointCount int) {
	defer qt.Recovering("QPaintEngine::drawPoints")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DrawPoints(ptr.Pointer(), core.PointerFromQPointF(points), C.int(pointCount))
	}
}

func (ptr *QPaintEngine) DrawPointsDefault(points core.QPointF_ITF, pointCount int) {
	defer qt.Recovering("QPaintEngine::drawPoints")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DrawPointsDefault(ptr.Pointer(), core.PointerFromQPointF(points), C.int(pointCount))
	}
}

func (ptr *QPaintEngine) ConnectDrawRects(f func(rects *core.QRectF, rectCount int)) {
	defer qt.Recovering("connect QPaintEngine::drawRects")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectNameAbs(), "drawRects", f)
	}
}

func (ptr *QPaintEngine) DisconnectDrawRects() {
	defer qt.Recovering("disconnect QPaintEngine::drawRects")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectNameAbs(), "drawRects")
	}
}

//export callbackQPaintEngineDrawRects
func callbackQPaintEngineDrawRects(ptr unsafe.Pointer, ptrName *C.char, rects unsafe.Pointer, rectCount C.int) {
	defer qt.Recovering("callback QPaintEngine::drawRects")

	if signal := qt.GetSignal(C.GoString(ptrName), "drawRects"); signal != nil {
		signal.(func(*core.QRectF, int))(core.NewQRectFFromPointer(rects), int(rectCount))
	} else {
		NewQPaintEngineFromPointer(ptr).DrawRectsDefault(core.NewQRectFFromPointer(rects), int(rectCount))
	}
}

func (ptr *QPaintEngine) DrawRects(rects core.QRectF_ITF, rectCount int) {
	defer qt.Recovering("QPaintEngine::drawRects")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DrawRects(ptr.Pointer(), core.PointerFromQRectF(rects), C.int(rectCount))
	}
}

func (ptr *QPaintEngine) DrawRectsDefault(rects core.QRectF_ITF, rectCount int) {
	defer qt.Recovering("QPaintEngine::drawRects")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DrawRectsDefault(ptr.Pointer(), core.PointerFromQRectF(rects), C.int(rectCount))
	}
}

func (ptr *QPaintEngine) End() bool {
	defer qt.Recovering("QPaintEngine::end")

	if ptr.Pointer() != nil {
		return C.QPaintEngine_End(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPaintEngine) HasFeature(feature QPaintEngine__PaintEngineFeature) bool {
	defer qt.Recovering("QPaintEngine::hasFeature")

	if ptr.Pointer() != nil {
		return C.QPaintEngine_HasFeature(ptr.Pointer(), C.int(feature)) != 0
	}
	return false
}

func (ptr *QPaintEngine) IsActive() bool {
	defer qt.Recovering("QPaintEngine::isActive")

	if ptr.Pointer() != nil {
		return C.QPaintEngine_IsActive(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPaintEngine) PaintDevice() *QPaintDevice {
	defer qt.Recovering("QPaintEngine::paintDevice")

	if ptr.Pointer() != nil {
		return NewQPaintDeviceFromPointer(C.QPaintEngine_PaintDevice(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPaintEngine) Painter() *QPainter {
	defer qt.Recovering("QPaintEngine::painter")

	if ptr.Pointer() != nil {
		return NewQPainterFromPointer(C.QPaintEngine_Painter(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPaintEngine) SetActive(state bool) {
	defer qt.Recovering("QPaintEngine::setActive")

	if ptr.Pointer() != nil {
		C.QPaintEngine_SetActive(ptr.Pointer(), C.int(qt.GoBoolToInt(state)))
	}
}

func (ptr *QPaintEngine) Type() QPaintEngine__Type {
	defer qt.Recovering("QPaintEngine::type")

	if ptr.Pointer() != nil {
		return QPaintEngine__Type(C.QPaintEngine_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintEngine) UpdateState(state QPaintEngineState_ITF) {
	defer qt.Recovering("QPaintEngine::updateState")

	if ptr.Pointer() != nil {
		C.QPaintEngine_UpdateState(ptr.Pointer(), PointerFromQPaintEngineState(state))
	}
}

func (ptr *QPaintEngine) DestroyQPaintEngine() {
	defer qt.Recovering("QPaintEngine::~QPaintEngine")

	if ptr.Pointer() != nil {
		C.QPaintEngine_DestroyQPaintEngine(ptr.Pointer())
	}
}

func (ptr *QPaintEngine) ObjectNameAbs() string {
	defer qt.Recovering("QPaintEngine::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPaintEngine_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPaintEngine) SetObjectNameAbs(name string) {
	defer qt.Recovering("QPaintEngine::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QPaintEngine_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QPaintEngineState struct {
	ptr unsafe.Pointer
}

type QPaintEngineState_ITF interface {
	QPaintEngineState_PTR() *QPaintEngineState
}

func (p *QPaintEngineState) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPaintEngineState) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPaintEngineState(ptr QPaintEngineState_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPaintEngineState_PTR().Pointer()
	}
	return nil
}

func NewQPaintEngineStateFromPointer(ptr unsafe.Pointer) *QPaintEngineState {
	var n = new(QPaintEngineState)
	n.SetPointer(ptr)
	return n
}

func newQPaintEngineStateFromPointer(ptr unsafe.Pointer) *QPaintEngineState {
	var n = NewQPaintEngineStateFromPointer(ptr)
	return n
}

func (ptr *QPaintEngineState) QPaintEngineState_PTR() *QPaintEngineState {
	return ptr
}

func (ptr *QPaintEngineState) BackgroundBrush() *QBrush {
	defer qt.Recovering("QPaintEngineState::backgroundBrush")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPaintEngineState_BackgroundBrush(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPaintEngineState) BackgroundMode() core.Qt__BGMode {
	defer qt.Recovering("QPaintEngineState::backgroundMode")

	if ptr.Pointer() != nil {
		return core.Qt__BGMode(C.QPaintEngineState_BackgroundMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintEngineState) Brush() *QBrush {
	defer qt.Recovering("QPaintEngineState::brush")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPaintEngineState_Brush(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPaintEngineState) BrushNeedsResolving() bool {
	defer qt.Recovering("QPaintEngineState::brushNeedsResolving")

	if ptr.Pointer() != nil {
		return C.QPaintEngineState_BrushNeedsResolving(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPaintEngineState) ClipOperation() core.Qt__ClipOperation {
	defer qt.Recovering("QPaintEngineState::clipOperation")

	if ptr.Pointer() != nil {
		return core.Qt__ClipOperation(C.QPaintEngineState_ClipOperation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintEngineState) ClipRegion() *QRegion {
	defer qt.Recovering("QPaintEngineState::clipRegion")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QPaintEngineState_ClipRegion(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPaintEngineState) CompositionMode() QPainter__CompositionMode {
	defer qt.Recovering("QPaintEngineState::compositionMode")

	if ptr.Pointer() != nil {
		return QPainter__CompositionMode(C.QPaintEngineState_CompositionMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintEngineState) IsClipEnabled() bool {
	defer qt.Recovering("QPaintEngineState::isClipEnabled")

	if ptr.Pointer() != nil {
		return C.QPaintEngineState_IsClipEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPaintEngineState) Opacity() float64 {
	defer qt.Recovering("QPaintEngineState::opacity")

	if ptr.Pointer() != nil {
		return float64(C.QPaintEngineState_Opacity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintEngineState) Painter() *QPainter {
	defer qt.Recovering("QPaintEngineState::painter")

	if ptr.Pointer() != nil {
		return NewQPainterFromPointer(C.QPaintEngineState_Painter(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPaintEngineState) PenNeedsResolving() bool {
	defer qt.Recovering("QPaintEngineState::penNeedsResolving")

	if ptr.Pointer() != nil {
		return C.QPaintEngineState_PenNeedsResolving(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPaintEngineState) RenderHints() QPainter__RenderHint {
	defer qt.Recovering("QPaintEngineState::renderHints")

	if ptr.Pointer() != nil {
		return QPainter__RenderHint(C.QPaintEngineState_RenderHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPaintEngineState) State() QPaintEngine__DirtyFlag {
	defer qt.Recovering("QPaintEngineState::state")

	if ptr.Pointer() != nil {
		return QPaintEngine__DirtyFlag(C.QPaintEngineState_State(ptr.Pointer()))
	}
	return 0
}

type QPaintEvent struct {
	core.QEvent
}

type QPaintEvent_ITF interface {
	core.QEvent_ITF
	QPaintEvent_PTR() *QPaintEvent
}

func PointerFromQPaintEvent(ptr QPaintEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPaintEvent_PTR().Pointer()
	}
	return nil
}

func NewQPaintEventFromPointer(ptr unsafe.Pointer) *QPaintEvent {
	var n = new(QPaintEvent)
	n.SetPointer(ptr)
	return n
}

func newQPaintEventFromPointer(ptr unsafe.Pointer) *QPaintEvent {
	var n = NewQPaintEventFromPointer(ptr)
	return n
}

func (ptr *QPaintEvent) QPaintEvent_PTR() *QPaintEvent {
	return ptr
}

func NewQPaintEvent2(paintRect core.QRect_ITF) *QPaintEvent {
	defer qt.Recovering("QPaintEvent::QPaintEvent")

	return newQPaintEventFromPointer(C.QPaintEvent_NewQPaintEvent2(core.PointerFromQRect(paintRect)))
}

func NewQPaintEvent(paintRegion QRegion_ITF) *QPaintEvent {
	defer qt.Recovering("QPaintEvent::QPaintEvent")

	return newQPaintEventFromPointer(C.QPaintEvent_NewQPaintEvent(PointerFromQRegion(paintRegion)))
}

func (ptr *QPaintEvent) Rect() *core.QRect {
	defer qt.Recovering("QPaintEvent::rect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPaintEvent_Rect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPaintEvent) Region() *QRegion {
	defer qt.Recovering("QPaintEvent::region")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QPaintEvent_Region(ptr.Pointer()))
	}
	return nil
}

type QPainter struct {
	ptr unsafe.Pointer
}

type QPainter_ITF interface {
	QPainter_PTR() *QPainter
}

func (p *QPainter) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPainter) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPainter(ptr QPainter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPainter_PTR().Pointer()
	}
	return nil
}

func NewQPainterFromPointer(ptr unsafe.Pointer) *QPainter {
	var n = new(QPainter)
	n.SetPointer(ptr)
	return n
}

func newQPainterFromPointer(ptr unsafe.Pointer) *QPainter {
	var n = NewQPainterFromPointer(ptr)
	return n
}

func (ptr *QPainter) QPainter_PTR() *QPainter {
	return ptr
}

//QPainter::CompositionMode
type QPainter__CompositionMode int64

const (
	QPainter__CompositionMode_SourceOver          = QPainter__CompositionMode(0)
	QPainter__CompositionMode_DestinationOver     = QPainter__CompositionMode(1)
	QPainter__CompositionMode_Clear               = QPainter__CompositionMode(2)
	QPainter__CompositionMode_Source              = QPainter__CompositionMode(3)
	QPainter__CompositionMode_Destination         = QPainter__CompositionMode(4)
	QPainter__CompositionMode_SourceIn            = QPainter__CompositionMode(5)
	QPainter__CompositionMode_DestinationIn       = QPainter__CompositionMode(6)
	QPainter__CompositionMode_SourceOut           = QPainter__CompositionMode(7)
	QPainter__CompositionMode_DestinationOut      = QPainter__CompositionMode(8)
	QPainter__CompositionMode_SourceAtop          = QPainter__CompositionMode(9)
	QPainter__CompositionMode_DestinationAtop     = QPainter__CompositionMode(10)
	QPainter__CompositionMode_Xor                 = QPainter__CompositionMode(11)
	QPainter__CompositionMode_Plus                = QPainter__CompositionMode(12)
	QPainter__CompositionMode_Multiply            = QPainter__CompositionMode(13)
	QPainter__CompositionMode_Screen              = QPainter__CompositionMode(14)
	QPainter__CompositionMode_Overlay             = QPainter__CompositionMode(15)
	QPainter__CompositionMode_Darken              = QPainter__CompositionMode(16)
	QPainter__CompositionMode_Lighten             = QPainter__CompositionMode(17)
	QPainter__CompositionMode_ColorDodge          = QPainter__CompositionMode(18)
	QPainter__CompositionMode_ColorBurn           = QPainter__CompositionMode(19)
	QPainter__CompositionMode_HardLight           = QPainter__CompositionMode(20)
	QPainter__CompositionMode_SoftLight           = QPainter__CompositionMode(21)
	QPainter__CompositionMode_Difference          = QPainter__CompositionMode(22)
	QPainter__CompositionMode_Exclusion           = QPainter__CompositionMode(23)
	QPainter__RasterOp_SourceOrDestination        = QPainter__CompositionMode(24)
	QPainter__RasterOp_SourceAndDestination       = QPainter__CompositionMode(25)
	QPainter__RasterOp_SourceXorDestination       = QPainter__CompositionMode(26)
	QPainter__RasterOp_NotSourceAndNotDestination = QPainter__CompositionMode(27)
	QPainter__RasterOp_NotSourceOrNotDestination  = QPainter__CompositionMode(28)
	QPainter__RasterOp_NotSourceXorDestination    = QPainter__CompositionMode(29)
	QPainter__RasterOp_NotSource                  = QPainter__CompositionMode(30)
	QPainter__RasterOp_NotSourceAndDestination    = QPainter__CompositionMode(31)
	QPainter__RasterOp_SourceAndNotDestination    = QPainter__CompositionMode(32)
	QPainter__RasterOp_NotSourceOrDestination     = QPainter__CompositionMode(33)
	QPainter__RasterOp_SourceOrNotDestination     = QPainter__CompositionMode(34)
	QPainter__RasterOp_ClearDestination           = QPainter__CompositionMode(35)
	QPainter__RasterOp_SetDestination             = QPainter__CompositionMode(36)
	QPainter__RasterOp_NotDestination             = QPainter__CompositionMode(37)
)

//QPainter::PixmapFragmentHint
type QPainter__PixmapFragmentHint int64

const (
	QPainter__OpaqueHint = QPainter__PixmapFragmentHint(0x01)
)

//QPainter::RenderHint
type QPainter__RenderHint int64

const (
	QPainter__Antialiasing            = QPainter__RenderHint(0x01)
	QPainter__TextAntialiasing        = QPainter__RenderHint(0x02)
	QPainter__SmoothPixmapTransform   = QPainter__RenderHint(0x04)
	QPainter__HighQualityAntialiasing = QPainter__RenderHint(0x08)
	QPainter__NonCosmeticDefaultPen   = QPainter__RenderHint(0x10)
	QPainter__Qt4CompatiblePainting   = QPainter__RenderHint(0x20)
)

func NewQPainter2(device QPaintDevice_ITF) *QPainter {
	defer qt.Recovering("QPainter::QPainter")

	return newQPainterFromPointer(C.QPainter_NewQPainter2(PointerFromQPaintDevice(device)))
}

func (ptr *QPainter) Begin(device QPaintDevice_ITF) bool {
	defer qt.Recovering("QPainter::begin")

	if ptr.Pointer() != nil {
		return C.QPainter_Begin(ptr.Pointer(), PointerFromQPaintDevice(device)) != 0
	}
	return false
}

func (ptr *QPainter) BoundingRect2(rectangle core.QRect_ITF, flags int, text string) *core.QRect {
	defer qt.Recovering("QPainter::boundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPainter_BoundingRect2(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(flags), C.CString(text)))
	}
	return nil
}

func (ptr *QPainter) DrawArc(rectangle core.QRectF_ITF, startAngle int, spanAngle int) {
	defer qt.Recovering("QPainter::drawArc")

	if ptr.Pointer() != nil {
		C.QPainter_DrawArc(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.int(startAngle), C.int(spanAngle))
	}
}

func (ptr *QPainter) DrawChord(rectangle core.QRectF_ITF, startAngle int, spanAngle int) {
	defer qt.Recovering("QPainter::drawChord")

	if ptr.Pointer() != nil {
		C.QPainter_DrawChord(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.int(startAngle), C.int(spanAngle))
	}
}

func (ptr *QPainter) DrawConvexPolygon2(points core.QPoint_ITF, pointCount int) {
	defer qt.Recovering("QPainter::drawConvexPolygon")

	if ptr.Pointer() != nil {
		C.QPainter_DrawConvexPolygon2(ptr.Pointer(), core.PointerFromQPoint(points), C.int(pointCount))
	}
}

func (ptr *QPainter) DrawConvexPolygon(points core.QPointF_ITF, pointCount int) {
	defer qt.Recovering("QPainter::drawConvexPolygon")

	if ptr.Pointer() != nil {
		C.QPainter_DrawConvexPolygon(ptr.Pointer(), core.PointerFromQPointF(points), C.int(pointCount))
	}
}

func (ptr *QPainter) DrawEllipse2(rectangle core.QRect_ITF) {
	defer qt.Recovering("QPainter::drawEllipse")

	if ptr.Pointer() != nil {
		C.QPainter_DrawEllipse2(ptr.Pointer(), core.PointerFromQRect(rectangle))
	}
}

func (ptr *QPainter) DrawEllipse(rectangle core.QRectF_ITF) {
	defer qt.Recovering("QPainter::drawEllipse")

	if ptr.Pointer() != nil {
		C.QPainter_DrawEllipse(ptr.Pointer(), core.PointerFromQRectF(rectangle))
	}
}

func (ptr *QPainter) DrawGlyphRun(position core.QPointF_ITF, glyphs QGlyphRun_ITF) {
	defer qt.Recovering("QPainter::drawGlyphRun")

	if ptr.Pointer() != nil {
		C.QPainter_DrawGlyphRun(ptr.Pointer(), core.PointerFromQPointF(position), PointerFromQGlyphRun(glyphs))
	}
}

func (ptr *QPainter) DrawImage3(point core.QPointF_ITF, image QImage_ITF) {
	defer qt.Recovering("QPainter::drawImage")

	if ptr.Pointer() != nil {
		C.QPainter_DrawImage3(ptr.Pointer(), core.PointerFromQPointF(point), PointerFromQImage(image))
	}
}

func (ptr *QPainter) DrawImage(target core.QRectF_ITF, image QImage_ITF, source core.QRectF_ITF, flags core.Qt__ImageConversionFlag) {
	defer qt.Recovering("QPainter::drawImage")

	if ptr.Pointer() != nil {
		C.QPainter_DrawImage(ptr.Pointer(), core.PointerFromQRectF(target), PointerFromQImage(image), core.PointerFromQRectF(source), C.int(flags))
	}
}

func (ptr *QPainter) DrawLines2(lines core.QLine_ITF, lineCount int) {
	defer qt.Recovering("QPainter::drawLines")

	if ptr.Pointer() != nil {
		C.QPainter_DrawLines2(ptr.Pointer(), core.PointerFromQLine(lines), C.int(lineCount))
	}
}

func (ptr *QPainter) DrawPicture(point core.QPointF_ITF, picture QPicture_ITF) {
	defer qt.Recovering("QPainter::drawPicture")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPicture(ptr.Pointer(), core.PointerFromQPointF(point), PointerFromQPicture(picture))
	}
}

func (ptr *QPainter) DrawPie(rectangle core.QRectF_ITF, startAngle int, spanAngle int) {
	defer qt.Recovering("QPainter::drawPie")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPie(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.int(startAngle), C.int(spanAngle))
	}
}

func (ptr *QPainter) DrawPixmap5(point core.QPointF_ITF, pixmap QPixmap_ITF) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap5(ptr.Pointer(), core.PointerFromQPointF(point), PointerFromQPixmap(pixmap))
	}
}

func (ptr *QPainter) DrawPixmap(target core.QRectF_ITF, pixmap QPixmap_ITF, source core.QRectF_ITF) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap(ptr.Pointer(), core.PointerFromQRectF(target), PointerFromQPixmap(pixmap), core.PointerFromQRectF(source))
	}
}

func (ptr *QPainter) DrawRects2(rectangles core.QRect_ITF, rectCount int) {
	defer qt.Recovering("QPainter::drawRects")

	if ptr.Pointer() != nil {
		C.QPainter_DrawRects2(ptr.Pointer(), core.PointerFromQRect(rectangles), C.int(rectCount))
	}
}

func (ptr *QPainter) DrawRects(rectangles core.QRectF_ITF, rectCount int) {
	defer qt.Recovering("QPainter::drawRects")

	if ptr.Pointer() != nil {
		C.QPainter_DrawRects(ptr.Pointer(), core.PointerFromQRectF(rectangles), C.int(rectCount))
	}
}

func (ptr *QPainter) DrawText(position core.QPointF_ITF, text string) {
	defer qt.Recovering("QPainter::drawText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawText(ptr.Pointer(), core.PointerFromQPointF(position), C.CString(text))
	}
}

func (ptr *QPainter) DrawText5(rectangle core.QRect_ITF, flags int, text string, boundingRect core.QRect_ITF) {
	defer qt.Recovering("QPainter::drawText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawText5(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(flags), C.CString(text), core.PointerFromQRect(boundingRect))
	}
}

func (ptr *QPainter) DrawText8(rectangle core.QRectF_ITF, text string, option QTextOption_ITF) {
	defer qt.Recovering("QPainter::drawText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawText8(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.CString(text), PointerFromQTextOption(option))
	}
}

func (ptr *QPainter) DrawText4(rectangle core.QRectF_ITF, flags int, text string, boundingRect core.QRectF_ITF) {
	defer qt.Recovering("QPainter::drawText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawText4(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.int(flags), C.CString(text), core.PointerFromQRectF(boundingRect))
	}
}

func (ptr *QPainter) DrawTiledPixmap(rectangle core.QRectF_ITF, pixmap QPixmap_ITF, position core.QPointF_ITF) {
	defer qt.Recovering("QPainter::drawTiledPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawTiledPixmap(ptr.Pointer(), core.PointerFromQRectF(rectangle), PointerFromQPixmap(pixmap), core.PointerFromQPointF(position))
	}
}

func (ptr *QPainter) EraseRect(rectangle core.QRectF_ITF) {
	defer qt.Recovering("QPainter::eraseRect")

	if ptr.Pointer() != nil {
		C.QPainter_EraseRect(ptr.Pointer(), core.PointerFromQRectF(rectangle))
	}
}

func (ptr *QPainter) FillRect5(rectangle core.QRect_ITF, brush QBrush_ITF) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect5(ptr.Pointer(), core.PointerFromQRect(rectangle), PointerFromQBrush(brush))
	}
}

func (ptr *QPainter) FillRect6(rectangle core.QRect_ITF, color QColor_ITF) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect6(ptr.Pointer(), core.PointerFromQRect(rectangle), PointerFromQColor(color))
	}
}

func (ptr *QPainter) FillRect(rectangle core.QRectF_ITF, brush QBrush_ITF) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect(ptr.Pointer(), core.PointerFromQRectF(rectangle), PointerFromQBrush(brush))
	}
}

func (ptr *QPainter) FillRect7(rectangle core.QRectF_ITF, color QColor_ITF) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect7(ptr.Pointer(), core.PointerFromQRectF(rectangle), PointerFromQColor(color))
	}
}

func (ptr *QPainter) Rotate(angle float64) {
	defer qt.Recovering("QPainter::rotate")

	if ptr.Pointer() != nil {
		C.QPainter_Rotate(ptr.Pointer(), C.double(angle))
	}
}

func (ptr *QPainter) SetBackground(brush QBrush_ITF) {
	defer qt.Recovering("QPainter::setBackground")

	if ptr.Pointer() != nil {
		C.QPainter_SetBackground(ptr.Pointer(), PointerFromQBrush(brush))
	}
}

func (ptr *QPainter) SetBrushOrigin(position core.QPointF_ITF) {
	defer qt.Recovering("QPainter::setBrushOrigin")

	if ptr.Pointer() != nil {
		C.QPainter_SetBrushOrigin(ptr.Pointer(), core.PointerFromQPointF(position))
	}
}

func (ptr *QPainter) SetClipPath(path QPainterPath_ITF, operation core.Qt__ClipOperation) {
	defer qt.Recovering("QPainter::setClipPath")

	if ptr.Pointer() != nil {
		C.QPainter_SetClipPath(ptr.Pointer(), PointerFromQPainterPath(path), C.int(operation))
	}
}

func (ptr *QPainter) SetClipRect3(rectangle core.QRect_ITF, operation core.Qt__ClipOperation) {
	defer qt.Recovering("QPainter::setClipRect")

	if ptr.Pointer() != nil {
		C.QPainter_SetClipRect3(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(operation))
	}
}

func (ptr *QPainter) SetClipRect(rectangle core.QRectF_ITF, operation core.Qt__ClipOperation) {
	defer qt.Recovering("QPainter::setClipRect")

	if ptr.Pointer() != nil {
		C.QPainter_SetClipRect(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.int(operation))
	}
}

func (ptr *QPainter) SetClipRegion(region QRegion_ITF, operation core.Qt__ClipOperation) {
	defer qt.Recovering("QPainter::setClipRegion")

	if ptr.Pointer() != nil {
		C.QPainter_SetClipRegion(ptr.Pointer(), PointerFromQRegion(region), C.int(operation))
	}
}

func (ptr *QPainter) SetViewport(rectangle core.QRect_ITF) {
	defer qt.Recovering("QPainter::setViewport")

	if ptr.Pointer() != nil {
		C.QPainter_SetViewport(ptr.Pointer(), core.PointerFromQRect(rectangle))
	}
}

func (ptr *QPainter) SetWindow(rectangle core.QRect_ITF) {
	defer qt.Recovering("QPainter::setWindow")

	if ptr.Pointer() != nil {
		C.QPainter_SetWindow(ptr.Pointer(), core.PointerFromQRect(rectangle))
	}
}

func NewQPainter() *QPainter {
	defer qt.Recovering("QPainter::QPainter")

	return newQPainterFromPointer(C.QPainter_NewQPainter())
}

func (ptr *QPainter) Background() *QBrush {
	defer qt.Recovering("QPainter::background")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPainter_Background(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPainter) BackgroundMode() core.Qt__BGMode {
	defer qt.Recovering("QPainter::backgroundMode")

	if ptr.Pointer() != nil {
		return core.Qt__BGMode(C.QPainter_BackgroundMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainter) BeginNativePainting() {
	defer qt.Recovering("QPainter::beginNativePainting")

	if ptr.Pointer() != nil {
		C.QPainter_BeginNativePainting(ptr.Pointer())
	}
}

func (ptr *QPainter) BoundingRect3(x int, y int, w int, h int, flags int, text string) *core.QRect {
	defer qt.Recovering("QPainter::boundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPainter_BoundingRect3(ptr.Pointer(), C.int(x), C.int(y), C.int(w), C.int(h), C.int(flags), C.CString(text)))
	}
	return nil
}

func (ptr *QPainter) Brush() *QBrush {
	defer qt.Recovering("QPainter::brush")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPainter_Brush(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPainter) BrushOrigin() *core.QPoint {
	defer qt.Recovering("QPainter::brushOrigin")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QPainter_BrushOrigin(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPainter) ClipRegion() *QRegion {
	defer qt.Recovering("QPainter::clipRegion")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QPainter_ClipRegion(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPainter) CompositionMode() QPainter__CompositionMode {
	defer qt.Recovering("QPainter::compositionMode")

	if ptr.Pointer() != nil {
		return QPainter__CompositionMode(C.QPainter_CompositionMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainter) Device() *QPaintDevice {
	defer qt.Recovering("QPainter::device")

	if ptr.Pointer() != nil {
		return NewQPaintDeviceFromPointer(C.QPainter_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPainter) DrawArc2(rectangle core.QRect_ITF, startAngle int, spanAngle int) {
	defer qt.Recovering("QPainter::drawArc")

	if ptr.Pointer() != nil {
		C.QPainter_DrawArc2(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(startAngle), C.int(spanAngle))
	}
}

func (ptr *QPainter) DrawArc3(x int, y int, width int, height int, startAngle int, spanAngle int) {
	defer qt.Recovering("QPainter::drawArc")

	if ptr.Pointer() != nil {
		C.QPainter_DrawArc3(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), C.int(startAngle), C.int(spanAngle))
	}
}

func (ptr *QPainter) DrawChord2(rectangle core.QRect_ITF, startAngle int, spanAngle int) {
	defer qt.Recovering("QPainter::drawChord")

	if ptr.Pointer() != nil {
		C.QPainter_DrawChord2(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(startAngle), C.int(spanAngle))
	}
}

func (ptr *QPainter) DrawChord3(x int, y int, width int, height int, startAngle int, spanAngle int) {
	defer qt.Recovering("QPainter::drawChord")

	if ptr.Pointer() != nil {
		C.QPainter_DrawChord3(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), C.int(startAngle), C.int(spanAngle))
	}
}

func (ptr *QPainter) DrawConvexPolygon4(polygon QPolygon_ITF) {
	defer qt.Recovering("QPainter::drawConvexPolygon")

	if ptr.Pointer() != nil {
		C.QPainter_DrawConvexPolygon4(ptr.Pointer(), PointerFromQPolygon(polygon))
	}
}

func (ptr *QPainter) DrawConvexPolygon3(polygon QPolygonF_ITF) {
	defer qt.Recovering("QPainter::drawConvexPolygon")

	if ptr.Pointer() != nil {
		C.QPainter_DrawConvexPolygon3(ptr.Pointer(), PointerFromQPolygonF(polygon))
	}
}

func (ptr *QPainter) DrawEllipse5(center core.QPoint_ITF, rx int, ry int) {
	defer qt.Recovering("QPainter::drawEllipse")

	if ptr.Pointer() != nil {
		C.QPainter_DrawEllipse5(ptr.Pointer(), core.PointerFromQPoint(center), C.int(rx), C.int(ry))
	}
}

func (ptr *QPainter) DrawEllipse4(center core.QPointF_ITF, rx float64, ry float64) {
	defer qt.Recovering("QPainter::drawEllipse")

	if ptr.Pointer() != nil {
		C.QPainter_DrawEllipse4(ptr.Pointer(), core.PointerFromQPointF(center), C.double(rx), C.double(ry))
	}
}

func (ptr *QPainter) DrawEllipse3(x int, y int, width int, height int) {
	defer qt.Recovering("QPainter::drawEllipse")

	if ptr.Pointer() != nil {
		C.QPainter_DrawEllipse3(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height))
	}
}

func (ptr *QPainter) DrawImage4(point core.QPoint_ITF, image QImage_ITF) {
	defer qt.Recovering("QPainter::drawImage")

	if ptr.Pointer() != nil {
		C.QPainter_DrawImage4(ptr.Pointer(), core.PointerFromQPoint(point), PointerFromQImage(image))
	}
}

func (ptr *QPainter) DrawImage6(point core.QPoint_ITF, image QImage_ITF, source core.QRect_ITF, flags core.Qt__ImageConversionFlag) {
	defer qt.Recovering("QPainter::drawImage")

	if ptr.Pointer() != nil {
		C.QPainter_DrawImage6(ptr.Pointer(), core.PointerFromQPoint(point), PointerFromQImage(image), core.PointerFromQRect(source), C.int(flags))
	}
}

func (ptr *QPainter) DrawImage5(point core.QPointF_ITF, image QImage_ITF, source core.QRectF_ITF, flags core.Qt__ImageConversionFlag) {
	defer qt.Recovering("QPainter::drawImage")

	if ptr.Pointer() != nil {
		C.QPainter_DrawImage5(ptr.Pointer(), core.PointerFromQPointF(point), PointerFromQImage(image), core.PointerFromQRectF(source), C.int(flags))
	}
}

func (ptr *QPainter) DrawImage8(rectangle core.QRect_ITF, image QImage_ITF) {
	defer qt.Recovering("QPainter::drawImage")

	if ptr.Pointer() != nil {
		C.QPainter_DrawImage8(ptr.Pointer(), core.PointerFromQRect(rectangle), PointerFromQImage(image))
	}
}

func (ptr *QPainter) DrawImage2(target core.QRect_ITF, image QImage_ITF, source core.QRect_ITF, flags core.Qt__ImageConversionFlag) {
	defer qt.Recovering("QPainter::drawImage")

	if ptr.Pointer() != nil {
		C.QPainter_DrawImage2(ptr.Pointer(), core.PointerFromQRect(target), PointerFromQImage(image), core.PointerFromQRect(source), C.int(flags))
	}
}

func (ptr *QPainter) DrawImage7(rectangle core.QRectF_ITF, image QImage_ITF) {
	defer qt.Recovering("QPainter::drawImage")

	if ptr.Pointer() != nil {
		C.QPainter_DrawImage7(ptr.Pointer(), core.PointerFromQRectF(rectangle), PointerFromQImage(image))
	}
}

func (ptr *QPainter) DrawImage9(x int, y int, image QImage_ITF, sx int, sy int, sw int, sh int, flags core.Qt__ImageConversionFlag) {
	defer qt.Recovering("QPainter::drawImage")

	if ptr.Pointer() != nil {
		C.QPainter_DrawImage9(ptr.Pointer(), C.int(x), C.int(y), PointerFromQImage(image), C.int(sx), C.int(sy), C.int(sw), C.int(sh), C.int(flags))
	}
}

func (ptr *QPainter) DrawLine2(line core.QLine_ITF) {
	defer qt.Recovering("QPainter::drawLine")

	if ptr.Pointer() != nil {
		C.QPainter_DrawLine2(ptr.Pointer(), core.PointerFromQLine(line))
	}
}

func (ptr *QPainter) DrawLine(line core.QLineF_ITF) {
	defer qt.Recovering("QPainter::drawLine")

	if ptr.Pointer() != nil {
		C.QPainter_DrawLine(ptr.Pointer(), core.PointerFromQLineF(line))
	}
}

func (ptr *QPainter) DrawLine3(p1 core.QPoint_ITF, p2 core.QPoint_ITF) {
	defer qt.Recovering("QPainter::drawLine")

	if ptr.Pointer() != nil {
		C.QPainter_DrawLine3(ptr.Pointer(), core.PointerFromQPoint(p1), core.PointerFromQPoint(p2))
	}
}

func (ptr *QPainter) DrawLine4(p1 core.QPointF_ITF, p2 core.QPointF_ITF) {
	defer qt.Recovering("QPainter::drawLine")

	if ptr.Pointer() != nil {
		C.QPainter_DrawLine4(ptr.Pointer(), core.PointerFromQPointF(p1), core.PointerFromQPointF(p2))
	}
}

func (ptr *QPainter) DrawLine5(x1 int, y1 int, x2 int, y2 int) {
	defer qt.Recovering("QPainter::drawLine")

	if ptr.Pointer() != nil {
		C.QPainter_DrawLine5(ptr.Pointer(), C.int(x1), C.int(y1), C.int(x2), C.int(y2))
	}
}

func (ptr *QPainter) DrawLines(lines core.QLineF_ITF, lineCount int) {
	defer qt.Recovering("QPainter::drawLines")

	if ptr.Pointer() != nil {
		C.QPainter_DrawLines(ptr.Pointer(), core.PointerFromQLineF(lines), C.int(lineCount))
	}
}

func (ptr *QPainter) DrawLines4(pointPairs core.QPoint_ITF, lineCount int) {
	defer qt.Recovering("QPainter::drawLines")

	if ptr.Pointer() != nil {
		C.QPainter_DrawLines4(ptr.Pointer(), core.PointerFromQPoint(pointPairs), C.int(lineCount))
	}
}

func (ptr *QPainter) DrawLines3(pointPairs core.QPointF_ITF, lineCount int) {
	defer qt.Recovering("QPainter::drawLines")

	if ptr.Pointer() != nil {
		C.QPainter_DrawLines3(ptr.Pointer(), core.PointerFromQPointF(pointPairs), C.int(lineCount))
	}
}

func (ptr *QPainter) DrawPath(path QPainterPath_ITF) {
	defer qt.Recovering("QPainter::drawPath")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPath(ptr.Pointer(), PointerFromQPainterPath(path))
	}
}

func (ptr *QPainter) DrawPicture2(point core.QPoint_ITF, picture QPicture_ITF) {
	defer qt.Recovering("QPainter::drawPicture")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPicture2(ptr.Pointer(), core.PointerFromQPoint(point), PointerFromQPicture(picture))
	}
}

func (ptr *QPainter) DrawPicture3(x int, y int, picture QPicture_ITF) {
	defer qt.Recovering("QPainter::drawPicture")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPicture3(ptr.Pointer(), C.int(x), C.int(y), PointerFromQPicture(picture))
	}
}

func (ptr *QPainter) DrawPie2(rectangle core.QRect_ITF, startAngle int, spanAngle int) {
	defer qt.Recovering("QPainter::drawPie")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPie2(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(startAngle), C.int(spanAngle))
	}
}

func (ptr *QPainter) DrawPie3(x int, y int, width int, height int, startAngle int, spanAngle int) {
	defer qt.Recovering("QPainter::drawPie")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPie3(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), C.int(startAngle), C.int(spanAngle))
	}
}

func (ptr *QPainter) DrawPixmap6(point core.QPoint_ITF, pixmap QPixmap_ITF) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap6(ptr.Pointer(), core.PointerFromQPoint(point), PointerFromQPixmap(pixmap))
	}
}

func (ptr *QPainter) DrawPixmap4(point core.QPoint_ITF, pixmap QPixmap_ITF, source core.QRect_ITF) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap4(ptr.Pointer(), core.PointerFromQPoint(point), PointerFromQPixmap(pixmap), core.PointerFromQRect(source))
	}
}

func (ptr *QPainter) DrawPixmap3(point core.QPointF_ITF, pixmap QPixmap_ITF, source core.QRectF_ITF) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap3(ptr.Pointer(), core.PointerFromQPointF(point), PointerFromQPixmap(pixmap), core.PointerFromQRectF(source))
	}
}

func (ptr *QPainter) DrawPixmap8(rectangle core.QRect_ITF, pixmap QPixmap_ITF) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap8(ptr.Pointer(), core.PointerFromQRect(rectangle), PointerFromQPixmap(pixmap))
	}
}

func (ptr *QPainter) DrawPixmap2(target core.QRect_ITF, pixmap QPixmap_ITF, source core.QRect_ITF) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap2(ptr.Pointer(), core.PointerFromQRect(target), PointerFromQPixmap(pixmap), core.PointerFromQRect(source))
	}
}

func (ptr *QPainter) DrawPixmap7(x int, y int, pixmap QPixmap_ITF) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap7(ptr.Pointer(), C.int(x), C.int(y), PointerFromQPixmap(pixmap))
	}
}

func (ptr *QPainter) DrawPixmap11(x int, y int, pixmap QPixmap_ITF, sx int, sy int, sw int, sh int) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap11(ptr.Pointer(), C.int(x), C.int(y), PointerFromQPixmap(pixmap), C.int(sx), C.int(sy), C.int(sw), C.int(sh))
	}
}

func (ptr *QPainter) DrawPixmap10(x int, y int, w int, h int, pixmap QPixmap_ITF, sx int, sy int, sw int, sh int) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap10(ptr.Pointer(), C.int(x), C.int(y), C.int(w), C.int(h), PointerFromQPixmap(pixmap), C.int(sx), C.int(sy), C.int(sw), C.int(sh))
	}
}

func (ptr *QPainter) DrawPixmap9(x int, y int, width int, height int, pixmap QPixmap_ITF) {
	defer qt.Recovering("QPainter::drawPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPixmap9(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), PointerFromQPixmap(pixmap))
	}
}

func (ptr *QPainter) DrawPoint2(position core.QPoint_ITF) {
	defer qt.Recovering("QPainter::drawPoint")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPoint2(ptr.Pointer(), core.PointerFromQPoint(position))
	}
}

func (ptr *QPainter) DrawPoint(position core.QPointF_ITF) {
	defer qt.Recovering("QPainter::drawPoint")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPoint(ptr.Pointer(), core.PointerFromQPointF(position))
	}
}

func (ptr *QPainter) DrawPoint3(x int, y int) {
	defer qt.Recovering("QPainter::drawPoint")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPoint3(ptr.Pointer(), C.int(x), C.int(y))
	}
}

func (ptr *QPainter) DrawPoints2(points core.QPoint_ITF, pointCount int) {
	defer qt.Recovering("QPainter::drawPoints")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPoints2(ptr.Pointer(), core.PointerFromQPoint(points), C.int(pointCount))
	}
}

func (ptr *QPainter) DrawPoints(points core.QPointF_ITF, pointCount int) {
	defer qt.Recovering("QPainter::drawPoints")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPoints(ptr.Pointer(), core.PointerFromQPointF(points), C.int(pointCount))
	}
}

func (ptr *QPainter) DrawPoints4(points QPolygon_ITF) {
	defer qt.Recovering("QPainter::drawPoints")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPoints4(ptr.Pointer(), PointerFromQPolygon(points))
	}
}

func (ptr *QPainter) DrawPoints3(points QPolygonF_ITF) {
	defer qt.Recovering("QPainter::drawPoints")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPoints3(ptr.Pointer(), PointerFromQPolygonF(points))
	}
}

func (ptr *QPainter) DrawPolygon2(points core.QPoint_ITF, pointCount int, fillRule core.Qt__FillRule) {
	defer qt.Recovering("QPainter::drawPolygon")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPolygon2(ptr.Pointer(), core.PointerFromQPoint(points), C.int(pointCount), C.int(fillRule))
	}
}

func (ptr *QPainter) DrawPolygon(points core.QPointF_ITF, pointCount int, fillRule core.Qt__FillRule) {
	defer qt.Recovering("QPainter::drawPolygon")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPolygon(ptr.Pointer(), core.PointerFromQPointF(points), C.int(pointCount), C.int(fillRule))
	}
}

func (ptr *QPainter) DrawPolygon4(points QPolygon_ITF, fillRule core.Qt__FillRule) {
	defer qt.Recovering("QPainter::drawPolygon")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPolygon4(ptr.Pointer(), PointerFromQPolygon(points), C.int(fillRule))
	}
}

func (ptr *QPainter) DrawPolygon3(points QPolygonF_ITF, fillRule core.Qt__FillRule) {
	defer qt.Recovering("QPainter::drawPolygon")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPolygon3(ptr.Pointer(), PointerFromQPolygonF(points), C.int(fillRule))
	}
}

func (ptr *QPainter) DrawPolyline2(points core.QPoint_ITF, pointCount int) {
	defer qt.Recovering("QPainter::drawPolyline")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPolyline2(ptr.Pointer(), core.PointerFromQPoint(points), C.int(pointCount))
	}
}

func (ptr *QPainter) DrawPolyline(points core.QPointF_ITF, pointCount int) {
	defer qt.Recovering("QPainter::drawPolyline")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPolyline(ptr.Pointer(), core.PointerFromQPointF(points), C.int(pointCount))
	}
}

func (ptr *QPainter) DrawPolyline4(points QPolygon_ITF) {
	defer qt.Recovering("QPainter::drawPolyline")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPolyline4(ptr.Pointer(), PointerFromQPolygon(points))
	}
}

func (ptr *QPainter) DrawPolyline3(points QPolygonF_ITF) {
	defer qt.Recovering("QPainter::drawPolyline")

	if ptr.Pointer() != nil {
		C.QPainter_DrawPolyline3(ptr.Pointer(), PointerFromQPolygonF(points))
	}
}

func (ptr *QPainter) DrawRect2(rectangle core.QRect_ITF) {
	defer qt.Recovering("QPainter::drawRect")

	if ptr.Pointer() != nil {
		C.QPainter_DrawRect2(ptr.Pointer(), core.PointerFromQRect(rectangle))
	}
}

func (ptr *QPainter) DrawRect(rectangle core.QRectF_ITF) {
	defer qt.Recovering("QPainter::drawRect")

	if ptr.Pointer() != nil {
		C.QPainter_DrawRect(ptr.Pointer(), core.PointerFromQRectF(rectangle))
	}
}

func (ptr *QPainter) DrawRect3(x int, y int, width int, height int) {
	defer qt.Recovering("QPainter::drawRect")

	if ptr.Pointer() != nil {
		C.QPainter_DrawRect3(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height))
	}
}

func (ptr *QPainter) DrawRoundedRect2(rect core.QRect_ITF, xRadius float64, yRadius float64, mode core.Qt__SizeMode) {
	defer qt.Recovering("QPainter::drawRoundedRect")

	if ptr.Pointer() != nil {
		C.QPainter_DrawRoundedRect2(ptr.Pointer(), core.PointerFromQRect(rect), C.double(xRadius), C.double(yRadius), C.int(mode))
	}
}

func (ptr *QPainter) DrawRoundedRect(rect core.QRectF_ITF, xRadius float64, yRadius float64, mode core.Qt__SizeMode) {
	defer qt.Recovering("QPainter::drawRoundedRect")

	if ptr.Pointer() != nil {
		C.QPainter_DrawRoundedRect(ptr.Pointer(), core.PointerFromQRectF(rect), C.double(xRadius), C.double(yRadius), C.int(mode))
	}
}

func (ptr *QPainter) DrawRoundedRect3(x int, y int, w int, h int, xRadius float64, yRadius float64, mode core.Qt__SizeMode) {
	defer qt.Recovering("QPainter::drawRoundedRect")

	if ptr.Pointer() != nil {
		C.QPainter_DrawRoundedRect3(ptr.Pointer(), C.int(x), C.int(y), C.int(w), C.int(h), C.double(xRadius), C.double(yRadius), C.int(mode))
	}
}

func (ptr *QPainter) DrawStaticText2(topLeftPosition core.QPoint_ITF, staticText QStaticText_ITF) {
	defer qt.Recovering("QPainter::drawStaticText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawStaticText2(ptr.Pointer(), core.PointerFromQPoint(topLeftPosition), PointerFromQStaticText(staticText))
	}
}

func (ptr *QPainter) DrawStaticText(topLeftPosition core.QPointF_ITF, staticText QStaticText_ITF) {
	defer qt.Recovering("QPainter::drawStaticText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawStaticText(ptr.Pointer(), core.PointerFromQPointF(topLeftPosition), PointerFromQStaticText(staticText))
	}
}

func (ptr *QPainter) DrawStaticText3(left int, top int, staticText QStaticText_ITF) {
	defer qt.Recovering("QPainter::drawStaticText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawStaticText3(ptr.Pointer(), C.int(left), C.int(top), PointerFromQStaticText(staticText))
	}
}

func (ptr *QPainter) DrawText3(position core.QPoint_ITF, text string) {
	defer qt.Recovering("QPainter::drawText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawText3(ptr.Pointer(), core.PointerFromQPoint(position), C.CString(text))
	}
}

func (ptr *QPainter) DrawText6(x int, y int, text string) {
	defer qt.Recovering("QPainter::drawText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawText6(ptr.Pointer(), C.int(x), C.int(y), C.CString(text))
	}
}

func (ptr *QPainter) DrawText7(x int, y int, width int, height int, flags int, text string, boundingRect core.QRect_ITF) {
	defer qt.Recovering("QPainter::drawText")

	if ptr.Pointer() != nil {
		C.QPainter_DrawText7(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), C.int(flags), C.CString(text), core.PointerFromQRect(boundingRect))
	}
}

func (ptr *QPainter) DrawTiledPixmap2(rectangle core.QRect_ITF, pixmap QPixmap_ITF, position core.QPoint_ITF) {
	defer qt.Recovering("QPainter::drawTiledPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawTiledPixmap2(ptr.Pointer(), core.PointerFromQRect(rectangle), PointerFromQPixmap(pixmap), core.PointerFromQPoint(position))
	}
}

func (ptr *QPainter) DrawTiledPixmap3(x int, y int, width int, height int, pixmap QPixmap_ITF, sx int, sy int) {
	defer qt.Recovering("QPainter::drawTiledPixmap")

	if ptr.Pointer() != nil {
		C.QPainter_DrawTiledPixmap3(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), PointerFromQPixmap(pixmap), C.int(sx), C.int(sy))
	}
}

func (ptr *QPainter) End() bool {
	defer qt.Recovering("QPainter::end")

	if ptr.Pointer() != nil {
		return C.QPainter_End(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPainter) EndNativePainting() {
	defer qt.Recovering("QPainter::endNativePainting")

	if ptr.Pointer() != nil {
		C.QPainter_EndNativePainting(ptr.Pointer())
	}
}

func (ptr *QPainter) EraseRect2(rectangle core.QRect_ITF) {
	defer qt.Recovering("QPainter::eraseRect")

	if ptr.Pointer() != nil {
		C.QPainter_EraseRect2(ptr.Pointer(), core.PointerFromQRect(rectangle))
	}
}

func (ptr *QPainter) EraseRect3(x int, y int, width int, height int) {
	defer qt.Recovering("QPainter::eraseRect")

	if ptr.Pointer() != nil {
		C.QPainter_EraseRect3(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height))
	}
}

func (ptr *QPainter) FillPath(path QPainterPath_ITF, brush QBrush_ITF) {
	defer qt.Recovering("QPainter::fillPath")

	if ptr.Pointer() != nil {
		C.QPainter_FillPath(ptr.Pointer(), PointerFromQPainterPath(path), PointerFromQBrush(brush))
	}
}

func (ptr *QPainter) FillRect3(rectangle core.QRect_ITF, style core.Qt__BrushStyle) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect3(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(style))
	}
}

func (ptr *QPainter) FillRect11(rectangle core.QRect_ITF, color core.Qt__GlobalColor) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect11(ptr.Pointer(), core.PointerFromQRect(rectangle), C.int(color))
	}
}

func (ptr *QPainter) FillRect4(rectangle core.QRectF_ITF, style core.Qt__BrushStyle) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect4(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.int(style))
	}
}

func (ptr *QPainter) FillRect12(rectangle core.QRectF_ITF, color core.Qt__GlobalColor) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect12(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.int(color))
	}
}

func (ptr *QPainter) FillRect2(x int, y int, width int, height int, style core.Qt__BrushStyle) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect2(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), C.int(style))
	}
}

func (ptr *QPainter) FillRect10(x int, y int, width int, height int, color core.Qt__GlobalColor) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect10(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), C.int(color))
	}
}

func (ptr *QPainter) FillRect8(x int, y int, width int, height int, brush QBrush_ITF) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect8(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), PointerFromQBrush(brush))
	}
}

func (ptr *QPainter) FillRect9(x int, y int, width int, height int, color QColor_ITF) {
	defer qt.Recovering("QPainter::fillRect")

	if ptr.Pointer() != nil {
		C.QPainter_FillRect9(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), PointerFromQColor(color))
	}
}

func (ptr *QPainter) HasClipping() bool {
	defer qt.Recovering("QPainter::hasClipping")

	if ptr.Pointer() != nil {
		return C.QPainter_HasClipping(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPainter) IsActive() bool {
	defer qt.Recovering("QPainter::isActive")

	if ptr.Pointer() != nil {
		return C.QPainter_IsActive(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPainter) LayoutDirection() core.Qt__LayoutDirection {
	defer qt.Recovering("QPainter::layoutDirection")

	if ptr.Pointer() != nil {
		return core.Qt__LayoutDirection(C.QPainter_LayoutDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainter) Opacity() float64 {
	defer qt.Recovering("QPainter::opacity")

	if ptr.Pointer() != nil {
		return float64(C.QPainter_Opacity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainter) PaintEngine() *QPaintEngine {
	defer qt.Recovering("QPainter::paintEngine")

	if ptr.Pointer() != nil {
		return NewQPaintEngineFromPointer(C.QPainter_PaintEngine(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPainter) RenderHints() QPainter__RenderHint {
	defer qt.Recovering("QPainter::renderHints")

	if ptr.Pointer() != nil {
		return QPainter__RenderHint(C.QPainter_RenderHints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainter) ResetTransform() {
	defer qt.Recovering("QPainter::resetTransform")

	if ptr.Pointer() != nil {
		C.QPainter_ResetTransform(ptr.Pointer())
	}
}

func (ptr *QPainter) Restore() {
	defer qt.Recovering("QPainter::restore")

	if ptr.Pointer() != nil {
		C.QPainter_Restore(ptr.Pointer())
	}
}

func (ptr *QPainter) Save() {
	defer qt.Recovering("QPainter::save")

	if ptr.Pointer() != nil {
		C.QPainter_Save(ptr.Pointer())
	}
}

func (ptr *QPainter) Scale(sx float64, sy float64) {
	defer qt.Recovering("QPainter::scale")

	if ptr.Pointer() != nil {
		C.QPainter_Scale(ptr.Pointer(), C.double(sx), C.double(sy))
	}
}

func (ptr *QPainter) SetBackgroundMode(mode core.Qt__BGMode) {
	defer qt.Recovering("QPainter::setBackgroundMode")

	if ptr.Pointer() != nil {
		C.QPainter_SetBackgroundMode(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QPainter) SetBrush2(style core.Qt__BrushStyle) {
	defer qt.Recovering("QPainter::setBrush")

	if ptr.Pointer() != nil {
		C.QPainter_SetBrush2(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QPainter) SetBrush(brush QBrush_ITF) {
	defer qt.Recovering("QPainter::setBrush")

	if ptr.Pointer() != nil {
		C.QPainter_SetBrush(ptr.Pointer(), PointerFromQBrush(brush))
	}
}

func (ptr *QPainter) SetBrushOrigin2(position core.QPoint_ITF) {
	defer qt.Recovering("QPainter::setBrushOrigin")

	if ptr.Pointer() != nil {
		C.QPainter_SetBrushOrigin2(ptr.Pointer(), core.PointerFromQPoint(position))
	}
}

func (ptr *QPainter) SetBrushOrigin3(x int, y int) {
	defer qt.Recovering("QPainter::setBrushOrigin")

	if ptr.Pointer() != nil {
		C.QPainter_SetBrushOrigin3(ptr.Pointer(), C.int(x), C.int(y))
	}
}

func (ptr *QPainter) SetClipRect2(x int, y int, width int, height int, operation core.Qt__ClipOperation) {
	defer qt.Recovering("QPainter::setClipRect")

	if ptr.Pointer() != nil {
		C.QPainter_SetClipRect2(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height), C.int(operation))
	}
}

func (ptr *QPainter) SetClipping(enable bool) {
	defer qt.Recovering("QPainter::setClipping")

	if ptr.Pointer() != nil {
		C.QPainter_SetClipping(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QPainter) SetCompositionMode(mode QPainter__CompositionMode) {
	defer qt.Recovering("QPainter::setCompositionMode")

	if ptr.Pointer() != nil {
		C.QPainter_SetCompositionMode(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QPainter) SetFont(font QFont_ITF) {
	defer qt.Recovering("QPainter::setFont")

	if ptr.Pointer() != nil {
		C.QPainter_SetFont(ptr.Pointer(), PointerFromQFont(font))
	}
}

func (ptr *QPainter) SetLayoutDirection(direction core.Qt__LayoutDirection) {
	defer qt.Recovering("QPainter::setLayoutDirection")

	if ptr.Pointer() != nil {
		C.QPainter_SetLayoutDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QPainter) SetOpacity(opacity float64) {
	defer qt.Recovering("QPainter::setOpacity")

	if ptr.Pointer() != nil {
		C.QPainter_SetOpacity(ptr.Pointer(), C.double(opacity))
	}
}

func (ptr *QPainter) SetPen3(style core.Qt__PenStyle) {
	defer qt.Recovering("QPainter::setPen")

	if ptr.Pointer() != nil {
		C.QPainter_SetPen3(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QPainter) SetPen2(color QColor_ITF) {
	defer qt.Recovering("QPainter::setPen")

	if ptr.Pointer() != nil {
		C.QPainter_SetPen2(ptr.Pointer(), PointerFromQColor(color))
	}
}

func (ptr *QPainter) SetPen(pen QPen_ITF) {
	defer qt.Recovering("QPainter::setPen")

	if ptr.Pointer() != nil {
		C.QPainter_SetPen(ptr.Pointer(), PointerFromQPen(pen))
	}
}

func (ptr *QPainter) SetRenderHint(hint QPainter__RenderHint, on bool) {
	defer qt.Recovering("QPainter::setRenderHint")

	if ptr.Pointer() != nil {
		C.QPainter_SetRenderHint(ptr.Pointer(), C.int(hint), C.int(qt.GoBoolToInt(on)))
	}
}

func (ptr *QPainter) SetRenderHints(hints QPainter__RenderHint, on bool) {
	defer qt.Recovering("QPainter::setRenderHints")

	if ptr.Pointer() != nil {
		C.QPainter_SetRenderHints(ptr.Pointer(), C.int(hints), C.int(qt.GoBoolToInt(on)))
	}
}

func (ptr *QPainter) SetTransform(transform QTransform_ITF, combine bool) {
	defer qt.Recovering("QPainter::setTransform")

	if ptr.Pointer() != nil {
		C.QPainter_SetTransform(ptr.Pointer(), PointerFromQTransform(transform), C.int(qt.GoBoolToInt(combine)))
	}
}

func (ptr *QPainter) SetViewTransformEnabled(enable bool) {
	defer qt.Recovering("QPainter::setViewTransformEnabled")

	if ptr.Pointer() != nil {
		C.QPainter_SetViewTransformEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QPainter) SetViewport2(x int, y int, width int, height int) {
	defer qt.Recovering("QPainter::setViewport")

	if ptr.Pointer() != nil {
		C.QPainter_SetViewport2(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height))
	}
}

func (ptr *QPainter) SetWindow2(x int, y int, width int, height int) {
	defer qt.Recovering("QPainter::setWindow")

	if ptr.Pointer() != nil {
		C.QPainter_SetWindow2(ptr.Pointer(), C.int(x), C.int(y), C.int(width), C.int(height))
	}
}

func (ptr *QPainter) SetWorldMatrixEnabled(enable bool) {
	defer qt.Recovering("QPainter::setWorldMatrixEnabled")

	if ptr.Pointer() != nil {
		C.QPainter_SetWorldMatrixEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QPainter) SetWorldTransform(matrix QTransform_ITF, combine bool) {
	defer qt.Recovering("QPainter::setWorldTransform")

	if ptr.Pointer() != nil {
		C.QPainter_SetWorldTransform(ptr.Pointer(), PointerFromQTransform(matrix), C.int(qt.GoBoolToInt(combine)))
	}
}

func (ptr *QPainter) Shear(sh float64, sv float64) {
	defer qt.Recovering("QPainter::shear")

	if ptr.Pointer() != nil {
		C.QPainter_Shear(ptr.Pointer(), C.double(sh), C.double(sv))
	}
}

func (ptr *QPainter) StrokePath(path QPainterPath_ITF, pen QPen_ITF) {
	defer qt.Recovering("QPainter::strokePath")

	if ptr.Pointer() != nil {
		C.QPainter_StrokePath(ptr.Pointer(), PointerFromQPainterPath(path), PointerFromQPen(pen))
	}
}

func (ptr *QPainter) TestRenderHint(hint QPainter__RenderHint) bool {
	defer qt.Recovering("QPainter::testRenderHint")

	if ptr.Pointer() != nil {
		return C.QPainter_TestRenderHint(ptr.Pointer(), C.int(hint)) != 0
	}
	return false
}

func (ptr *QPainter) Translate2(offset core.QPoint_ITF) {
	defer qt.Recovering("QPainter::translate")

	if ptr.Pointer() != nil {
		C.QPainter_Translate2(ptr.Pointer(), core.PointerFromQPoint(offset))
	}
}

func (ptr *QPainter) Translate(offset core.QPointF_ITF) {
	defer qt.Recovering("QPainter::translate")

	if ptr.Pointer() != nil {
		C.QPainter_Translate(ptr.Pointer(), core.PointerFromQPointF(offset))
	}
}

func (ptr *QPainter) Translate3(dx float64, dy float64) {
	defer qt.Recovering("QPainter::translate")

	if ptr.Pointer() != nil {
		C.QPainter_Translate3(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

func (ptr *QPainter) ViewTransformEnabled() bool {
	defer qt.Recovering("QPainter::viewTransformEnabled")

	if ptr.Pointer() != nil {
		return C.QPainter_ViewTransformEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPainter) Viewport() *core.QRect {
	defer qt.Recovering("QPainter::viewport")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPainter_Viewport(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPainter) Window() *core.QRect {
	defer qt.Recovering("QPainter::window")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPainter_Window(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPainter) WorldMatrixEnabled() bool {
	defer qt.Recovering("QPainter::worldMatrixEnabled")

	if ptr.Pointer() != nil {
		return C.QPainter_WorldMatrixEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPainter) DestroyQPainter() {
	defer qt.Recovering("QPainter::~QPainter")

	if ptr.Pointer() != nil {
		C.QPainter_DestroyQPainter(ptr.Pointer())
	}
}

type QPainterPath struct {
	ptr unsafe.Pointer
}

type QPainterPath_ITF interface {
	QPainterPath_PTR() *QPainterPath
}

func (p *QPainterPath) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPainterPath) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPainterPath(ptr QPainterPath_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPainterPath_PTR().Pointer()
	}
	return nil
}

func NewQPainterPathFromPointer(ptr unsafe.Pointer) *QPainterPath {
	var n = new(QPainterPath)
	n.SetPointer(ptr)
	return n
}

func newQPainterPathFromPointer(ptr unsafe.Pointer) *QPainterPath {
	var n = NewQPainterPathFromPointer(ptr)
	return n
}

func (ptr *QPainterPath) QPainterPath_PTR() *QPainterPath {
	return ptr
}

//QPainterPath::ElementType
type QPainterPath__ElementType int64

const (
	QPainterPath__MoveToElement      = QPainterPath__ElementType(0)
	QPainterPath__LineToElement      = QPainterPath__ElementType(1)
	QPainterPath__CurveToElement     = QPainterPath__ElementType(2)
	QPainterPath__CurveToDataElement = QPainterPath__ElementType(3)
)

func NewQPainterPath3(path QPainterPath_ITF) *QPainterPath {
	defer qt.Recovering("QPainterPath::QPainterPath")

	return newQPainterPathFromPointer(C.QPainterPath_NewQPainterPath3(PointerFromQPainterPath(path)))
}

func (ptr *QPainterPath) AddEllipse(boundingRectangle core.QRectF_ITF) {
	defer qt.Recovering("QPainterPath::addEllipse")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddEllipse(ptr.Pointer(), core.PointerFromQRectF(boundingRectangle))
	}
}

func (ptr *QPainterPath) AddPath(path QPainterPath_ITF) {
	defer qt.Recovering("QPainterPath::addPath")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddPath(ptr.Pointer(), PointerFromQPainterPath(path))
	}
}

func (ptr *QPainterPath) AddRect(rectangle core.QRectF_ITF) {
	defer qt.Recovering("QPainterPath::addRect")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddRect(ptr.Pointer(), core.PointerFromQRectF(rectangle))
	}
}

func (ptr *QPainterPath) AddText(point core.QPointF_ITF, font QFont_ITF, text string) {
	defer qt.Recovering("QPainterPath::addText")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddText(ptr.Pointer(), core.PointerFromQPointF(point), PointerFromQFont(font), C.CString(text))
	}
}

func (ptr *QPainterPath) ArcMoveTo(rectangle core.QRectF_ITF, angle float64) {
	defer qt.Recovering("QPainterPath::arcMoveTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_ArcMoveTo(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.double(angle))
	}
}

func (ptr *QPainterPath) ArcTo(rectangle core.QRectF_ITF, startAngle float64, sweepLength float64) {
	defer qt.Recovering("QPainterPath::arcTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_ArcTo(ptr.Pointer(), core.PointerFromQRectF(rectangle), C.double(startAngle), C.double(sweepLength))
	}
}

func (ptr *QPainterPath) ConnectPath(path QPainterPath_ITF) {
	defer qt.Recovering("QPainterPath::connectPath")

	if ptr.Pointer() != nil {
		C.QPainterPath_ConnectPath(ptr.Pointer(), PointerFromQPainterPath(path))
	}
}

func (ptr *QPainterPath) Contains(point core.QPointF_ITF) bool {
	defer qt.Recovering("QPainterPath::contains")

	if ptr.Pointer() != nil {
		return C.QPainterPath_Contains(ptr.Pointer(), core.PointerFromQPointF(point)) != 0
	}
	return false
}

func (ptr *QPainterPath) Contains2(rectangle core.QRectF_ITF) bool {
	defer qt.Recovering("QPainterPath::contains")

	if ptr.Pointer() != nil {
		return C.QPainterPath_Contains2(ptr.Pointer(), core.PointerFromQRectF(rectangle)) != 0
	}
	return false
}

func (ptr *QPainterPath) CubicTo(c1 core.QPointF_ITF, c2 core.QPointF_ITF, endPoint core.QPointF_ITF) {
	defer qt.Recovering("QPainterPath::cubicTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_CubicTo(ptr.Pointer(), core.PointerFromQPointF(c1), core.PointerFromQPointF(c2), core.PointerFromQPointF(endPoint))
	}
}

func (ptr *QPainterPath) ElementCount() int {
	defer qt.Recovering("QPainterPath::elementCount")

	if ptr.Pointer() != nil {
		return int(C.QPainterPath_ElementCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainterPath) Intersects(rectangle core.QRectF_ITF) bool {
	defer qt.Recovering("QPainterPath::intersects")

	if ptr.Pointer() != nil {
		return C.QPainterPath_Intersects(ptr.Pointer(), core.PointerFromQRectF(rectangle)) != 0
	}
	return false
}

func (ptr *QPainterPath) IsEmpty() bool {
	defer qt.Recovering("QPainterPath::isEmpty")

	if ptr.Pointer() != nil {
		return C.QPainterPath_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPainterPath) LineTo(endPoint core.QPointF_ITF) {
	defer qt.Recovering("QPainterPath::lineTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_LineTo(ptr.Pointer(), core.PointerFromQPointF(endPoint))
	}
}

func (ptr *QPainterPath) MoveTo(point core.QPointF_ITF) {
	defer qt.Recovering("QPainterPath::moveTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_MoveTo(ptr.Pointer(), core.PointerFromQPointF(point))
	}
}

func (ptr *QPainterPath) QuadTo(c core.QPointF_ITF, endPoint core.QPointF_ITF) {
	defer qt.Recovering("QPainterPath::quadTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_QuadTo(ptr.Pointer(), core.PointerFromQPointF(c), core.PointerFromQPointF(endPoint))
	}
}

func (ptr *QPainterPath) SetElementPositionAt(index int, x float64, y float64) {
	defer qt.Recovering("QPainterPath::setElementPositionAt")

	if ptr.Pointer() != nil {
		C.QPainterPath_SetElementPositionAt(ptr.Pointer(), C.int(index), C.double(x), C.double(y))
	}
}

func (ptr *QPainterPath) SetFillRule(fillRule core.Qt__FillRule) {
	defer qt.Recovering("QPainterPath::setFillRule")

	if ptr.Pointer() != nil {
		C.QPainterPath_SetFillRule(ptr.Pointer(), C.int(fillRule))
	}
}

func NewQPainterPath() *QPainterPath {
	defer qt.Recovering("QPainterPath::QPainterPath")

	return newQPainterPathFromPointer(C.QPainterPath_NewQPainterPath())
}

func NewQPainterPath2(startPoint core.QPointF_ITF) *QPainterPath {
	defer qt.Recovering("QPainterPath::QPainterPath")

	return newQPainterPathFromPointer(C.QPainterPath_NewQPainterPath2(core.PointerFromQPointF(startPoint)))
}

func (ptr *QPainterPath) AddEllipse3(center core.QPointF_ITF, rx float64, ry float64) {
	defer qt.Recovering("QPainterPath::addEllipse")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddEllipse3(ptr.Pointer(), core.PointerFromQPointF(center), C.double(rx), C.double(ry))
	}
}

func (ptr *QPainterPath) AddEllipse2(x float64, y float64, width float64, height float64) {
	defer qt.Recovering("QPainterPath::addEllipse")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddEllipse2(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height))
	}
}

func (ptr *QPainterPath) AddPolygon(polygon QPolygonF_ITF) {
	defer qt.Recovering("QPainterPath::addPolygon")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddPolygon(ptr.Pointer(), PointerFromQPolygonF(polygon))
	}
}

func (ptr *QPainterPath) AddRect2(x float64, y float64, width float64, height float64) {
	defer qt.Recovering("QPainterPath::addRect")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height))
	}
}

func (ptr *QPainterPath) AddRegion(region QRegion_ITF) {
	defer qt.Recovering("QPainterPath::addRegion")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddRegion(ptr.Pointer(), PointerFromQRegion(region))
	}
}

func (ptr *QPainterPath) AddRoundedRect(rect core.QRectF_ITF, xRadius float64, yRadius float64, mode core.Qt__SizeMode) {
	defer qt.Recovering("QPainterPath::addRoundedRect")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddRoundedRect(ptr.Pointer(), core.PointerFromQRectF(rect), C.double(xRadius), C.double(yRadius), C.int(mode))
	}
}

func (ptr *QPainterPath) AddRoundedRect2(x float64, y float64, w float64, h float64, xRadius float64, yRadius float64, mode core.Qt__SizeMode) {
	defer qt.Recovering("QPainterPath::addRoundedRect")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddRoundedRect2(ptr.Pointer(), C.double(x), C.double(y), C.double(w), C.double(h), C.double(xRadius), C.double(yRadius), C.int(mode))
	}
}

func (ptr *QPainterPath) AddText2(x float64, y float64, font QFont_ITF, text string) {
	defer qt.Recovering("QPainterPath::addText")

	if ptr.Pointer() != nil {
		C.QPainterPath_AddText2(ptr.Pointer(), C.double(x), C.double(y), PointerFromQFont(font), C.CString(text))
	}
}

func (ptr *QPainterPath) AngleAtPercent(t float64) float64 {
	defer qt.Recovering("QPainterPath::angleAtPercent")

	if ptr.Pointer() != nil {
		return float64(C.QPainterPath_AngleAtPercent(ptr.Pointer(), C.double(t)))
	}
	return 0
}

func (ptr *QPainterPath) ArcMoveTo2(x float64, y float64, width float64, height float64, angle float64) {
	defer qt.Recovering("QPainterPath::arcMoveTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_ArcMoveTo2(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height), C.double(angle))
	}
}

func (ptr *QPainterPath) ArcTo2(x float64, y float64, width float64, height float64, startAngle float64, sweepLength float64) {
	defer qt.Recovering("QPainterPath::arcTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_ArcTo2(ptr.Pointer(), C.double(x), C.double(y), C.double(width), C.double(height), C.double(startAngle), C.double(sweepLength))
	}
}

func (ptr *QPainterPath) CloseSubpath() {
	defer qt.Recovering("QPainterPath::closeSubpath")

	if ptr.Pointer() != nil {
		C.QPainterPath_CloseSubpath(ptr.Pointer())
	}
}

func (ptr *QPainterPath) Contains3(p QPainterPath_ITF) bool {
	defer qt.Recovering("QPainterPath::contains")

	if ptr.Pointer() != nil {
		return C.QPainterPath_Contains3(ptr.Pointer(), PointerFromQPainterPath(p)) != 0
	}
	return false
}

func (ptr *QPainterPath) CubicTo2(c1X float64, c1Y float64, c2X float64, c2Y float64, endPointX float64, endPointY float64) {
	defer qt.Recovering("QPainterPath::cubicTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_CubicTo2(ptr.Pointer(), C.double(c1X), C.double(c1Y), C.double(c2X), C.double(c2Y), C.double(endPointX), C.double(endPointY))
	}
}

func (ptr *QPainterPath) FillRule() core.Qt__FillRule {
	defer qt.Recovering("QPainterPath::fillRule")

	if ptr.Pointer() != nil {
		return core.Qt__FillRule(C.QPainterPath_FillRule(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainterPath) Intersects2(p QPainterPath_ITF) bool {
	defer qt.Recovering("QPainterPath::intersects")

	if ptr.Pointer() != nil {
		return C.QPainterPath_Intersects2(ptr.Pointer(), PointerFromQPainterPath(p)) != 0
	}
	return false
}

func (ptr *QPainterPath) Length() float64 {
	defer qt.Recovering("QPainterPath::length")

	if ptr.Pointer() != nil {
		return float64(C.QPainterPath_Length(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainterPath) LineTo2(x float64, y float64) {
	defer qt.Recovering("QPainterPath::lineTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_LineTo2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QPainterPath) MoveTo2(x float64, y float64) {
	defer qt.Recovering("QPainterPath::moveTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_MoveTo2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QPainterPath) PercentAtLength(len float64) float64 {
	defer qt.Recovering("QPainterPath::percentAtLength")

	if ptr.Pointer() != nil {
		return float64(C.QPainterPath_PercentAtLength(ptr.Pointer(), C.double(len)))
	}
	return 0
}

func (ptr *QPainterPath) QuadTo2(cx float64, cy float64, endPointX float64, endPointY float64) {
	defer qt.Recovering("QPainterPath::quadTo")

	if ptr.Pointer() != nil {
		C.QPainterPath_QuadTo2(ptr.Pointer(), C.double(cx), C.double(cy), C.double(endPointX), C.double(endPointY))
	}
}

func (ptr *QPainterPath) SlopeAtPercent(t float64) float64 {
	defer qt.Recovering("QPainterPath::slopeAtPercent")

	if ptr.Pointer() != nil {
		return float64(C.QPainterPath_SlopeAtPercent(ptr.Pointer(), C.double(t)))
	}
	return 0
}

func (ptr *QPainterPath) Swap(other QPainterPath_ITF) {
	defer qt.Recovering("QPainterPath::swap")

	if ptr.Pointer() != nil {
		C.QPainterPath_Swap(ptr.Pointer(), PointerFromQPainterPath(other))
	}
}

func (ptr *QPainterPath) Translate2(offset core.QPointF_ITF) {
	defer qt.Recovering("QPainterPath::translate")

	if ptr.Pointer() != nil {
		C.QPainterPath_Translate2(ptr.Pointer(), core.PointerFromQPointF(offset))
	}
}

func (ptr *QPainterPath) Translate(dx float64, dy float64) {
	defer qt.Recovering("QPainterPath::translate")

	if ptr.Pointer() != nil {
		C.QPainterPath_Translate(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

func (ptr *QPainterPath) DestroyQPainterPath() {
	defer qt.Recovering("QPainterPath::~QPainterPath")

	if ptr.Pointer() != nil {
		C.QPainterPath_DestroyQPainterPath(ptr.Pointer())
	}
}

type QPainterPathStroker struct {
	ptr unsafe.Pointer
}

type QPainterPathStroker_ITF interface {
	QPainterPathStroker_PTR() *QPainterPathStroker
}

func (p *QPainterPathStroker) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPainterPathStroker) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPainterPathStroker(ptr QPainterPathStroker_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPainterPathStroker_PTR().Pointer()
	}
	return nil
}

func NewQPainterPathStrokerFromPointer(ptr unsafe.Pointer) *QPainterPathStroker {
	var n = new(QPainterPathStroker)
	n.SetPointer(ptr)
	return n
}

func newQPainterPathStrokerFromPointer(ptr unsafe.Pointer) *QPainterPathStroker {
	var n = NewQPainterPathStrokerFromPointer(ptr)
	return n
}

func (ptr *QPainterPathStroker) QPainterPathStroker_PTR() *QPainterPathStroker {
	return ptr
}

func NewQPainterPathStroker() *QPainterPathStroker {
	defer qt.Recovering("QPainterPathStroker::QPainterPathStroker")

	return newQPainterPathStrokerFromPointer(C.QPainterPathStroker_NewQPainterPathStroker())
}

func NewQPainterPathStroker2(pen QPen_ITF) *QPainterPathStroker {
	defer qt.Recovering("QPainterPathStroker::QPainterPathStroker")

	return newQPainterPathStrokerFromPointer(C.QPainterPathStroker_NewQPainterPathStroker2(PointerFromQPen(pen)))
}

func (ptr *QPainterPathStroker) CapStyle() core.Qt__PenCapStyle {
	defer qt.Recovering("QPainterPathStroker::capStyle")

	if ptr.Pointer() != nil {
		return core.Qt__PenCapStyle(C.QPainterPathStroker_CapStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainterPathStroker) CurveThreshold() float64 {
	defer qt.Recovering("QPainterPathStroker::curveThreshold")

	if ptr.Pointer() != nil {
		return float64(C.QPainterPathStroker_CurveThreshold(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainterPathStroker) DashOffset() float64 {
	defer qt.Recovering("QPainterPathStroker::dashOffset")

	if ptr.Pointer() != nil {
		return float64(C.QPainterPathStroker_DashOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainterPathStroker) JoinStyle() core.Qt__PenJoinStyle {
	defer qt.Recovering("QPainterPathStroker::joinStyle")

	if ptr.Pointer() != nil {
		return core.Qt__PenJoinStyle(C.QPainterPathStroker_JoinStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainterPathStroker) MiterLimit() float64 {
	defer qt.Recovering("QPainterPathStroker::miterLimit")

	if ptr.Pointer() != nil {
		return float64(C.QPainterPathStroker_MiterLimit(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainterPathStroker) SetCapStyle(style core.Qt__PenCapStyle) {
	defer qt.Recovering("QPainterPathStroker::setCapStyle")

	if ptr.Pointer() != nil {
		C.QPainterPathStroker_SetCapStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QPainterPathStroker) SetCurveThreshold(threshold float64) {
	defer qt.Recovering("QPainterPathStroker::setCurveThreshold")

	if ptr.Pointer() != nil {
		C.QPainterPathStroker_SetCurveThreshold(ptr.Pointer(), C.double(threshold))
	}
}

func (ptr *QPainterPathStroker) SetDashOffset(offset float64) {
	defer qt.Recovering("QPainterPathStroker::setDashOffset")

	if ptr.Pointer() != nil {
		C.QPainterPathStroker_SetDashOffset(ptr.Pointer(), C.double(offset))
	}
}

func (ptr *QPainterPathStroker) SetDashPattern(style core.Qt__PenStyle) {
	defer qt.Recovering("QPainterPathStroker::setDashPattern")

	if ptr.Pointer() != nil {
		C.QPainterPathStroker_SetDashPattern(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QPainterPathStroker) SetJoinStyle(style core.Qt__PenJoinStyle) {
	defer qt.Recovering("QPainterPathStroker::setJoinStyle")

	if ptr.Pointer() != nil {
		C.QPainterPathStroker_SetJoinStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QPainterPathStroker) SetMiterLimit(limit float64) {
	defer qt.Recovering("QPainterPathStroker::setMiterLimit")

	if ptr.Pointer() != nil {
		C.QPainterPathStroker_SetMiterLimit(ptr.Pointer(), C.double(limit))
	}
}

func (ptr *QPainterPathStroker) SetWidth(width float64) {
	defer qt.Recovering("QPainterPathStroker::setWidth")

	if ptr.Pointer() != nil {
		C.QPainterPathStroker_SetWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QPainterPathStroker) Width() float64 {
	defer qt.Recovering("QPainterPathStroker::width")

	if ptr.Pointer() != nil {
		return float64(C.QPainterPathStroker_Width(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPainterPathStroker) DestroyQPainterPathStroker() {
	defer qt.Recovering("QPainterPathStroker::~QPainterPathStroker")

	if ptr.Pointer() != nil {
		C.QPainterPathStroker_DestroyQPainterPathStroker(ptr.Pointer())
	}
}

type QPalette struct {
	ptr unsafe.Pointer
}

type QPalette_ITF interface {
	QPalette_PTR() *QPalette
}

func (p *QPalette) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPalette) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPalette(ptr QPalette_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPalette_PTR().Pointer()
	}
	return nil
}

func NewQPaletteFromPointer(ptr unsafe.Pointer) *QPalette {
	var n = new(QPalette)
	n.SetPointer(ptr)
	return n
}

func newQPaletteFromPointer(ptr unsafe.Pointer) *QPalette {
	var n = NewQPaletteFromPointer(ptr)
	return n
}

func (ptr *QPalette) QPalette_PTR() *QPalette {
	return ptr
}

//QPalette::ColorGroup
type QPalette__ColorGroup int64

const (
	QPalette__Active       = QPalette__ColorGroup(0)
	QPalette__Disabled     = QPalette__ColorGroup(1)
	QPalette__Inactive     = QPalette__ColorGroup(2)
	QPalette__NColorGroups = QPalette__ColorGroup(3)
	QPalette__Current      = QPalette__ColorGroup(4)
	QPalette__All          = QPalette__ColorGroup(5)
	QPalette__Normal       = QPalette__ColorGroup(QPalette__Active)
)

//QPalette::ColorRole
type QPalette__ColorRole int64

var (
	QPalette__WindowText      = QPalette__ColorRole(0)
	QPalette__Button          = QPalette__ColorRole(1)
	QPalette__Light           = QPalette__ColorRole(2)
	QPalette__Midlight        = QPalette__ColorRole(3)
	QPalette__Dark            = QPalette__ColorRole(4)
	QPalette__Mid             = QPalette__ColorRole(5)
	QPalette__Text            = QPalette__ColorRole(6)
	QPalette__BrightText      = QPalette__ColorRole(7)
	QPalette__ButtonText      = QPalette__ColorRole(8)
	QPalette__Base            = QPalette__ColorRole(9)
	QPalette__Window          = QPalette__ColorRole(10)
	QPalette__Shadow          = QPalette__ColorRole(11)
	QPalette__Highlight       = QPalette__ColorRole(12)
	QPalette__HighlightedText = QPalette__ColorRole(13)
	QPalette__Link            = QPalette__ColorRole(14)
	QPalette__LinkVisited     = QPalette__ColorRole(15)
	QPalette__AlternateBase   = QPalette__ColorRole(16)
	QPalette__NoRole          = QPalette__ColorRole(17)
	QPalette__ToolTipBase     = QPalette__ColorRole(18)
	QPalette__ToolTipText     = QPalette__ColorRole(19)
	QPalette__NColorRoles     = QPalette__ColorRole(C.QPalette_NColorRoles_Type())
	QPalette__Foreground      = QPalette__ColorRole(QPalette__WindowText)
	QPalette__Background      = QPalette__ColorRole(QPalette__Window)
)

func (ptr *QPalette) Brush(group QPalette__ColorGroup, role QPalette__ColorRole) *QBrush {
	defer qt.Recovering("QPalette::brush")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Brush(ptr.Pointer(), C.int(group), C.int(role)))
	}
	return nil
}

func (ptr *QPalette) IsEqual(cg1 QPalette__ColorGroup, cg2 QPalette__ColorGroup) bool {
	defer qt.Recovering("QPalette::isEqual")

	if ptr.Pointer() != nil {
		return C.QPalette_IsEqual(ptr.Pointer(), C.int(cg1), C.int(cg2)) != 0
	}
	return false
}

func (ptr *QPalette) SetBrush2(group QPalette__ColorGroup, role QPalette__ColorRole, brush QBrush_ITF) {
	defer qt.Recovering("QPalette::setBrush")

	if ptr.Pointer() != nil {
		C.QPalette_SetBrush2(ptr.Pointer(), C.int(group), C.int(role), PointerFromQBrush(brush))
	}
}

func NewQPalette() *QPalette {
	defer qt.Recovering("QPalette::QPalette")

	return newQPaletteFromPointer(C.QPalette_NewQPalette())
}

func NewQPalette8(other QPalette_ITF) *QPalette {
	defer qt.Recovering("QPalette::QPalette")

	return newQPaletteFromPointer(C.QPalette_NewQPalette8(PointerFromQPalette(other)))
}

func NewQPalette3(button core.Qt__GlobalColor) *QPalette {
	defer qt.Recovering("QPalette::QPalette")

	return newQPaletteFromPointer(C.QPalette_NewQPalette3(C.int(button)))
}

func NewQPalette5(windowText QBrush_ITF, button QBrush_ITF, light QBrush_ITF, dark QBrush_ITF, mid QBrush_ITF, text QBrush_ITF, bright_text QBrush_ITF, base QBrush_ITF, window QBrush_ITF) *QPalette {
	defer qt.Recovering("QPalette::QPalette")

	return newQPaletteFromPointer(C.QPalette_NewQPalette5(PointerFromQBrush(windowText), PointerFromQBrush(button), PointerFromQBrush(light), PointerFromQBrush(dark), PointerFromQBrush(mid), PointerFromQBrush(text), PointerFromQBrush(bright_text), PointerFromQBrush(base), PointerFromQBrush(window)))
}

func NewQPalette2(button QColor_ITF) *QPalette {
	defer qt.Recovering("QPalette::QPalette")

	return newQPaletteFromPointer(C.QPalette_NewQPalette2(PointerFromQColor(button)))
}

func NewQPalette4(button QColor_ITF, window QColor_ITF) *QPalette {
	defer qt.Recovering("QPalette::QPalette")

	return newQPaletteFromPointer(C.QPalette_NewQPalette4(PointerFromQColor(button), PointerFromQColor(window)))
}

func NewQPalette7(p QPalette_ITF) *QPalette {
	defer qt.Recovering("QPalette::QPalette")

	return newQPaletteFromPointer(C.QPalette_NewQPalette7(PointerFromQPalette(p)))
}

func (ptr *QPalette) AlternateBase() *QBrush {
	defer qt.Recovering("QPalette::alternateBase")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_AlternateBase(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) Base() *QBrush {
	defer qt.Recovering("QPalette::base")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Base(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) BrightText() *QBrush {
	defer qt.Recovering("QPalette::brightText")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_BrightText(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) Brush2(role QPalette__ColorRole) *QBrush {
	defer qt.Recovering("QPalette::brush")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Brush2(ptr.Pointer(), C.int(role)))
	}
	return nil
}

func (ptr *QPalette) Button() *QBrush {
	defer qt.Recovering("QPalette::button")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Button(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) ButtonText() *QBrush {
	defer qt.Recovering("QPalette::buttonText")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_ButtonText(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) CacheKey() int64 {
	defer qt.Recovering("QPalette::cacheKey")

	if ptr.Pointer() != nil {
		return int64(C.QPalette_CacheKey(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPalette) Color(group QPalette__ColorGroup, role QPalette__ColorRole) *QColor {
	defer qt.Recovering("QPalette::color")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QPalette_Color(ptr.Pointer(), C.int(group), C.int(role)))
	}
	return nil
}

func (ptr *QPalette) Color2(role QPalette__ColorRole) *QColor {
	defer qt.Recovering("QPalette::color")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QPalette_Color2(ptr.Pointer(), C.int(role)))
	}
	return nil
}

func (ptr *QPalette) CurrentColorGroup() QPalette__ColorGroup {
	defer qt.Recovering("QPalette::currentColorGroup")

	if ptr.Pointer() != nil {
		return QPalette__ColorGroup(C.QPalette_CurrentColorGroup(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPalette) Dark() *QBrush {
	defer qt.Recovering("QPalette::dark")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Dark(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) Highlight() *QBrush {
	defer qt.Recovering("QPalette::highlight")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Highlight(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) HighlightedText() *QBrush {
	defer qt.Recovering("QPalette::highlightedText")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_HighlightedText(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) IsBrushSet(cg QPalette__ColorGroup, cr QPalette__ColorRole) bool {
	defer qt.Recovering("QPalette::isBrushSet")

	if ptr.Pointer() != nil {
		return C.QPalette_IsBrushSet(ptr.Pointer(), C.int(cg), C.int(cr)) != 0
	}
	return false
}

func (ptr *QPalette) IsCopyOf(p QPalette_ITF) bool {
	defer qt.Recovering("QPalette::isCopyOf")

	if ptr.Pointer() != nil {
		return C.QPalette_IsCopyOf(ptr.Pointer(), PointerFromQPalette(p)) != 0
	}
	return false
}

func (ptr *QPalette) Light() *QBrush {
	defer qt.Recovering("QPalette::light")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Light(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) Link() *QBrush {
	defer qt.Recovering("QPalette::link")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Link(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) LinkVisited() *QBrush {
	defer qt.Recovering("QPalette::linkVisited")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_LinkVisited(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) Mid() *QBrush {
	defer qt.Recovering("QPalette::mid")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Mid(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) Midlight() *QBrush {
	defer qt.Recovering("QPalette::midlight")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Midlight(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) SetBrush(role QPalette__ColorRole, brush QBrush_ITF) {
	defer qt.Recovering("QPalette::setBrush")

	if ptr.Pointer() != nil {
		C.QPalette_SetBrush(ptr.Pointer(), C.int(role), PointerFromQBrush(brush))
	}
}

func (ptr *QPalette) SetColor(group QPalette__ColorGroup, role QPalette__ColorRole, color QColor_ITF) {
	defer qt.Recovering("QPalette::setColor")

	if ptr.Pointer() != nil {
		C.QPalette_SetColor(ptr.Pointer(), C.int(group), C.int(role), PointerFromQColor(color))
	}
}

func (ptr *QPalette) SetColor2(role QPalette__ColorRole, color QColor_ITF) {
	defer qt.Recovering("QPalette::setColor")

	if ptr.Pointer() != nil {
		C.QPalette_SetColor2(ptr.Pointer(), C.int(role), PointerFromQColor(color))
	}
}

func (ptr *QPalette) SetColorGroup(cg QPalette__ColorGroup, windowText QBrush_ITF, button QBrush_ITF, light QBrush_ITF, dark QBrush_ITF, mid QBrush_ITF, text QBrush_ITF, bright_text QBrush_ITF, base QBrush_ITF, window QBrush_ITF) {
	defer qt.Recovering("QPalette::setColorGroup")

	if ptr.Pointer() != nil {
		C.QPalette_SetColorGroup(ptr.Pointer(), C.int(cg), PointerFromQBrush(windowText), PointerFromQBrush(button), PointerFromQBrush(light), PointerFromQBrush(dark), PointerFromQBrush(mid), PointerFromQBrush(text), PointerFromQBrush(bright_text), PointerFromQBrush(base), PointerFromQBrush(window))
	}
}

func (ptr *QPalette) SetCurrentColorGroup(cg QPalette__ColorGroup) {
	defer qt.Recovering("QPalette::setCurrentColorGroup")

	if ptr.Pointer() != nil {
		C.QPalette_SetCurrentColorGroup(ptr.Pointer(), C.int(cg))
	}
}

func (ptr *QPalette) Shadow() *QBrush {
	defer qt.Recovering("QPalette::shadow")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Shadow(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) Swap(other QPalette_ITF) {
	defer qt.Recovering("QPalette::swap")

	if ptr.Pointer() != nil {
		C.QPalette_Swap(ptr.Pointer(), PointerFromQPalette(other))
	}
}

func (ptr *QPalette) Text() *QBrush {
	defer qt.Recovering("QPalette::text")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Text(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) ToolTipBase() *QBrush {
	defer qt.Recovering("QPalette::toolTipBase")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_ToolTipBase(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) ToolTipText() *QBrush {
	defer qt.Recovering("QPalette::toolTipText")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_ToolTipText(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) Window() *QBrush {
	defer qt.Recovering("QPalette::window")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_Window(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) WindowText() *QBrush {
	defer qt.Recovering("QPalette::windowText")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPalette_WindowText(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPalette) DestroyQPalette() {
	defer qt.Recovering("QPalette::~QPalette")

	if ptr.Pointer() != nil {
		C.QPalette_DestroyQPalette(ptr.Pointer())
	}
}

type QPdfWriter struct {
	core.QObject
	QPagedPaintDevice
}

type QPdfWriter_ITF interface {
	core.QObject_ITF
	QPagedPaintDevice_ITF
	QPdfWriter_PTR() *QPdfWriter
}

func (p *QPdfWriter) Pointer() unsafe.Pointer {
	return p.QObject_PTR().Pointer()
}

func (p *QPdfWriter) SetPointer(ptr unsafe.Pointer) {
	p.QObject_PTR().SetPointer(ptr)
	p.QPagedPaintDevice_PTR().SetPointer(ptr)
}

func PointerFromQPdfWriter(ptr QPdfWriter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPdfWriter_PTR().Pointer()
	}
	return nil
}

func NewQPdfWriterFromPointer(ptr unsafe.Pointer) *QPdfWriter {
	var n = new(QPdfWriter)
	n.SetPointer(ptr)
	return n
}

func newQPdfWriterFromPointer(ptr unsafe.Pointer) *QPdfWriter {
	var n = NewQPdfWriterFromPointer(ptr)
	for len(n.ObjectName()) < len("QPdfWriter_") {
		n.SetObjectName("QPdfWriter_" + qt.Identifier())
	}
	return n
}

func (ptr *QPdfWriter) QPdfWriter_PTR() *QPdfWriter {
	return ptr
}

func NewQPdfWriter2(device core.QIODevice_ITF) *QPdfWriter {
	defer qt.Recovering("QPdfWriter::QPdfWriter")

	return newQPdfWriterFromPointer(C.QPdfWriter_NewQPdfWriter2(core.PointerFromQIODevice(device)))
}

func NewQPdfWriter(filename string) *QPdfWriter {
	defer qt.Recovering("QPdfWriter::QPdfWriter")

	return newQPdfWriterFromPointer(C.QPdfWriter_NewQPdfWriter(C.CString(filename)))
}

func (ptr *QPdfWriter) Creator() string {
	defer qt.Recovering("QPdfWriter::creator")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPdfWriter_Creator(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPdfWriter) NewPage() bool {
	defer qt.Recovering("QPdfWriter::newPage")

	if ptr.Pointer() != nil {
		return C.QPdfWriter_NewPage(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPdfWriter) PaintEngine() *QPaintEngine {
	defer qt.Recovering("QPdfWriter::paintEngine")

	if ptr.Pointer() != nil {
		return NewQPaintEngineFromPointer(C.QPdfWriter_PaintEngine(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPdfWriter) Resolution() int {
	defer qt.Recovering("QPdfWriter::resolution")

	if ptr.Pointer() != nil {
		return int(C.QPdfWriter_Resolution(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPdfWriter) SetCreator(creator string) {
	defer qt.Recovering("QPdfWriter::setCreator")

	if ptr.Pointer() != nil {
		C.QPdfWriter_SetCreator(ptr.Pointer(), C.CString(creator))
	}
}

func (ptr *QPdfWriter) SetPageLayout(newPageLayout QPageLayout_ITF) bool {
	defer qt.Recovering("QPdfWriter::setPageLayout")

	if ptr.Pointer() != nil {
		return C.QPdfWriter_SetPageLayout(ptr.Pointer(), PointerFromQPageLayout(newPageLayout)) != 0
	}
	return false
}

func (ptr *QPdfWriter) SetPageMargins(margins core.QMarginsF_ITF) bool {
	defer qt.Recovering("QPdfWriter::setPageMargins")

	if ptr.Pointer() != nil {
		return C.QPdfWriter_SetPageMargins(ptr.Pointer(), core.PointerFromQMarginsF(margins)) != 0
	}
	return false
}

func (ptr *QPdfWriter) SetPageMargins2(margins core.QMarginsF_ITF, units QPageLayout__Unit) bool {
	defer qt.Recovering("QPdfWriter::setPageMargins")

	if ptr.Pointer() != nil {
		return C.QPdfWriter_SetPageMargins2(ptr.Pointer(), core.PointerFromQMarginsF(margins), C.int(units)) != 0
	}
	return false
}

func (ptr *QPdfWriter) SetPageOrientation(orientation QPageLayout__Orientation) bool {
	defer qt.Recovering("QPdfWriter::setPageOrientation")

	if ptr.Pointer() != nil {
		return C.QPdfWriter_SetPageOrientation(ptr.Pointer(), C.int(orientation)) != 0
	}
	return false
}

func (ptr *QPdfWriter) SetPageSize(pageSize QPageSize_ITF) bool {
	defer qt.Recovering("QPdfWriter::setPageSize")

	if ptr.Pointer() != nil {
		return C.QPdfWriter_SetPageSize(ptr.Pointer(), PointerFromQPageSize(pageSize)) != 0
	}
	return false
}

func (ptr *QPdfWriter) SetResolution(resolution int) {
	defer qt.Recovering("QPdfWriter::setResolution")

	if ptr.Pointer() != nil {
		C.QPdfWriter_SetResolution(ptr.Pointer(), C.int(resolution))
	}
}

func (ptr *QPdfWriter) SetTitle(title string) {
	defer qt.Recovering("QPdfWriter::setTitle")

	if ptr.Pointer() != nil {
		C.QPdfWriter_SetTitle(ptr.Pointer(), C.CString(title))
	}
}

func (ptr *QPdfWriter) Title() string {
	defer qt.Recovering("QPdfWriter::title")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPdfWriter_Title(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPdfWriter) DestroyQPdfWriter() {
	defer qt.Recovering("QPdfWriter::~QPdfWriter")

	if ptr.Pointer() != nil {
		C.QPdfWriter_DestroyQPdfWriter(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QPdfWriter) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QPdfWriter::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QPdfWriter) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QPdfWriter::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQPdfWriterTimerEvent
func callbackQPdfWriterTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPdfWriter::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQPdfWriterFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QPdfWriter) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QPdfWriter::timerEvent")

	if ptr.Pointer() != nil {
		C.QPdfWriter_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QPdfWriter) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QPdfWriter::timerEvent")

	if ptr.Pointer() != nil {
		C.QPdfWriter_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QPdfWriter) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QPdfWriter::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QPdfWriter) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QPdfWriter::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQPdfWriterChildEvent
func callbackQPdfWriterChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPdfWriter::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQPdfWriterFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QPdfWriter) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QPdfWriter::childEvent")

	if ptr.Pointer() != nil {
		C.QPdfWriter_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QPdfWriter) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QPdfWriter::childEvent")

	if ptr.Pointer() != nil {
		C.QPdfWriter_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QPdfWriter) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QPdfWriter::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QPdfWriter) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QPdfWriter::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQPdfWriterCustomEvent
func callbackQPdfWriterCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QPdfWriter::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQPdfWriterFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QPdfWriter) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QPdfWriter::customEvent")

	if ptr.Pointer() != nil {
		C.QPdfWriter_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QPdfWriter) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QPdfWriter::customEvent")

	if ptr.Pointer() != nil {
		C.QPdfWriter_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QPen struct {
	ptr unsafe.Pointer
}

type QPen_ITF interface {
	QPen_PTR() *QPen
}

func (p *QPen) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPen) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPen(ptr QPen_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPen_PTR().Pointer()
	}
	return nil
}

func NewQPenFromPointer(ptr unsafe.Pointer) *QPen {
	var n = new(QPen)
	n.SetPointer(ptr)
	return n
}

func newQPenFromPointer(ptr unsafe.Pointer) *QPen {
	var n = NewQPenFromPointer(ptr)
	return n
}

func (ptr *QPen) QPen_PTR() *QPen {
	return ptr
}

func NewQPen4(brush QBrush_ITF, width float64, style core.Qt__PenStyle, cap core.Qt__PenCapStyle, join core.Qt__PenJoinStyle) *QPen {
	defer qt.Recovering("QPen::QPen")

	return newQPenFromPointer(C.QPen_NewQPen4(PointerFromQBrush(brush), C.double(width), C.int(style), C.int(cap), C.int(join)))
}

func NewQPen5(pen QPen_ITF) *QPen {
	defer qt.Recovering("QPen::QPen")

	return newQPenFromPointer(C.QPen_NewQPen5(PointerFromQPen(pen)))
}

func (ptr *QPen) Color() *QColor {
	defer qt.Recovering("QPen::color")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QPen_Color(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPen) SetCapStyle(style core.Qt__PenCapStyle) {
	defer qt.Recovering("QPen::setCapStyle")

	if ptr.Pointer() != nil {
		C.QPen_SetCapStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QPen) SetColor(color QColor_ITF) {
	defer qt.Recovering("QPen::setColor")

	if ptr.Pointer() != nil {
		C.QPen_SetColor(ptr.Pointer(), PointerFromQColor(color))
	}
}

func (ptr *QPen) SetJoinStyle(style core.Qt__PenJoinStyle) {
	defer qt.Recovering("QPen::setJoinStyle")

	if ptr.Pointer() != nil {
		C.QPen_SetJoinStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QPen) SetStyle(style core.Qt__PenStyle) {
	defer qt.Recovering("QPen::setStyle")

	if ptr.Pointer() != nil {
		C.QPen_SetStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QPen) SetWidth(width int) {
	defer qt.Recovering("QPen::setWidth")

	if ptr.Pointer() != nil {
		C.QPen_SetWidth(ptr.Pointer(), C.int(width))
	}
}

func (ptr *QPen) Style() core.Qt__PenStyle {
	defer qt.Recovering("QPen::style")

	if ptr.Pointer() != nil {
		return core.Qt__PenStyle(C.QPen_Style(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPen) Width() int {
	defer qt.Recovering("QPen::width")

	if ptr.Pointer() != nil {
		return int(C.QPen_Width(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPen) WidthF() float64 {
	defer qt.Recovering("QPen::widthF")

	if ptr.Pointer() != nil {
		return float64(C.QPen_WidthF(ptr.Pointer()))
	}
	return 0
}

func NewQPen() *QPen {
	defer qt.Recovering("QPen::QPen")

	return newQPenFromPointer(C.QPen_NewQPen())
}

func NewQPen6(pen QPen_ITF) *QPen {
	defer qt.Recovering("QPen::QPen")

	return newQPenFromPointer(C.QPen_NewQPen6(PointerFromQPen(pen)))
}

func NewQPen2(style core.Qt__PenStyle) *QPen {
	defer qt.Recovering("QPen::QPen")

	return newQPenFromPointer(C.QPen_NewQPen2(C.int(style)))
}

func NewQPen3(color QColor_ITF) *QPen {
	defer qt.Recovering("QPen::QPen")

	return newQPenFromPointer(C.QPen_NewQPen3(PointerFromQColor(color)))
}

func (ptr *QPen) Brush() *QBrush {
	defer qt.Recovering("QPen::brush")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QPen_Brush(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPen) CapStyle() core.Qt__PenCapStyle {
	defer qt.Recovering("QPen::capStyle")

	if ptr.Pointer() != nil {
		return core.Qt__PenCapStyle(C.QPen_CapStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPen) DashOffset() float64 {
	defer qt.Recovering("QPen::dashOffset")

	if ptr.Pointer() != nil {
		return float64(C.QPen_DashOffset(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPen) IsCosmetic() bool {
	defer qt.Recovering("QPen::isCosmetic")

	if ptr.Pointer() != nil {
		return C.QPen_IsCosmetic(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPen) IsSolid() bool {
	defer qt.Recovering("QPen::isSolid")

	if ptr.Pointer() != nil {
		return C.QPen_IsSolid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPen) JoinStyle() core.Qt__PenJoinStyle {
	defer qt.Recovering("QPen::joinStyle")

	if ptr.Pointer() != nil {
		return core.Qt__PenJoinStyle(C.QPen_JoinStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPen) MiterLimit() float64 {
	defer qt.Recovering("QPen::miterLimit")

	if ptr.Pointer() != nil {
		return float64(C.QPen_MiterLimit(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPen) SetBrush(brush QBrush_ITF) {
	defer qt.Recovering("QPen::setBrush")

	if ptr.Pointer() != nil {
		C.QPen_SetBrush(ptr.Pointer(), PointerFromQBrush(brush))
	}
}

func (ptr *QPen) SetCosmetic(cosmetic bool) {
	defer qt.Recovering("QPen::setCosmetic")

	if ptr.Pointer() != nil {
		C.QPen_SetCosmetic(ptr.Pointer(), C.int(qt.GoBoolToInt(cosmetic)))
	}
}

func (ptr *QPen) SetDashOffset(offset float64) {
	defer qt.Recovering("QPen::setDashOffset")

	if ptr.Pointer() != nil {
		C.QPen_SetDashOffset(ptr.Pointer(), C.double(offset))
	}
}

func (ptr *QPen) SetMiterLimit(limit float64) {
	defer qt.Recovering("QPen::setMiterLimit")

	if ptr.Pointer() != nil {
		C.QPen_SetMiterLimit(ptr.Pointer(), C.double(limit))
	}
}

func (ptr *QPen) SetWidthF(width float64) {
	defer qt.Recovering("QPen::setWidthF")

	if ptr.Pointer() != nil {
		C.QPen_SetWidthF(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QPen) Swap(other QPen_ITF) {
	defer qt.Recovering("QPen::swap")

	if ptr.Pointer() != nil {
		C.QPen_Swap(ptr.Pointer(), PointerFromQPen(other))
	}
}

func (ptr *QPen) DestroyQPen() {
	defer qt.Recovering("QPen::~QPen")

	if ptr.Pointer() != nil {
		C.QPen_DestroyQPen(ptr.Pointer())
	}
}

type QPicture struct {
	QPaintDevice
}

type QPicture_ITF interface {
	QPaintDevice_ITF
	QPicture_PTR() *QPicture
}

func PointerFromQPicture(ptr QPicture_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPicture_PTR().Pointer()
	}
	return nil
}

func NewQPictureFromPointer(ptr unsafe.Pointer) *QPicture {
	var n = new(QPicture)
	n.SetPointer(ptr)
	return n
}

func newQPictureFromPointer(ptr unsafe.Pointer) *QPicture {
	var n = NewQPictureFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QPicture_") {
		n.SetObjectNameAbs("QPicture_" + qt.Identifier())
	}
	return n
}

func (ptr *QPicture) QPicture_PTR() *QPicture {
	return ptr
}

func (ptr *QPicture) IsNull() bool {
	defer qt.Recovering("QPicture::isNull")

	if ptr.Pointer() != nil {
		return C.QPicture_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func NewQPicture2(pic QPicture_ITF) *QPicture {
	defer qt.Recovering("QPicture::QPicture")

	return newQPictureFromPointer(C.QPicture_NewQPicture2(PointerFromQPicture(pic)))
}

func NewQPicture(formatVersion int) *QPicture {
	defer qt.Recovering("QPicture::QPicture")

	return newQPictureFromPointer(C.QPicture_NewQPicture(C.int(formatVersion)))
}

func (ptr *QPicture) BoundingRect() *core.QRect {
	defer qt.Recovering("QPicture::boundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPicture_BoundingRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPicture) Load2(dev core.QIODevice_ITF, format string) bool {
	defer qt.Recovering("QPicture::load")

	if ptr.Pointer() != nil {
		return C.QPicture_Load2(ptr.Pointer(), core.PointerFromQIODevice(dev), C.CString(format)) != 0
	}
	return false
}

func (ptr *QPicture) Load(fileName string, format string) bool {
	defer qt.Recovering("QPicture::load")

	if ptr.Pointer() != nil {
		return C.QPicture_Load(ptr.Pointer(), C.CString(fileName), C.CString(format)) != 0
	}
	return false
}

func (ptr *QPicture) Play(painter QPainter_ITF) bool {
	defer qt.Recovering("QPicture::play")

	if ptr.Pointer() != nil {
		return C.QPicture_Play(ptr.Pointer(), PointerFromQPainter(painter)) != 0
	}
	return false
}

func (ptr *QPicture) Save2(dev core.QIODevice_ITF, format string) bool {
	defer qt.Recovering("QPicture::save")

	if ptr.Pointer() != nil {
		return C.QPicture_Save2(ptr.Pointer(), core.PointerFromQIODevice(dev), C.CString(format)) != 0
	}
	return false
}

func (ptr *QPicture) Save(fileName string, format string) bool {
	defer qt.Recovering("QPicture::save")

	if ptr.Pointer() != nil {
		return C.QPicture_Save(ptr.Pointer(), C.CString(fileName), C.CString(format)) != 0
	}
	return false
}

func (ptr *QPicture) SetBoundingRect(r core.QRect_ITF) {
	defer qt.Recovering("QPicture::setBoundingRect")

	if ptr.Pointer() != nil {
		C.QPicture_SetBoundingRect(ptr.Pointer(), core.PointerFromQRect(r))
	}
}

func (ptr *QPicture) Swap(other QPicture_ITF) {
	defer qt.Recovering("QPicture::swap")

	if ptr.Pointer() != nil {
		C.QPicture_Swap(ptr.Pointer(), PointerFromQPicture(other))
	}
}

func (ptr *QPicture) DestroyQPicture() {
	defer qt.Recovering("QPicture::~QPicture")

	if ptr.Pointer() != nil {
		C.QPicture_DestroyQPicture(ptr.Pointer())
	}
}

func (ptr *QPicture) ObjectNameAbs() string {
	defer qt.Recovering("QPicture::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QPicture_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QPicture) SetObjectNameAbs(name string) {
	defer qt.Recovering("QPicture::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QPicture_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QPixelFormat struct {
	ptr unsafe.Pointer
}

type QPixelFormat_ITF interface {
	QPixelFormat_PTR() *QPixelFormat
}

func (p *QPixelFormat) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPixelFormat) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPixelFormat(ptr QPixelFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPixelFormat_PTR().Pointer()
	}
	return nil
}

func NewQPixelFormatFromPointer(ptr unsafe.Pointer) *QPixelFormat {
	var n = new(QPixelFormat)
	n.SetPointer(ptr)
	return n
}

func newQPixelFormatFromPointer(ptr unsafe.Pointer) *QPixelFormat {
	var n = NewQPixelFormatFromPointer(ptr)
	return n
}

func (ptr *QPixelFormat) QPixelFormat_PTR() *QPixelFormat {
	return ptr
}

//QPixelFormat::AlphaPosition
type QPixelFormat__AlphaPosition int64

const (
	QPixelFormat__AtBeginning = QPixelFormat__AlphaPosition(0)
	QPixelFormat__AtEnd       = QPixelFormat__AlphaPosition(1)
)

//QPixelFormat::AlphaPremultiplied
type QPixelFormat__AlphaPremultiplied int64

const (
	QPixelFormat__NotPremultiplied = QPixelFormat__AlphaPremultiplied(0)
	QPixelFormat__Premultiplied    = QPixelFormat__AlphaPremultiplied(1)
)

//QPixelFormat::AlphaUsage
type QPixelFormat__AlphaUsage int64

const (
	QPixelFormat__UsesAlpha    = QPixelFormat__AlphaUsage(0)
	QPixelFormat__IgnoresAlpha = QPixelFormat__AlphaUsage(1)
)

//QPixelFormat::ByteOrder
type QPixelFormat__ByteOrder int64

const (
	QPixelFormat__LittleEndian        = QPixelFormat__ByteOrder(0)
	QPixelFormat__BigEndian           = QPixelFormat__ByteOrder(1)
	QPixelFormat__CurrentSystemEndian = QPixelFormat__ByteOrder(2)
)

//QPixelFormat::ColorModel
type QPixelFormat__ColorModel int64

const (
	QPixelFormat__RGB       = QPixelFormat__ColorModel(0)
	QPixelFormat__BGR       = QPixelFormat__ColorModel(1)
	QPixelFormat__Indexed   = QPixelFormat__ColorModel(2)
	QPixelFormat__Grayscale = QPixelFormat__ColorModel(3)
	QPixelFormat__CMYK      = QPixelFormat__ColorModel(4)
	QPixelFormat__HSL       = QPixelFormat__ColorModel(5)
	QPixelFormat__HSV       = QPixelFormat__ColorModel(6)
	QPixelFormat__YUV       = QPixelFormat__ColorModel(7)
	QPixelFormat__Alpha     = QPixelFormat__ColorModel(8)
)

//QPixelFormat::TypeInterpretation
type QPixelFormat__TypeInterpretation int64

const (
	QPixelFormat__UnsignedInteger = QPixelFormat__TypeInterpretation(0)
	QPixelFormat__UnsignedShort   = QPixelFormat__TypeInterpretation(1)
	QPixelFormat__UnsignedByte    = QPixelFormat__TypeInterpretation(2)
	QPixelFormat__FloatingPoint   = QPixelFormat__TypeInterpretation(3)
)

//QPixelFormat::YUVLayout
type QPixelFormat__YUVLayout int64

const (
	QPixelFormat__YUV444   = QPixelFormat__YUVLayout(0)
	QPixelFormat__YUV422   = QPixelFormat__YUVLayout(1)
	QPixelFormat__YUV411   = QPixelFormat__YUVLayout(2)
	QPixelFormat__YUV420P  = QPixelFormat__YUVLayout(3)
	QPixelFormat__YUV420SP = QPixelFormat__YUVLayout(4)
	QPixelFormat__YV12     = QPixelFormat__YUVLayout(5)
	QPixelFormat__UYVY     = QPixelFormat__YUVLayout(6)
	QPixelFormat__YUYV     = QPixelFormat__YUVLayout(7)
	QPixelFormat__NV12     = QPixelFormat__YUVLayout(8)
	QPixelFormat__NV21     = QPixelFormat__YUVLayout(9)
	QPixelFormat__IMC1     = QPixelFormat__YUVLayout(10)
	QPixelFormat__IMC2     = QPixelFormat__YUVLayout(11)
	QPixelFormat__IMC3     = QPixelFormat__YUVLayout(12)
	QPixelFormat__IMC4     = QPixelFormat__YUVLayout(13)
	QPixelFormat__Y8       = QPixelFormat__YUVLayout(14)
	QPixelFormat__Y16      = QPixelFormat__YUVLayout(15)
)

func NewQPixelFormat() *QPixelFormat {
	defer qt.Recovering("QPixelFormat::QPixelFormat")

	return newQPixelFormatFromPointer(C.QPixelFormat_NewQPixelFormat())
}

func (ptr *QPixelFormat) AlphaPosition() QPixelFormat__AlphaPosition {
	defer qt.Recovering("QPixelFormat::alphaPosition")

	if ptr.Pointer() != nil {
		return QPixelFormat__AlphaPosition(C.QPixelFormat_AlphaPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixelFormat) AlphaUsage() QPixelFormat__AlphaUsage {
	defer qt.Recovering("QPixelFormat::alphaUsage")

	if ptr.Pointer() != nil {
		return QPixelFormat__AlphaUsage(C.QPixelFormat_AlphaUsage(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixelFormat) ByteOrder() QPixelFormat__ByteOrder {
	defer qt.Recovering("QPixelFormat::byteOrder")

	if ptr.Pointer() != nil {
		return QPixelFormat__ByteOrder(C.QPixelFormat_ByteOrder(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixelFormat) ColorModel() QPixelFormat__ColorModel {
	defer qt.Recovering("QPixelFormat::colorModel")

	if ptr.Pointer() != nil {
		return QPixelFormat__ColorModel(C.QPixelFormat_ColorModel(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixelFormat) Premultiplied() QPixelFormat__AlphaPremultiplied {
	defer qt.Recovering("QPixelFormat::premultiplied")

	if ptr.Pointer() != nil {
		return QPixelFormat__AlphaPremultiplied(C.QPixelFormat_Premultiplied(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixelFormat) TypeInterpretation() QPixelFormat__TypeInterpretation {
	defer qt.Recovering("QPixelFormat::typeInterpretation")

	if ptr.Pointer() != nil {
		return QPixelFormat__TypeInterpretation(C.QPixelFormat_TypeInterpretation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixelFormat) YuvLayout() QPixelFormat__YUVLayout {
	defer qt.Recovering("QPixelFormat::yuvLayout")

	if ptr.Pointer() != nil {
		return QPixelFormat__YUVLayout(C.QPixelFormat_YuvLayout(ptr.Pointer()))
	}
	return 0
}

type QPixmap struct {
	QPaintDevice
}

type QPixmap_ITF interface {
	QPaintDevice_ITF
	QPixmap_PTR() *QPixmap
}

func PointerFromQPixmap(ptr QPixmap_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPixmap_PTR().Pointer()
	}
	return nil
}

func NewQPixmapFromPointer(ptr unsafe.Pointer) *QPixmap {
	var n = new(QPixmap)
	n.SetPointer(ptr)
	return n
}

func newQPixmapFromPointer(ptr unsafe.Pointer) *QPixmap {
	var n = NewQPixmapFromPointer(ptr)
	return n
}

func (ptr *QPixmap) QPixmap_PTR() *QPixmap {
	return ptr
}

func NewQPixmap3(width int, height int) *QPixmap {
	defer qt.Recovering("QPixmap::QPixmap")

	return newQPixmapFromPointer(C.QPixmap_NewQPixmap3(C.int(width), C.int(height)))
}

func (ptr *QPixmap) Depth() int {
	defer qt.Recovering("QPixmap::depth")

	if ptr.Pointer() != nil {
		return int(C.QPixmap_Depth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixmap) Height() int {
	defer qt.Recovering("QPixmap::height")

	if ptr.Pointer() != nil {
		return int(C.QPixmap_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixmap) IsNull() bool {
	defer qt.Recovering("QPixmap::isNull")

	if ptr.Pointer() != nil {
		return C.QPixmap_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPixmap) IsQBitmap() bool {
	defer qt.Recovering("QPixmap::isQBitmap")

	if ptr.Pointer() != nil {
		return C.QPixmap_IsQBitmap(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPixmap) Rect() *core.QRect {
	defer qt.Recovering("QPixmap::rect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPixmap_Rect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPixmap) Size() *core.QSize {
	defer qt.Recovering("QPixmap::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QPixmap_Size(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPixmap) Width() int {
	defer qt.Recovering("QPixmap::width")

	if ptr.Pointer() != nil {
		return int(C.QPixmap_Width(ptr.Pointer()))
	}
	return 0
}

func NewQPixmap() *QPixmap {
	defer qt.Recovering("QPixmap::QPixmap")

	return newQPixmapFromPointer(C.QPixmap_NewQPixmap())
}

func NewQPixmap6(pixmap QPixmap_ITF) *QPixmap {
	defer qt.Recovering("QPixmap::QPixmap")

	return newQPixmapFromPointer(C.QPixmap_NewQPixmap6(PointerFromQPixmap(pixmap)))
}

func NewQPixmap8(size core.QSize_ITF) *QPixmap {
	defer qt.Recovering("QPixmap::QPixmap")

	return newQPixmapFromPointer(C.QPixmap_NewQPixmap8(core.PointerFromQSize(size)))
}

func NewQPixmap4(fileName string, format string, flags core.Qt__ImageConversionFlag) *QPixmap {
	defer qt.Recovering("QPixmap::QPixmap")

	return newQPixmapFromPointer(C.QPixmap_NewQPixmap4(C.CString(fileName), C.CString(format), C.int(flags)))
}

func (ptr *QPixmap) CacheKey() int64 {
	defer qt.Recovering("QPixmap::cacheKey")

	if ptr.Pointer() != nil {
		return int64(C.QPixmap_CacheKey(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixmap) ConvertFromImage(image QImage_ITF, flags core.Qt__ImageConversionFlag) bool {
	defer qt.Recovering("QPixmap::convertFromImage")

	if ptr.Pointer() != nil {
		return C.QPixmap_ConvertFromImage(ptr.Pointer(), PointerFromQImage(image), C.int(flags)) != 0
	}
	return false
}

func QPixmap_DefaultDepth() int {
	defer qt.Recovering("QPixmap::defaultDepth")

	return int(C.QPixmap_QPixmap_DefaultDepth())
}

func (ptr *QPixmap) Detach() {
	defer qt.Recovering("QPixmap::detach")

	if ptr.Pointer() != nil {
		C.QPixmap_Detach(ptr.Pointer())
	}
}

func (ptr *QPixmap) DevicePixelRatio() float64 {
	defer qt.Recovering("QPixmap::devicePixelRatio")

	if ptr.Pointer() != nil {
		return float64(C.QPixmap_DevicePixelRatio(ptr.Pointer()))
	}
	return 0
}

func (ptr *QPixmap) Fill(color QColor_ITF) {
	defer qt.Recovering("QPixmap::fill")

	if ptr.Pointer() != nil {
		C.QPixmap_Fill(ptr.Pointer(), PointerFromQColor(color))
	}
}

func (ptr *QPixmap) HasAlpha() bool {
	defer qt.Recovering("QPixmap::hasAlpha")

	if ptr.Pointer() != nil {
		return C.QPixmap_HasAlpha(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPixmap) HasAlphaChannel() bool {
	defer qt.Recovering("QPixmap::hasAlphaChannel")

	if ptr.Pointer() != nil {
		return C.QPixmap_HasAlphaChannel(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPixmap) Load(fileName string, format string, flags core.Qt__ImageConversionFlag) bool {
	defer qt.Recovering("QPixmap::load")

	if ptr.Pointer() != nil {
		return C.QPixmap_Load(ptr.Pointer(), C.CString(fileName), C.CString(format), C.int(flags)) != 0
	}
	return false
}

func (ptr *QPixmap) LoadFromData2(data core.QByteArray_ITF, format string, flags core.Qt__ImageConversionFlag) bool {
	defer qt.Recovering("QPixmap::loadFromData")

	if ptr.Pointer() != nil {
		return C.QPixmap_LoadFromData2(ptr.Pointer(), core.PointerFromQByteArray(data), C.CString(format), C.int(flags)) != 0
	}
	return false
}

func (ptr *QPixmap) Save2(device core.QIODevice_ITF, format string, quality int) bool {
	defer qt.Recovering("QPixmap::save")

	if ptr.Pointer() != nil {
		return C.QPixmap_Save2(ptr.Pointer(), core.PointerFromQIODevice(device), C.CString(format), C.int(quality)) != 0
	}
	return false
}

func (ptr *QPixmap) Save(fileName string, format string, quality int) bool {
	defer qt.Recovering("QPixmap::save")

	if ptr.Pointer() != nil {
		return C.QPixmap_Save(ptr.Pointer(), C.CString(fileName), C.CString(format), C.int(quality)) != 0
	}
	return false
}

func (ptr *QPixmap) Scroll2(dx int, dy int, rect core.QRect_ITF, exposed QRegion_ITF) {
	defer qt.Recovering("QPixmap::scroll")

	if ptr.Pointer() != nil {
		C.QPixmap_Scroll2(ptr.Pointer(), C.int(dx), C.int(dy), core.PointerFromQRect(rect), PointerFromQRegion(exposed))
	}
}

func (ptr *QPixmap) Scroll(dx int, dy int, x int, y int, width int, height int, exposed QRegion_ITF) {
	defer qt.Recovering("QPixmap::scroll")

	if ptr.Pointer() != nil {
		C.QPixmap_Scroll(ptr.Pointer(), C.int(dx), C.int(dy), C.int(x), C.int(y), C.int(width), C.int(height), PointerFromQRegion(exposed))
	}
}

func (ptr *QPixmap) SetDevicePixelRatio(scaleFactor float64) {
	defer qt.Recovering("QPixmap::setDevicePixelRatio")

	if ptr.Pointer() != nil {
		C.QPixmap_SetDevicePixelRatio(ptr.Pointer(), C.double(scaleFactor))
	}
}

func (ptr *QPixmap) SetMask(mask QBitmap_ITF) {
	defer qt.Recovering("QPixmap::setMask")

	if ptr.Pointer() != nil {
		C.QPixmap_SetMask(ptr.Pointer(), PointerFromQBitmap(mask))
	}
}

func (ptr *QPixmap) Swap(other QPixmap_ITF) {
	defer qt.Recovering("QPixmap::swap")

	if ptr.Pointer() != nil {
		C.QPixmap_Swap(ptr.Pointer(), PointerFromQPixmap(other))
	}
}

func (ptr *QPixmap) DestroyQPixmap() {
	defer qt.Recovering("QPixmap::~QPixmap")

	if ptr.Pointer() != nil {
		C.QPixmap_DestroyQPixmap(ptr.Pointer())
	}
}

type QPixmapCache struct {
	ptr unsafe.Pointer
}

type QPixmapCache_ITF interface {
	QPixmapCache_PTR() *QPixmapCache
}

func (p *QPixmapCache) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QPixmapCache) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQPixmapCache(ptr QPixmapCache_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPixmapCache_PTR().Pointer()
	}
	return nil
}

func NewQPixmapCacheFromPointer(ptr unsafe.Pointer) *QPixmapCache {
	var n = new(QPixmapCache)
	n.SetPointer(ptr)
	return n
}

func newQPixmapCacheFromPointer(ptr unsafe.Pointer) *QPixmapCache {
	var n = NewQPixmapCacheFromPointer(ptr)
	return n
}

func (ptr *QPixmapCache) QPixmapCache_PTR() *QPixmapCache {
	return ptr
}

func QPixmapCache_CacheLimit() int {
	defer qt.Recovering("QPixmapCache::cacheLimit")

	return int(C.QPixmapCache_QPixmapCache_CacheLimit())
}

func QPixmapCache_Clear() {
	defer qt.Recovering("QPixmapCache::clear")

	C.QPixmapCache_QPixmapCache_Clear()
}

func QPixmapCache_SetCacheLimit(n int) {
	defer qt.Recovering("QPixmapCache::setCacheLimit")

	C.QPixmapCache_QPixmapCache_SetCacheLimit(C.int(n))
}

type QPlatformGraphicsBuffer struct {
	core.QObject
}

type QPlatformGraphicsBuffer_ITF interface {
	core.QObject_ITF
	QPlatformGraphicsBuffer_PTR() *QPlatformGraphicsBuffer
}

func PointerFromQPlatformGraphicsBuffer(ptr QPlatformGraphicsBuffer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPlatformGraphicsBuffer_PTR().Pointer()
	}
	return nil
}

func NewQPlatformGraphicsBufferFromPointer(ptr unsafe.Pointer) *QPlatformGraphicsBuffer {
	var n = new(QPlatformGraphicsBuffer)
	n.SetPointer(ptr)
	return n
}

func newQPlatformGraphicsBufferFromPointer(ptr unsafe.Pointer) *QPlatformGraphicsBuffer {
	var n = NewQPlatformGraphicsBufferFromPointer(ptr)
	for len(n.ObjectName()) < len("QPlatformGraphicsBuffer_") {
		n.SetObjectName("QPlatformGraphicsBuffer_" + qt.Identifier())
	}
	return n
}

func (ptr *QPlatformGraphicsBuffer) QPlatformGraphicsBuffer_PTR() *QPlatformGraphicsBuffer {
	return ptr
}

//QPlatformGraphicsBuffer::AccessType
type QPlatformGraphicsBuffer__AccessType int64

const (
	QPlatformGraphicsBuffer__None          = QPlatformGraphicsBuffer__AccessType(0x00)
	QPlatformGraphicsBuffer__SWReadAccess  = QPlatformGraphicsBuffer__AccessType(0x01)
	QPlatformGraphicsBuffer__SWWriteAccess = QPlatformGraphicsBuffer__AccessType(0x02)
	QPlatformGraphicsBuffer__TextureAccess = QPlatformGraphicsBuffer__AccessType(0x04)
	QPlatformGraphicsBuffer__HWCompositor  = QPlatformGraphicsBuffer__AccessType(0x08)
)

//QPlatformGraphicsBuffer::Origin
type QPlatformGraphicsBuffer__Origin int64

const (
	QPlatformGraphicsBuffer__OriginBottomLeft = QPlatformGraphicsBuffer__Origin(0)
	QPlatformGraphicsBuffer__OriginTopLeft    = QPlatformGraphicsBuffer__Origin(1)
)

type QPlatformSurfaceEvent struct {
	core.QEvent
}

type QPlatformSurfaceEvent_ITF interface {
	core.QEvent_ITF
	QPlatformSurfaceEvent_PTR() *QPlatformSurfaceEvent
}

func PointerFromQPlatformSurfaceEvent(ptr QPlatformSurfaceEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPlatformSurfaceEvent_PTR().Pointer()
	}
	return nil
}

func NewQPlatformSurfaceEventFromPointer(ptr unsafe.Pointer) *QPlatformSurfaceEvent {
	var n = new(QPlatformSurfaceEvent)
	n.SetPointer(ptr)
	return n
}

func newQPlatformSurfaceEventFromPointer(ptr unsafe.Pointer) *QPlatformSurfaceEvent {
	var n = NewQPlatformSurfaceEventFromPointer(ptr)
	return n
}

func (ptr *QPlatformSurfaceEvent) QPlatformSurfaceEvent_PTR() *QPlatformSurfaceEvent {
	return ptr
}

//QPlatformSurfaceEvent::SurfaceEventType
type QPlatformSurfaceEvent__SurfaceEventType int64

const (
	QPlatformSurfaceEvent__SurfaceCreated            = QPlatformSurfaceEvent__SurfaceEventType(0)
	QPlatformSurfaceEvent__SurfaceAboutToBeDestroyed = QPlatformSurfaceEvent__SurfaceEventType(1)
)

func NewQPlatformSurfaceEvent(surfaceEventType QPlatformSurfaceEvent__SurfaceEventType) *QPlatformSurfaceEvent {
	defer qt.Recovering("QPlatformSurfaceEvent::QPlatformSurfaceEvent")

	return newQPlatformSurfaceEventFromPointer(C.QPlatformSurfaceEvent_NewQPlatformSurfaceEvent(C.int(surfaceEventType)))
}

func (ptr *QPlatformSurfaceEvent) SurfaceEventType() QPlatformSurfaceEvent__SurfaceEventType {
	defer qt.Recovering("QPlatformSurfaceEvent::surfaceEventType")

	if ptr.Pointer() != nil {
		return QPlatformSurfaceEvent__SurfaceEventType(C.QPlatformSurfaceEvent_SurfaceEventType(ptr.Pointer()))
	}
	return 0
}

type QPlatformSystemTrayIcon struct {
	core.QObject
}

type QPlatformSystemTrayIcon_ITF interface {
	core.QObject_ITF
	QPlatformSystemTrayIcon_PTR() *QPlatformSystemTrayIcon
}

func PointerFromQPlatformSystemTrayIcon(ptr QPlatformSystemTrayIcon_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPlatformSystemTrayIcon_PTR().Pointer()
	}
	return nil
}

func NewQPlatformSystemTrayIconFromPointer(ptr unsafe.Pointer) *QPlatformSystemTrayIcon {
	var n = new(QPlatformSystemTrayIcon)
	n.SetPointer(ptr)
	return n
}

func newQPlatformSystemTrayIconFromPointer(ptr unsafe.Pointer) *QPlatformSystemTrayIcon {
	var n = NewQPlatformSystemTrayIconFromPointer(ptr)
	for len(n.ObjectName()) < len("QPlatformSystemTrayIcon_") {
		n.SetObjectName("QPlatformSystemTrayIcon_" + qt.Identifier())
	}
	return n
}

func (ptr *QPlatformSystemTrayIcon) QPlatformSystemTrayIcon_PTR() *QPlatformSystemTrayIcon {
	return ptr
}

//QPlatformSystemTrayIcon::ActivationReason
type QPlatformSystemTrayIcon__ActivationReason int64

const (
	QPlatformSystemTrayIcon__Unknown     = QPlatformSystemTrayIcon__ActivationReason(0)
	QPlatformSystemTrayIcon__Context     = QPlatformSystemTrayIcon__ActivationReason(1)
	QPlatformSystemTrayIcon__DoubleClick = QPlatformSystemTrayIcon__ActivationReason(2)
	QPlatformSystemTrayIcon__Trigger     = QPlatformSystemTrayIcon__ActivationReason(3)
	QPlatformSystemTrayIcon__MiddleClick = QPlatformSystemTrayIcon__ActivationReason(4)
)

//QPlatformSystemTrayIcon::MessageIcon
type QPlatformSystemTrayIcon__MessageIcon int64

const (
	QPlatformSystemTrayIcon__NoIcon      = QPlatformSystemTrayIcon__MessageIcon(0)
	QPlatformSystemTrayIcon__Information = QPlatformSystemTrayIcon__MessageIcon(1)
	QPlatformSystemTrayIcon__Warning     = QPlatformSystemTrayIcon__MessageIcon(2)
	QPlatformSystemTrayIcon__Critical    = QPlatformSystemTrayIcon__MessageIcon(3)
)

type QPolygon struct {
	core.QVector
}

type QPolygon_ITF interface {
	core.QVector_ITF
	QPolygon_PTR() *QPolygon
}

func PointerFromQPolygon(ptr QPolygon_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPolygon_PTR().Pointer()
	}
	return nil
}

func NewQPolygonFromPointer(ptr unsafe.Pointer) *QPolygon {
	var n = new(QPolygon)
	n.SetPointer(ptr)
	return n
}

func newQPolygonFromPointer(ptr unsafe.Pointer) *QPolygon {
	var n = NewQPolygonFromPointer(ptr)
	return n
}

func (ptr *QPolygon) QPolygon_PTR() *QPolygon {
	return ptr
}

func NewQPolygon5(rectangle core.QRect_ITF, closed bool) *QPolygon {
	defer qt.Recovering("QPolygon::QPolygon")

	return newQPolygonFromPointer(C.QPolygon_NewQPolygon5(core.PointerFromQRect(rectangle), C.int(qt.GoBoolToInt(closed))))
}

func (ptr *QPolygon) ContainsPoint(point core.QPoint_ITF, fillRule core.Qt__FillRule) bool {
	defer qt.Recovering("QPolygon::containsPoint")

	if ptr.Pointer() != nil {
		return C.QPolygon_ContainsPoint(ptr.Pointer(), core.PointerFromQPoint(point), C.int(fillRule)) != 0
	}
	return false
}

func (ptr *QPolygon) PutPoints3(index int, nPoints int, fromPolygon QPolygon_ITF, fromIndex int) {
	defer qt.Recovering("QPolygon::putPoints")

	if ptr.Pointer() != nil {
		C.QPolygon_PutPoints3(ptr.Pointer(), C.int(index), C.int(nPoints), PointerFromQPolygon(fromPolygon), C.int(fromIndex))
	}
}

func NewQPolygon() *QPolygon {
	defer qt.Recovering("QPolygon::QPolygon")

	return newQPolygonFromPointer(C.QPolygon_NewQPolygon())
}

func NewQPolygon3(polygon QPolygon_ITF) *QPolygon {
	defer qt.Recovering("QPolygon::QPolygon")

	return newQPolygonFromPointer(C.QPolygon_NewQPolygon3(PointerFromQPolygon(polygon)))
}

func NewQPolygon2(size int) *QPolygon {
	defer qt.Recovering("QPolygon::QPolygon")

	return newQPolygonFromPointer(C.QPolygon_NewQPolygon2(C.int(size)))
}

func (ptr *QPolygon) BoundingRect() *core.QRect {
	defer qt.Recovering("QPolygon::boundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QPolygon_BoundingRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QPolygon) Point2(index int) *core.QPoint {
	defer qt.Recovering("QPolygon::point")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QPolygon_Point2(ptr.Pointer(), C.int(index)))
	}
	return nil
}

func (ptr *QPolygon) Point(index int, x int, y int) {
	defer qt.Recovering("QPolygon::point")

	if ptr.Pointer() != nil {
		C.QPolygon_Point(ptr.Pointer(), C.int(index), C.int(x), C.int(y))
	}
}

func (ptr *QPolygon) SetPoint2(index int, point core.QPoint_ITF) {
	defer qt.Recovering("QPolygon::setPoint")

	if ptr.Pointer() != nil {
		C.QPolygon_SetPoint2(ptr.Pointer(), C.int(index), core.PointerFromQPoint(point))
	}
}

func (ptr *QPolygon) SetPoint(index int, x int, y int) {
	defer qt.Recovering("QPolygon::setPoint")

	if ptr.Pointer() != nil {
		C.QPolygon_SetPoint(ptr.Pointer(), C.int(index), C.int(x), C.int(y))
	}
}

func (ptr *QPolygon) SetPoints(nPoints int, points int) {
	defer qt.Recovering("QPolygon::setPoints")

	if ptr.Pointer() != nil {
		C.QPolygon_SetPoints(ptr.Pointer(), C.int(nPoints), C.int(points))
	}
}

func (ptr *QPolygon) Swap(other QPolygon_ITF) {
	defer qt.Recovering("QPolygon::swap")

	if ptr.Pointer() != nil {
		C.QPolygon_Swap(ptr.Pointer(), PointerFromQPolygon(other))
	}
}

func (ptr *QPolygon) Translate2(offset core.QPoint_ITF) {
	defer qt.Recovering("QPolygon::translate")

	if ptr.Pointer() != nil {
		C.QPolygon_Translate2(ptr.Pointer(), core.PointerFromQPoint(offset))
	}
}

func (ptr *QPolygon) Translate(dx int, dy int) {
	defer qt.Recovering("QPolygon::translate")

	if ptr.Pointer() != nil {
		C.QPolygon_Translate(ptr.Pointer(), C.int(dx), C.int(dy))
	}
}

func (ptr *QPolygon) DestroyQPolygon() {
	defer qt.Recovering("QPolygon::~QPolygon")

	if ptr.Pointer() != nil {
		C.QPolygon_DestroyQPolygon(ptr.Pointer())
	}
}

type QPolygonF struct {
	core.QVector
}

type QPolygonF_ITF interface {
	core.QVector_ITF
	QPolygonF_PTR() *QPolygonF
}

func PointerFromQPolygonF(ptr QPolygonF_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QPolygonF_PTR().Pointer()
	}
	return nil
}

func NewQPolygonFFromPointer(ptr unsafe.Pointer) *QPolygonF {
	var n = new(QPolygonF)
	n.SetPointer(ptr)
	return n
}

func newQPolygonFFromPointer(ptr unsafe.Pointer) *QPolygonF {
	var n = NewQPolygonFFromPointer(ptr)
	return n
}

func (ptr *QPolygonF) QPolygonF_PTR() *QPolygonF {
	return ptr
}

func NewQPolygonF6(polygon QPolygon_ITF) *QPolygonF {
	defer qt.Recovering("QPolygonF::QPolygonF")

	return newQPolygonFFromPointer(C.QPolygonF_NewQPolygonF6(PointerFromQPolygon(polygon)))
}

func NewQPolygonF5(rectangle core.QRectF_ITF) *QPolygonF {
	defer qt.Recovering("QPolygonF::QPolygonF")

	return newQPolygonFFromPointer(C.QPolygonF_NewQPolygonF5(core.PointerFromQRectF(rectangle)))
}

func (ptr *QPolygonF) ContainsPoint(point core.QPointF_ITF, fillRule core.Qt__FillRule) bool {
	defer qt.Recovering("QPolygonF::containsPoint")

	if ptr.Pointer() != nil {
		return C.QPolygonF_ContainsPoint(ptr.Pointer(), core.PointerFromQPointF(point), C.int(fillRule)) != 0
	}
	return false
}

func NewQPolygonF() *QPolygonF {
	defer qt.Recovering("QPolygonF::QPolygonF")

	return newQPolygonFFromPointer(C.QPolygonF_NewQPolygonF())
}

func NewQPolygonF3(polygon QPolygonF_ITF) *QPolygonF {
	defer qt.Recovering("QPolygonF::QPolygonF")

	return newQPolygonFFromPointer(C.QPolygonF_NewQPolygonF3(PointerFromQPolygonF(polygon)))
}

func NewQPolygonF2(size int) *QPolygonF {
	defer qt.Recovering("QPolygonF::QPolygonF")

	return newQPolygonFFromPointer(C.QPolygonF_NewQPolygonF2(C.int(size)))
}

func (ptr *QPolygonF) IsClosed() bool {
	defer qt.Recovering("QPolygonF::isClosed")

	if ptr.Pointer() != nil {
		return C.QPolygonF_IsClosed(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QPolygonF) Swap(other QPolygonF_ITF) {
	defer qt.Recovering("QPolygonF::swap")

	if ptr.Pointer() != nil {
		C.QPolygonF_Swap(ptr.Pointer(), PointerFromQPolygonF(other))
	}
}

func (ptr *QPolygonF) Translate(offset core.QPointF_ITF) {
	defer qt.Recovering("QPolygonF::translate")

	if ptr.Pointer() != nil {
		C.QPolygonF_Translate(ptr.Pointer(), core.PointerFromQPointF(offset))
	}
}

func (ptr *QPolygonF) Translate2(dx float64, dy float64) {
	defer qt.Recovering("QPolygonF::translate")

	if ptr.Pointer() != nil {
		C.QPolygonF_Translate2(ptr.Pointer(), C.double(dx), C.double(dy))
	}
}

func (ptr *QPolygonF) DestroyQPolygonF() {
	defer qt.Recovering("QPolygonF::~QPolygonF")

	if ptr.Pointer() != nil {
		C.QPolygonF_DestroyQPolygonF(ptr.Pointer())
	}
}

type QQuaternion struct {
	ptr unsafe.Pointer
}

type QQuaternion_ITF interface {
	QQuaternion_PTR() *QQuaternion
}

func (p *QQuaternion) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QQuaternion) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQQuaternion(ptr QQuaternion_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QQuaternion_PTR().Pointer()
	}
	return nil
}

func NewQQuaternionFromPointer(ptr unsafe.Pointer) *QQuaternion {
	var n = new(QQuaternion)
	n.SetPointer(ptr)
	return n
}

func newQQuaternionFromPointer(ptr unsafe.Pointer) *QQuaternion {
	var n = NewQQuaternionFromPointer(ptr)
	return n
}

func (ptr *QQuaternion) QQuaternion_PTR() *QQuaternion {
	return ptr
}

func NewQQuaternion() *QQuaternion {
	defer qt.Recovering("QQuaternion::QQuaternion")

	return newQQuaternionFromPointer(C.QQuaternion_NewQQuaternion())
}

func NewQQuaternion5(vector QVector4D_ITF) *QQuaternion {
	defer qt.Recovering("QQuaternion::QQuaternion")

	return newQQuaternionFromPointer(C.QQuaternion_NewQQuaternion5(PointerFromQVector4D(vector)))
}

func (ptr *QQuaternion) GetAxes(xAxis QVector3D_ITF, yAxis QVector3D_ITF, zAxis QVector3D_ITF) {
	defer qt.Recovering("QQuaternion::getAxes")

	if ptr.Pointer() != nil {
		C.QQuaternion_GetAxes(ptr.Pointer(), PointerFromQVector3D(xAxis), PointerFromQVector3D(yAxis), PointerFromQVector3D(zAxis))
	}
}

func (ptr *QQuaternion) IsIdentity() bool {
	defer qt.Recovering("QQuaternion::isIdentity")

	if ptr.Pointer() != nil {
		return C.QQuaternion_IsIdentity(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuaternion) IsNull() bool {
	defer qt.Recovering("QQuaternion::isNull")

	if ptr.Pointer() != nil {
		return C.QQuaternion_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QQuaternion) Normalize() {
	defer qt.Recovering("QQuaternion::normalize")

	if ptr.Pointer() != nil {
		C.QQuaternion_Normalize(ptr.Pointer())
	}
}

func (ptr *QQuaternion) SetVector(vector QVector3D_ITF) {
	defer qt.Recovering("QQuaternion::setVector")

	if ptr.Pointer() != nil {
		C.QQuaternion_SetVector(ptr.Pointer(), PointerFromQVector3D(vector))
	}
}

type QRadialGradient struct {
	QGradient
}

type QRadialGradient_ITF interface {
	QGradient_ITF
	QRadialGradient_PTR() *QRadialGradient
}

func PointerFromQRadialGradient(ptr QRadialGradient_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRadialGradient_PTR().Pointer()
	}
	return nil
}

func NewQRadialGradientFromPointer(ptr unsafe.Pointer) *QRadialGradient {
	var n = new(QRadialGradient)
	n.SetPointer(ptr)
	return n
}

func newQRadialGradientFromPointer(ptr unsafe.Pointer) *QRadialGradient {
	var n = NewQRadialGradientFromPointer(ptr)
	return n
}

func (ptr *QRadialGradient) QRadialGradient_PTR() *QRadialGradient {
	return ptr
}

func NewQRadialGradient() *QRadialGradient {
	defer qt.Recovering("QRadialGradient::QRadialGradient")

	return newQRadialGradientFromPointer(C.QRadialGradient_NewQRadialGradient())
}

func NewQRadialGradient6(center core.QPointF_ITF, centerRadius float64, focalPoint core.QPointF_ITF, focalRadius float64) *QRadialGradient {
	defer qt.Recovering("QRadialGradient::QRadialGradient")

	return newQRadialGradientFromPointer(C.QRadialGradient_NewQRadialGradient6(core.PointerFromQPointF(center), C.double(centerRadius), core.PointerFromQPointF(focalPoint), C.double(focalRadius)))
}

func NewQRadialGradient4(center core.QPointF_ITF, radius float64) *QRadialGradient {
	defer qt.Recovering("QRadialGradient::QRadialGradient")

	return newQRadialGradientFromPointer(C.QRadialGradient_NewQRadialGradient4(core.PointerFromQPointF(center), C.double(radius)))
}

func NewQRadialGradient2(center core.QPointF_ITF, radius float64, focalPoint core.QPointF_ITF) *QRadialGradient {
	defer qt.Recovering("QRadialGradient::QRadialGradient")

	return newQRadialGradientFromPointer(C.QRadialGradient_NewQRadialGradient2(core.PointerFromQPointF(center), C.double(radius), core.PointerFromQPointF(focalPoint)))
}

func NewQRadialGradient7(cx float64, cy float64, centerRadius float64, fx float64, fy float64, focalRadius float64) *QRadialGradient {
	defer qt.Recovering("QRadialGradient::QRadialGradient")

	return newQRadialGradientFromPointer(C.QRadialGradient_NewQRadialGradient7(C.double(cx), C.double(cy), C.double(centerRadius), C.double(fx), C.double(fy), C.double(focalRadius)))
}

func NewQRadialGradient5(cx float64, cy float64, radius float64) *QRadialGradient {
	defer qt.Recovering("QRadialGradient::QRadialGradient")

	return newQRadialGradientFromPointer(C.QRadialGradient_NewQRadialGradient5(C.double(cx), C.double(cy), C.double(radius)))
}

func NewQRadialGradient3(cx float64, cy float64, radius float64, fx float64, fy float64) *QRadialGradient {
	defer qt.Recovering("QRadialGradient::QRadialGradient")

	return newQRadialGradientFromPointer(C.QRadialGradient_NewQRadialGradient3(C.double(cx), C.double(cy), C.double(radius), C.double(fx), C.double(fy)))
}

func (ptr *QRadialGradient) CenterRadius() float64 {
	defer qt.Recovering("QRadialGradient::centerRadius")

	if ptr.Pointer() != nil {
		return float64(C.QRadialGradient_CenterRadius(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRadialGradient) FocalRadius() float64 {
	defer qt.Recovering("QRadialGradient::focalRadius")

	if ptr.Pointer() != nil {
		return float64(C.QRadialGradient_FocalRadius(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRadialGradient) Radius() float64 {
	defer qt.Recovering("QRadialGradient::radius")

	if ptr.Pointer() != nil {
		return float64(C.QRadialGradient_Radius(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRadialGradient) SetCenter(center core.QPointF_ITF) {
	defer qt.Recovering("QRadialGradient::setCenter")

	if ptr.Pointer() != nil {
		C.QRadialGradient_SetCenter(ptr.Pointer(), core.PointerFromQPointF(center))
	}
}

func (ptr *QRadialGradient) SetCenter2(x float64, y float64) {
	defer qt.Recovering("QRadialGradient::setCenter")

	if ptr.Pointer() != nil {
		C.QRadialGradient_SetCenter2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QRadialGradient) SetCenterRadius(radius float64) {
	defer qt.Recovering("QRadialGradient::setCenterRadius")

	if ptr.Pointer() != nil {
		C.QRadialGradient_SetCenterRadius(ptr.Pointer(), C.double(radius))
	}
}

func (ptr *QRadialGradient) SetFocalPoint(focalPoint core.QPointF_ITF) {
	defer qt.Recovering("QRadialGradient::setFocalPoint")

	if ptr.Pointer() != nil {
		C.QRadialGradient_SetFocalPoint(ptr.Pointer(), core.PointerFromQPointF(focalPoint))
	}
}

func (ptr *QRadialGradient) SetFocalPoint2(x float64, y float64) {
	defer qt.Recovering("QRadialGradient::setFocalPoint")

	if ptr.Pointer() != nil {
		C.QRadialGradient_SetFocalPoint2(ptr.Pointer(), C.double(x), C.double(y))
	}
}

func (ptr *QRadialGradient) SetFocalRadius(radius float64) {
	defer qt.Recovering("QRadialGradient::setFocalRadius")

	if ptr.Pointer() != nil {
		C.QRadialGradient_SetFocalRadius(ptr.Pointer(), C.double(radius))
	}
}

func (ptr *QRadialGradient) SetRadius(radius float64) {
	defer qt.Recovering("QRadialGradient::setRadius")

	if ptr.Pointer() != nil {
		C.QRadialGradient_SetRadius(ptr.Pointer(), C.double(radius))
	}
}

type QRasterPaintEngine struct {
	QPaintEngine
}

type QRasterPaintEngine_ITF interface {
	QPaintEngine_ITF
	QRasterPaintEngine_PTR() *QRasterPaintEngine
}

func PointerFromQRasterPaintEngine(ptr QRasterPaintEngine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRasterPaintEngine_PTR().Pointer()
	}
	return nil
}

func NewQRasterPaintEngineFromPointer(ptr unsafe.Pointer) *QRasterPaintEngine {
	var n = new(QRasterPaintEngine)
	n.SetPointer(ptr)
	return n
}

func newQRasterPaintEngineFromPointer(ptr unsafe.Pointer) *QRasterPaintEngine {
	var n = NewQRasterPaintEngineFromPointer(ptr)
	return n
}

func (ptr *QRasterPaintEngine) QRasterPaintEngine_PTR() *QRasterPaintEngine {
	return ptr
}

type QRasterWindow struct {
	QPaintDeviceWindow
}

type QRasterWindow_ITF interface {
	QPaintDeviceWindow_ITF
	QRasterWindow_PTR() *QRasterWindow
}

func PointerFromQRasterWindow(ptr QRasterWindow_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRasterWindow_PTR().Pointer()
	}
	return nil
}

func NewQRasterWindowFromPointer(ptr unsafe.Pointer) *QRasterWindow {
	var n = new(QRasterWindow)
	n.SetPointer(ptr)
	return n
}

func newQRasterWindowFromPointer(ptr unsafe.Pointer) *QRasterWindow {
	var n = NewQRasterWindowFromPointer(ptr)
	for len(n.ObjectName()) < len("QRasterWindow_") {
		n.SetObjectName("QRasterWindow_" + qt.Identifier())
	}
	return n
}

func (ptr *QRasterWindow) QRasterWindow_PTR() *QRasterWindow {
	return ptr
}

func NewQRasterWindow(parent QWindow_ITF) *QRasterWindow {
	defer qt.Recovering("QRasterWindow::QRasterWindow")

	return newQRasterWindowFromPointer(C.QRasterWindow_NewQRasterWindow(PointerFromQWindow(parent)))
}

func (ptr *QRasterWindow) ConnectPaintEvent(f func(event *QPaintEvent)) {
	defer qt.Recovering("connect QRasterWindow::paintEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "paintEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectPaintEvent() {
	defer qt.Recovering("disconnect QRasterWindow::paintEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "paintEvent")
	}
}

//export callbackQRasterWindowPaintEvent
func callbackQRasterWindowPaintEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::paintEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "paintEvent"); signal != nil {
		signal.(func(*QPaintEvent))(NewQPaintEventFromPointer(event))
	} else {
		NewQRasterWindowFromPointer(ptr).PaintEventDefault(NewQPaintEventFromPointer(event))
	}
}

func (ptr *QRasterWindow) PaintEvent(event QPaintEvent_ITF) {
	defer qt.Recovering("QRasterWindow::paintEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_PaintEvent(ptr.Pointer(), PointerFromQPaintEvent(event))
	}
}

func (ptr *QRasterWindow) PaintEventDefault(event QPaintEvent_ITF) {
	defer qt.Recovering("QRasterWindow::paintEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_PaintEventDefault(ptr.Pointer(), PointerFromQPaintEvent(event))
	}
}

func (ptr *QRasterWindow) ConnectExposeEvent(f func(ev *QExposeEvent)) {
	defer qt.Recovering("connect QRasterWindow::exposeEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "exposeEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectExposeEvent() {
	defer qt.Recovering("disconnect QRasterWindow::exposeEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "exposeEvent")
	}
}

//export callbackQRasterWindowExposeEvent
func callbackQRasterWindowExposeEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::exposeEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "exposeEvent"); signal != nil {
		signal.(func(*QExposeEvent))(NewQExposeEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).ExposeEventDefault(NewQExposeEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) ExposeEvent(ev QExposeEvent_ITF) {
	defer qt.Recovering("QRasterWindow::exposeEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_ExposeEvent(ptr.Pointer(), PointerFromQExposeEvent(ev))
	}
}

func (ptr *QRasterWindow) ExposeEventDefault(ev QExposeEvent_ITF) {
	defer qt.Recovering("QRasterWindow::exposeEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_ExposeEventDefault(ptr.Pointer(), PointerFromQExposeEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectFocusInEvent(f func(ev *QFocusEvent)) {
	defer qt.Recovering("connect QRasterWindow::focusInEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "focusInEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectFocusInEvent() {
	defer qt.Recovering("disconnect QRasterWindow::focusInEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "focusInEvent")
	}
}

//export callbackQRasterWindowFocusInEvent
func callbackQRasterWindowFocusInEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::focusInEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "focusInEvent"); signal != nil {
		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).FocusInEventDefault(NewQFocusEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) FocusInEvent(ev QFocusEvent_ITF) {
	defer qt.Recovering("QRasterWindow::focusInEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_FocusInEvent(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QRasterWindow) FocusInEventDefault(ev QFocusEvent_ITF) {
	defer qt.Recovering("QRasterWindow::focusInEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_FocusInEventDefault(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectFocusOutEvent(f func(ev *QFocusEvent)) {
	defer qt.Recovering("connect QRasterWindow::focusOutEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "focusOutEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectFocusOutEvent() {
	defer qt.Recovering("disconnect QRasterWindow::focusOutEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "focusOutEvent")
	}
}

//export callbackQRasterWindowFocusOutEvent
func callbackQRasterWindowFocusOutEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::focusOutEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "focusOutEvent"); signal != nil {
		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).FocusOutEventDefault(NewQFocusEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) FocusOutEvent(ev QFocusEvent_ITF) {
	defer qt.Recovering("QRasterWindow::focusOutEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_FocusOutEvent(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QRasterWindow) FocusOutEventDefault(ev QFocusEvent_ITF) {
	defer qt.Recovering("QRasterWindow::focusOutEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_FocusOutEventDefault(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectHideEvent(f func(ev *QHideEvent)) {
	defer qt.Recovering("connect QRasterWindow::hideEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "hideEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectHideEvent() {
	defer qt.Recovering("disconnect QRasterWindow::hideEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "hideEvent")
	}
}

//export callbackQRasterWindowHideEvent
func callbackQRasterWindowHideEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::hideEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "hideEvent"); signal != nil {
		signal.(func(*QHideEvent))(NewQHideEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).HideEventDefault(NewQHideEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) HideEvent(ev QHideEvent_ITF) {
	defer qt.Recovering("QRasterWindow::hideEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_HideEvent(ptr.Pointer(), PointerFromQHideEvent(ev))
	}
}

func (ptr *QRasterWindow) HideEventDefault(ev QHideEvent_ITF) {
	defer qt.Recovering("QRasterWindow::hideEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_HideEventDefault(ptr.Pointer(), PointerFromQHideEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectKeyPressEvent(f func(ev *QKeyEvent)) {
	defer qt.Recovering("connect QRasterWindow::keyPressEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "keyPressEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectKeyPressEvent() {
	defer qt.Recovering("disconnect QRasterWindow::keyPressEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "keyPressEvent")
	}
}

//export callbackQRasterWindowKeyPressEvent
func callbackQRasterWindowKeyPressEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::keyPressEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "keyPressEvent"); signal != nil {
		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).KeyPressEventDefault(NewQKeyEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) KeyPressEvent(ev QKeyEvent_ITF) {
	defer qt.Recovering("QRasterWindow::keyPressEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_KeyPressEvent(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QRasterWindow) KeyPressEventDefault(ev QKeyEvent_ITF) {
	defer qt.Recovering("QRasterWindow::keyPressEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_KeyPressEventDefault(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectKeyReleaseEvent(f func(ev *QKeyEvent)) {
	defer qt.Recovering("connect QRasterWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "keyReleaseEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectKeyReleaseEvent() {
	defer qt.Recovering("disconnect QRasterWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "keyReleaseEvent")
	}
}

//export callbackQRasterWindowKeyReleaseEvent
func callbackQRasterWindowKeyReleaseEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::keyReleaseEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "keyReleaseEvent"); signal != nil {
		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).KeyReleaseEventDefault(NewQKeyEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) KeyReleaseEvent(ev QKeyEvent_ITF) {
	defer qt.Recovering("QRasterWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_KeyReleaseEvent(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QRasterWindow) KeyReleaseEventDefault(ev QKeyEvent_ITF) {
	defer qt.Recovering("QRasterWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_KeyReleaseEventDefault(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectMouseDoubleClickEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QRasterWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectMouseDoubleClickEvent() {
	defer qt.Recovering("disconnect QRasterWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent")
	}
}

//export callbackQRasterWindowMouseDoubleClickEvent
func callbackQRasterWindowMouseDoubleClickEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::mouseDoubleClickEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseDoubleClickEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).MouseDoubleClickEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) MouseDoubleClickEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QRasterWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MouseDoubleClickEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QRasterWindow) MouseDoubleClickEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QRasterWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MouseDoubleClickEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectMouseMoveEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QRasterWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mouseMoveEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectMouseMoveEvent() {
	defer qt.Recovering("disconnect QRasterWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mouseMoveEvent")
	}
}

//export callbackQRasterWindowMouseMoveEvent
func callbackQRasterWindowMouseMoveEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::mouseMoveEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseMoveEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).MouseMoveEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) MouseMoveEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QRasterWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MouseMoveEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QRasterWindow) MouseMoveEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QRasterWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MouseMoveEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectMousePressEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QRasterWindow::mousePressEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mousePressEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectMousePressEvent() {
	defer qt.Recovering("disconnect QRasterWindow::mousePressEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mousePressEvent")
	}
}

//export callbackQRasterWindowMousePressEvent
func callbackQRasterWindowMousePressEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::mousePressEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mousePressEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).MousePressEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) MousePressEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QRasterWindow::mousePressEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MousePressEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QRasterWindow) MousePressEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QRasterWindow::mousePressEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MousePressEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectMouseReleaseEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QRasterWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mouseReleaseEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectMouseReleaseEvent() {
	defer qt.Recovering("disconnect QRasterWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mouseReleaseEvent")
	}
}

//export callbackQRasterWindowMouseReleaseEvent
func callbackQRasterWindowMouseReleaseEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::mouseReleaseEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseReleaseEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).MouseReleaseEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) MouseReleaseEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QRasterWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MouseReleaseEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QRasterWindow) MouseReleaseEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QRasterWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MouseReleaseEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectMoveEvent(f func(ev *QMoveEvent)) {
	defer qt.Recovering("connect QRasterWindow::moveEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "moveEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectMoveEvent() {
	defer qt.Recovering("disconnect QRasterWindow::moveEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "moveEvent")
	}
}

//export callbackQRasterWindowMoveEvent
func callbackQRasterWindowMoveEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::moveEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "moveEvent"); signal != nil {
		signal.(func(*QMoveEvent))(NewQMoveEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).MoveEventDefault(NewQMoveEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) MoveEvent(ev QMoveEvent_ITF) {
	defer qt.Recovering("QRasterWindow::moveEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MoveEvent(ptr.Pointer(), PointerFromQMoveEvent(ev))
	}
}

func (ptr *QRasterWindow) MoveEventDefault(ev QMoveEvent_ITF) {
	defer qt.Recovering("QRasterWindow::moveEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_MoveEventDefault(ptr.Pointer(), PointerFromQMoveEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectResizeEvent(f func(ev *QResizeEvent)) {
	defer qt.Recovering("connect QRasterWindow::resizeEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "resizeEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectResizeEvent() {
	defer qt.Recovering("disconnect QRasterWindow::resizeEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "resizeEvent")
	}
}

//export callbackQRasterWindowResizeEvent
func callbackQRasterWindowResizeEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::resizeEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "resizeEvent"); signal != nil {
		signal.(func(*QResizeEvent))(NewQResizeEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).ResizeEventDefault(NewQResizeEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) ResizeEvent(ev QResizeEvent_ITF) {
	defer qt.Recovering("QRasterWindow::resizeEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_ResizeEvent(ptr.Pointer(), PointerFromQResizeEvent(ev))
	}
}

func (ptr *QRasterWindow) ResizeEventDefault(ev QResizeEvent_ITF) {
	defer qt.Recovering("QRasterWindow::resizeEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_ResizeEventDefault(ptr.Pointer(), PointerFromQResizeEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectShowEvent(f func(ev *QShowEvent)) {
	defer qt.Recovering("connect QRasterWindow::showEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "showEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectShowEvent() {
	defer qt.Recovering("disconnect QRasterWindow::showEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "showEvent")
	}
}

//export callbackQRasterWindowShowEvent
func callbackQRasterWindowShowEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::showEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "showEvent"); signal != nil {
		signal.(func(*QShowEvent))(NewQShowEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).ShowEventDefault(NewQShowEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) ShowEvent(ev QShowEvent_ITF) {
	defer qt.Recovering("QRasterWindow::showEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_ShowEvent(ptr.Pointer(), PointerFromQShowEvent(ev))
	}
}

func (ptr *QRasterWindow) ShowEventDefault(ev QShowEvent_ITF) {
	defer qt.Recovering("QRasterWindow::showEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_ShowEventDefault(ptr.Pointer(), PointerFromQShowEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectTabletEvent(f func(ev *QTabletEvent)) {
	defer qt.Recovering("connect QRasterWindow::tabletEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "tabletEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectTabletEvent() {
	defer qt.Recovering("disconnect QRasterWindow::tabletEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "tabletEvent")
	}
}

//export callbackQRasterWindowTabletEvent
func callbackQRasterWindowTabletEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::tabletEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "tabletEvent"); signal != nil {
		signal.(func(*QTabletEvent))(NewQTabletEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).TabletEventDefault(NewQTabletEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) TabletEvent(ev QTabletEvent_ITF) {
	defer qt.Recovering("QRasterWindow::tabletEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_TabletEvent(ptr.Pointer(), PointerFromQTabletEvent(ev))
	}
}

func (ptr *QRasterWindow) TabletEventDefault(ev QTabletEvent_ITF) {
	defer qt.Recovering("QRasterWindow::tabletEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_TabletEventDefault(ptr.Pointer(), PointerFromQTabletEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectTouchEvent(f func(ev *QTouchEvent)) {
	defer qt.Recovering("connect QRasterWindow::touchEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "touchEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectTouchEvent() {
	defer qt.Recovering("disconnect QRasterWindow::touchEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "touchEvent")
	}
}

//export callbackQRasterWindowTouchEvent
func callbackQRasterWindowTouchEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::touchEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "touchEvent"); signal != nil {
		signal.(func(*QTouchEvent))(NewQTouchEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).TouchEventDefault(NewQTouchEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) TouchEvent(ev QTouchEvent_ITF) {
	defer qt.Recovering("QRasterWindow::touchEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_TouchEvent(ptr.Pointer(), PointerFromQTouchEvent(ev))
	}
}

func (ptr *QRasterWindow) TouchEventDefault(ev QTouchEvent_ITF) {
	defer qt.Recovering("QRasterWindow::touchEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_TouchEventDefault(ptr.Pointer(), PointerFromQTouchEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectWheelEvent(f func(ev *QWheelEvent)) {
	defer qt.Recovering("connect QRasterWindow::wheelEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "wheelEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectWheelEvent() {
	defer qt.Recovering("disconnect QRasterWindow::wheelEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "wheelEvent")
	}
}

//export callbackQRasterWindowWheelEvent
func callbackQRasterWindowWheelEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::wheelEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "wheelEvent"); signal != nil {
		signal.(func(*QWheelEvent))(NewQWheelEventFromPointer(ev))
	} else {
		NewQRasterWindowFromPointer(ptr).WheelEventDefault(NewQWheelEventFromPointer(ev))
	}
}

func (ptr *QRasterWindow) WheelEvent(ev QWheelEvent_ITF) {
	defer qt.Recovering("QRasterWindow::wheelEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_WheelEvent(ptr.Pointer(), PointerFromQWheelEvent(ev))
	}
}

func (ptr *QRasterWindow) WheelEventDefault(ev QWheelEvent_ITF) {
	defer qt.Recovering("QRasterWindow::wheelEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_WheelEventDefault(ptr.Pointer(), PointerFromQWheelEvent(ev))
	}
}

func (ptr *QRasterWindow) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QRasterWindow::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QRasterWindow::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQRasterWindowTimerEvent
func callbackQRasterWindowTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQRasterWindowFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QRasterWindow) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QRasterWindow::timerEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QRasterWindow) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QRasterWindow::timerEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QRasterWindow) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QRasterWindow::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QRasterWindow::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQRasterWindowChildEvent
func callbackQRasterWindowChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQRasterWindowFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QRasterWindow) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QRasterWindow::childEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QRasterWindow) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QRasterWindow::childEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QRasterWindow) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QRasterWindow::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QRasterWindow) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QRasterWindow::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQRasterWindowCustomEvent
func callbackQRasterWindowCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRasterWindow::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQRasterWindowFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QRasterWindow) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QRasterWindow::customEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QRasterWindow) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QRasterWindow::customEvent")

	if ptr.Pointer() != nil {
		C.QRasterWindow_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QRawFont struct {
	ptr unsafe.Pointer
}

type QRawFont_ITF interface {
	QRawFont_PTR() *QRawFont
}

func (p *QRawFont) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QRawFont) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQRawFont(ptr QRawFont_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRawFont_PTR().Pointer()
	}
	return nil
}

func NewQRawFontFromPointer(ptr unsafe.Pointer) *QRawFont {
	var n = new(QRawFont)
	n.SetPointer(ptr)
	return n
}

func newQRawFontFromPointer(ptr unsafe.Pointer) *QRawFont {
	var n = NewQRawFontFromPointer(ptr)
	return n
}

func (ptr *QRawFont) QRawFont_PTR() *QRawFont {
	return ptr
}

//QRawFont::AntialiasingType
type QRawFont__AntialiasingType int64

const (
	QRawFont__PixelAntialiasing    = QRawFont__AntialiasingType(0)
	QRawFont__SubPixelAntialiasing = QRawFont__AntialiasingType(1)
)

//QRawFont::LayoutFlag
type QRawFont__LayoutFlag int64

const (
	QRawFont__SeparateAdvances = QRawFont__LayoutFlag(0)
	QRawFont__KernedAdvances   = QRawFont__LayoutFlag(1)
	QRawFont__UseDesignMetrics = QRawFont__LayoutFlag(2)
)

func NewQRawFont() *QRawFont {
	defer qt.Recovering("QRawFont::QRawFont")

	return newQRawFontFromPointer(C.QRawFont_NewQRawFont())
}

func NewQRawFont3(fontData core.QByteArray_ITF, pixelSize float64, hintingPreference QFont__HintingPreference) *QRawFont {
	defer qt.Recovering("QRawFont::QRawFont")

	return newQRawFontFromPointer(C.QRawFont_NewQRawFont3(core.PointerFromQByteArray(fontData), C.double(pixelSize), C.int(hintingPreference)))
}

func NewQRawFont4(other QRawFont_ITF) *QRawFont {
	defer qt.Recovering("QRawFont::QRawFont")

	return newQRawFontFromPointer(C.QRawFont_NewQRawFont4(PointerFromQRawFont(other)))
}

func NewQRawFont2(fileName string, pixelSize float64, hintingPreference QFont__HintingPreference) *QRawFont {
	defer qt.Recovering("QRawFont::QRawFont")

	return newQRawFontFromPointer(C.QRawFont_NewQRawFont2(C.CString(fileName), C.double(pixelSize), C.int(hintingPreference)))
}

func (ptr *QRawFont) Ascent() float64 {
	defer qt.Recovering("QRawFont::ascent")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_Ascent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) AverageCharWidth() float64 {
	defer qt.Recovering("QRawFont::averageCharWidth")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_AverageCharWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) Descent() float64 {
	defer qt.Recovering("QRawFont::descent")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_Descent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) FamilyName() string {
	defer qt.Recovering("QRawFont::familyName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRawFont_FamilyName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QRawFont) FontTable(tagName string) *core.QByteArray {
	defer qt.Recovering("QRawFont::fontTable")

	if ptr.Pointer() != nil {
		return core.NewQByteArrayFromPointer(C.QRawFont_FontTable(ptr.Pointer(), C.CString(tagName)))
	}
	return nil
}

func (ptr *QRawFont) HintingPreference() QFont__HintingPreference {
	defer qt.Recovering("QRawFont::hintingPreference")

	if ptr.Pointer() != nil {
		return QFont__HintingPreference(C.QRawFont_HintingPreference(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) IsValid() bool {
	defer qt.Recovering("QRawFont::isValid")

	if ptr.Pointer() != nil {
		return C.QRawFont_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRawFont) Leading() float64 {
	defer qt.Recovering("QRawFont::leading")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_Leading(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) LineThickness() float64 {
	defer qt.Recovering("QRawFont::lineThickness")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_LineThickness(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) LoadFromData(fontData core.QByteArray_ITF, pixelSize float64, hintingPreference QFont__HintingPreference) {
	defer qt.Recovering("QRawFont::loadFromData")

	if ptr.Pointer() != nil {
		C.QRawFont_LoadFromData(ptr.Pointer(), core.PointerFromQByteArray(fontData), C.double(pixelSize), C.int(hintingPreference))
	}
}

func (ptr *QRawFont) LoadFromFile(fileName string, pixelSize float64, hintingPreference QFont__HintingPreference) {
	defer qt.Recovering("QRawFont::loadFromFile")

	if ptr.Pointer() != nil {
		C.QRawFont_LoadFromFile(ptr.Pointer(), C.CString(fileName), C.double(pixelSize), C.int(hintingPreference))
	}
}

func (ptr *QRawFont) MaxCharWidth() float64 {
	defer qt.Recovering("QRawFont::maxCharWidth")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_MaxCharWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) PixelSize() float64 {
	defer qt.Recovering("QRawFont::pixelSize")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_PixelSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) SetPixelSize(pixelSize float64) {
	defer qt.Recovering("QRawFont::setPixelSize")

	if ptr.Pointer() != nil {
		C.QRawFont_SetPixelSize(ptr.Pointer(), C.double(pixelSize))
	}
}

func (ptr *QRawFont) Style() QFont__Style {
	defer qt.Recovering("QRawFont::style")

	if ptr.Pointer() != nil {
		return QFont__Style(C.QRawFont_Style(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) StyleName() string {
	defer qt.Recovering("QRawFont::styleName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QRawFont_StyleName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QRawFont) SupportsCharacter(character core.QChar_ITF) bool {
	defer qt.Recovering("QRawFont::supportsCharacter")

	if ptr.Pointer() != nil {
		return C.QRawFont_SupportsCharacter(ptr.Pointer(), core.PointerFromQChar(character)) != 0
	}
	return false
}

func (ptr *QRawFont) Swap(other QRawFont_ITF) {
	defer qt.Recovering("QRawFont::swap")

	if ptr.Pointer() != nil {
		C.QRawFont_Swap(ptr.Pointer(), PointerFromQRawFont(other))
	}
}

func (ptr *QRawFont) UnderlinePosition() float64 {
	defer qt.Recovering("QRawFont::underlinePosition")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_UnderlinePosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) UnitsPerEm() float64 {
	defer qt.Recovering("QRawFont::unitsPerEm")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_UnitsPerEm(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) Weight() int {
	defer qt.Recovering("QRawFont::weight")

	if ptr.Pointer() != nil {
		return int(C.QRawFont_Weight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) XHeight() float64 {
	defer qt.Recovering("QRawFont::xHeight")

	if ptr.Pointer() != nil {
		return float64(C.QRawFont_XHeight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRawFont) DestroyQRawFont() {
	defer qt.Recovering("QRawFont::~QRawFont")

	if ptr.Pointer() != nil {
		C.QRawFont_DestroyQRawFont(ptr.Pointer())
	}
}

type QRegExpValidator struct {
	QValidator
}

type QRegExpValidator_ITF interface {
	QValidator_ITF
	QRegExpValidator_PTR() *QRegExpValidator
}

func PointerFromQRegExpValidator(ptr QRegExpValidator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegExpValidator_PTR().Pointer()
	}
	return nil
}

func NewQRegExpValidatorFromPointer(ptr unsafe.Pointer) *QRegExpValidator {
	var n = new(QRegExpValidator)
	n.SetPointer(ptr)
	return n
}

func newQRegExpValidatorFromPointer(ptr unsafe.Pointer) *QRegExpValidator {
	var n = NewQRegExpValidatorFromPointer(ptr)
	for len(n.ObjectName()) < len("QRegExpValidator_") {
		n.SetObjectName("QRegExpValidator_" + qt.Identifier())
	}
	return n
}

func (ptr *QRegExpValidator) QRegExpValidator_PTR() *QRegExpValidator {
	return ptr
}

func (ptr *QRegExpValidator) SetRegExp(rx core.QRegExp_ITF) {
	defer qt.Recovering("QRegExpValidator::setRegExp")

	if ptr.Pointer() != nil {
		C.QRegExpValidator_SetRegExp(ptr.Pointer(), core.PointerFromQRegExp(rx))
	}
}

func NewQRegExpValidator(parent core.QObject_ITF) *QRegExpValidator {
	defer qt.Recovering("QRegExpValidator::QRegExpValidator")

	return newQRegExpValidatorFromPointer(C.QRegExpValidator_NewQRegExpValidator(core.PointerFromQObject(parent)))
}

func NewQRegExpValidator2(rx core.QRegExp_ITF, parent core.QObject_ITF) *QRegExpValidator {
	defer qt.Recovering("QRegExpValidator::QRegExpValidator")

	return newQRegExpValidatorFromPointer(C.QRegExpValidator_NewQRegExpValidator2(core.PointerFromQRegExp(rx), core.PointerFromQObject(parent)))
}

func (ptr *QRegExpValidator) RegExp() *core.QRegExp {
	defer qt.Recovering("QRegExpValidator::regExp")

	if ptr.Pointer() != nil {
		return core.NewQRegExpFromPointer(C.QRegExpValidator_RegExp(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRegExpValidator) DestroyQRegExpValidator() {
	defer qt.Recovering("QRegExpValidator::~QRegExpValidator")

	if ptr.Pointer() != nil {
		C.QRegExpValidator_DestroyQRegExpValidator(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QRegExpValidator) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QRegExpValidator::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QRegExpValidator) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QRegExpValidator::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQRegExpValidatorTimerEvent
func callbackQRegExpValidatorTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRegExpValidator::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQRegExpValidatorFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QRegExpValidator) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QRegExpValidator::timerEvent")

	if ptr.Pointer() != nil {
		C.QRegExpValidator_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QRegExpValidator) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QRegExpValidator::timerEvent")

	if ptr.Pointer() != nil {
		C.QRegExpValidator_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QRegExpValidator) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QRegExpValidator::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QRegExpValidator) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QRegExpValidator::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQRegExpValidatorChildEvent
func callbackQRegExpValidatorChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRegExpValidator::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQRegExpValidatorFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QRegExpValidator) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QRegExpValidator::childEvent")

	if ptr.Pointer() != nil {
		C.QRegExpValidator_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QRegExpValidator) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QRegExpValidator::childEvent")

	if ptr.Pointer() != nil {
		C.QRegExpValidator_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QRegExpValidator) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QRegExpValidator::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QRegExpValidator) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QRegExpValidator::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQRegExpValidatorCustomEvent
func callbackQRegExpValidatorCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRegExpValidator::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQRegExpValidatorFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QRegExpValidator) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QRegExpValidator::customEvent")

	if ptr.Pointer() != nil {
		C.QRegExpValidator_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QRegExpValidator) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QRegExpValidator::customEvent")

	if ptr.Pointer() != nil {
		C.QRegExpValidator_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QRegion struct {
	ptr unsafe.Pointer
}

type QRegion_ITF interface {
	QRegion_PTR() *QRegion
}

func (p *QRegion) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QRegion) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQRegion(ptr QRegion_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegion_PTR().Pointer()
	}
	return nil
}

func NewQRegionFromPointer(ptr unsafe.Pointer) *QRegion {
	var n = new(QRegion)
	n.SetPointer(ptr)
	return n
}

func newQRegionFromPointer(ptr unsafe.Pointer) *QRegion {
	var n = NewQRegionFromPointer(ptr)
	return n
}

func (ptr *QRegion) QRegion_PTR() *QRegion {
	return ptr
}

//QRegion::RegionType
type QRegion__RegionType int64

const (
	QRegion__Rectangle = QRegion__RegionType(0)
	QRegion__Ellipse   = QRegion__RegionType(1)
)

func NewQRegion() *QRegion {
	defer qt.Recovering("QRegion::QRegion")

	return newQRegionFromPointer(C.QRegion_NewQRegion())
}

func NewQRegion5(bm QBitmap_ITF) *QRegion {
	defer qt.Recovering("QRegion::QRegion")

	return newQRegionFromPointer(C.QRegion_NewQRegion5(PointerFromQBitmap(bm)))
}

func NewQRegion3(a QPolygon_ITF, fillRule core.Qt__FillRule) *QRegion {
	defer qt.Recovering("QRegion::QRegion")

	return newQRegionFromPointer(C.QRegion_NewQRegion3(PointerFromQPolygon(a), C.int(fillRule)))
}

func NewQRegion6(r core.QRect_ITF, t QRegion__RegionType) *QRegion {
	defer qt.Recovering("QRegion::QRegion")

	return newQRegionFromPointer(C.QRegion_NewQRegion6(core.PointerFromQRect(r), C.int(t)))
}

func NewQRegion4(r QRegion_ITF) *QRegion {
	defer qt.Recovering("QRegion::QRegion")

	return newQRegionFromPointer(C.QRegion_NewQRegion4(PointerFromQRegion(r)))
}

func (ptr *QRegion) BoundingRect() *core.QRect {
	defer qt.Recovering("QRegion::boundingRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QRegion_BoundingRect(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRegion) Contains(p core.QPoint_ITF) bool {
	defer qt.Recovering("QRegion::contains")

	if ptr.Pointer() != nil {
		return C.QRegion_Contains(ptr.Pointer(), core.PointerFromQPoint(p)) != 0
	}
	return false
}

func (ptr *QRegion) Contains2(r core.QRect_ITF) bool {
	defer qt.Recovering("QRegion::contains")

	if ptr.Pointer() != nil {
		return C.QRegion_Contains2(ptr.Pointer(), core.PointerFromQRect(r)) != 0
	}
	return false
}

func (ptr *QRegion) Intersected2(rect core.QRect_ITF) *QRegion {
	defer qt.Recovering("QRegion::intersected")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QRegion_Intersected2(ptr.Pointer(), core.PointerFromQRect(rect)))
	}
	return nil
}

func (ptr *QRegion) Intersected(r QRegion_ITF) *QRegion {
	defer qt.Recovering("QRegion::intersected")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QRegion_Intersected(ptr.Pointer(), PointerFromQRegion(r)))
	}
	return nil
}

func (ptr *QRegion) Intersects2(rect core.QRect_ITF) bool {
	defer qt.Recovering("QRegion::intersects")

	if ptr.Pointer() != nil {
		return C.QRegion_Intersects2(ptr.Pointer(), core.PointerFromQRect(rect)) != 0
	}
	return false
}

func (ptr *QRegion) IsEmpty() bool {
	defer qt.Recovering("QRegion::isEmpty")

	if ptr.Pointer() != nil {
		return C.QRegion_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRegion) IsNull() bool {
	defer qt.Recovering("QRegion::isNull")

	if ptr.Pointer() != nil {
		return C.QRegion_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QRegion) RectCount() int {
	defer qt.Recovering("QRegion::rectCount")

	if ptr.Pointer() != nil {
		return int(C.QRegion_RectCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QRegion) SetRects(rects core.QRect_ITF, number int) {
	defer qt.Recovering("QRegion::setRects")

	if ptr.Pointer() != nil {
		C.QRegion_SetRects(ptr.Pointer(), core.PointerFromQRect(rects), C.int(number))
	}
}

func (ptr *QRegion) Subtracted(r QRegion_ITF) *QRegion {
	defer qt.Recovering("QRegion::subtracted")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QRegion_Subtracted(ptr.Pointer(), PointerFromQRegion(r)))
	}
	return nil
}

func (ptr *QRegion) Translate(dx int, dy int) {
	defer qt.Recovering("QRegion::translate")

	if ptr.Pointer() != nil {
		C.QRegion_Translate(ptr.Pointer(), C.int(dx), C.int(dy))
	}
}

func (ptr *QRegion) United2(rect core.QRect_ITF) *QRegion {
	defer qt.Recovering("QRegion::united")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QRegion_United2(ptr.Pointer(), core.PointerFromQRect(rect)))
	}
	return nil
}

func (ptr *QRegion) United(r QRegion_ITF) *QRegion {
	defer qt.Recovering("QRegion::united")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QRegion_United(ptr.Pointer(), PointerFromQRegion(r)))
	}
	return nil
}

func (ptr *QRegion) Xored(r QRegion_ITF) *QRegion {
	defer qt.Recovering("QRegion::xored")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QRegion_Xored(ptr.Pointer(), PointerFromQRegion(r)))
	}
	return nil
}

func NewQRegion2(x int, y int, w int, h int, t QRegion__RegionType) *QRegion {
	defer qt.Recovering("QRegion::QRegion")

	return newQRegionFromPointer(C.QRegion_NewQRegion2(C.int(x), C.int(y), C.int(w), C.int(h), C.int(t)))
}

func (ptr *QRegion) Intersects(region QRegion_ITF) bool {
	defer qt.Recovering("QRegion::intersects")

	if ptr.Pointer() != nil {
		return C.QRegion_Intersects(ptr.Pointer(), PointerFromQRegion(region)) != 0
	}
	return false
}

func (ptr *QRegion) Swap(other QRegion_ITF) {
	defer qt.Recovering("QRegion::swap")

	if ptr.Pointer() != nil {
		C.QRegion_Swap(ptr.Pointer(), PointerFromQRegion(other))
	}
}

func (ptr *QRegion) Translate2(point core.QPoint_ITF) {
	defer qt.Recovering("QRegion::translate")

	if ptr.Pointer() != nil {
		C.QRegion_Translate2(ptr.Pointer(), core.PointerFromQPoint(point))
	}
}

func (ptr *QRegion) Translated2(p core.QPoint_ITF) *QRegion {
	defer qt.Recovering("QRegion::translated")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QRegion_Translated2(ptr.Pointer(), core.PointerFromQPoint(p)))
	}
	return nil
}

func (ptr *QRegion) Translated(dx int, dy int) *QRegion {
	defer qt.Recovering("QRegion::translated")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QRegion_Translated(ptr.Pointer(), C.int(dx), C.int(dy)))
	}
	return nil
}

type QRegularExpressionValidator struct {
	QValidator
}

type QRegularExpressionValidator_ITF interface {
	QValidator_ITF
	QRegularExpressionValidator_PTR() *QRegularExpressionValidator
}

func PointerFromQRegularExpressionValidator(ptr QRegularExpressionValidator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QRegularExpressionValidator_PTR().Pointer()
	}
	return nil
}

func NewQRegularExpressionValidatorFromPointer(ptr unsafe.Pointer) *QRegularExpressionValidator {
	var n = new(QRegularExpressionValidator)
	n.SetPointer(ptr)
	return n
}

func newQRegularExpressionValidatorFromPointer(ptr unsafe.Pointer) *QRegularExpressionValidator {
	var n = NewQRegularExpressionValidatorFromPointer(ptr)
	for len(n.ObjectName()) < len("QRegularExpressionValidator_") {
		n.SetObjectName("QRegularExpressionValidator_" + qt.Identifier())
	}
	return n
}

func (ptr *QRegularExpressionValidator) QRegularExpressionValidator_PTR() *QRegularExpressionValidator {
	return ptr
}

func (ptr *QRegularExpressionValidator) RegularExpression() *core.QRegularExpression {
	defer qt.Recovering("QRegularExpressionValidator::regularExpression")

	if ptr.Pointer() != nil {
		return core.NewQRegularExpressionFromPointer(C.QRegularExpressionValidator_RegularExpression(ptr.Pointer()))
	}
	return nil
}

func (ptr *QRegularExpressionValidator) SetRegularExpression(re core.QRegularExpression_ITF) {
	defer qt.Recovering("QRegularExpressionValidator::setRegularExpression")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_SetRegularExpression(ptr.Pointer(), core.PointerFromQRegularExpression(re))
	}
}

func NewQRegularExpressionValidator(parent core.QObject_ITF) *QRegularExpressionValidator {
	defer qt.Recovering("QRegularExpressionValidator::QRegularExpressionValidator")

	return newQRegularExpressionValidatorFromPointer(C.QRegularExpressionValidator_NewQRegularExpressionValidator(core.PointerFromQObject(parent)))
}

func NewQRegularExpressionValidator2(re core.QRegularExpression_ITF, parent core.QObject_ITF) *QRegularExpressionValidator {
	defer qt.Recovering("QRegularExpressionValidator::QRegularExpressionValidator")

	return newQRegularExpressionValidatorFromPointer(C.QRegularExpressionValidator_NewQRegularExpressionValidator2(core.PointerFromQRegularExpression(re), core.PointerFromQObject(parent)))
}

func (ptr *QRegularExpressionValidator) ConnectRegularExpressionChanged(f func(re *core.QRegularExpression)) {
	defer qt.Recovering("connect QRegularExpressionValidator::regularExpressionChanged")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_ConnectRegularExpressionChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "regularExpressionChanged", f)
	}
}

func (ptr *QRegularExpressionValidator) DisconnectRegularExpressionChanged() {
	defer qt.Recovering("disconnect QRegularExpressionValidator::regularExpressionChanged")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_DisconnectRegularExpressionChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "regularExpressionChanged")
	}
}

//export callbackQRegularExpressionValidatorRegularExpressionChanged
func callbackQRegularExpressionValidatorRegularExpressionChanged(ptr unsafe.Pointer, ptrName *C.char, re unsafe.Pointer) {
	defer qt.Recovering("callback QRegularExpressionValidator::regularExpressionChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "regularExpressionChanged"); signal != nil {
		signal.(func(*core.QRegularExpression))(core.NewQRegularExpressionFromPointer(re))
	}

}

func (ptr *QRegularExpressionValidator) RegularExpressionChanged(re core.QRegularExpression_ITF) {
	defer qt.Recovering("QRegularExpressionValidator::regularExpressionChanged")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_RegularExpressionChanged(ptr.Pointer(), core.PointerFromQRegularExpression(re))
	}
}

func (ptr *QRegularExpressionValidator) DestroyQRegularExpressionValidator() {
	defer qt.Recovering("QRegularExpressionValidator::~QRegularExpressionValidator")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_DestroyQRegularExpressionValidator(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QRegularExpressionValidator) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QRegularExpressionValidator::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QRegularExpressionValidator) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QRegularExpressionValidator::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQRegularExpressionValidatorTimerEvent
func callbackQRegularExpressionValidatorTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRegularExpressionValidator::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQRegularExpressionValidatorFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QRegularExpressionValidator) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QRegularExpressionValidator::timerEvent")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QRegularExpressionValidator) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QRegularExpressionValidator::timerEvent")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QRegularExpressionValidator) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QRegularExpressionValidator::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QRegularExpressionValidator) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QRegularExpressionValidator::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQRegularExpressionValidatorChildEvent
func callbackQRegularExpressionValidatorChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRegularExpressionValidator::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQRegularExpressionValidatorFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QRegularExpressionValidator) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QRegularExpressionValidator::childEvent")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QRegularExpressionValidator) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QRegularExpressionValidator::childEvent")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QRegularExpressionValidator) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QRegularExpressionValidator::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QRegularExpressionValidator) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QRegularExpressionValidator::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQRegularExpressionValidatorCustomEvent
func callbackQRegularExpressionValidatorCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QRegularExpressionValidator::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQRegularExpressionValidatorFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QRegularExpressionValidator) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QRegularExpressionValidator::customEvent")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QRegularExpressionValidator) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QRegularExpressionValidator::customEvent")

	if ptr.Pointer() != nil {
		C.QRegularExpressionValidator_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QResizeEvent struct {
	core.QEvent
}

type QResizeEvent_ITF interface {
	core.QEvent_ITF
	QResizeEvent_PTR() *QResizeEvent
}

func PointerFromQResizeEvent(ptr QResizeEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QResizeEvent_PTR().Pointer()
	}
	return nil
}

func NewQResizeEventFromPointer(ptr unsafe.Pointer) *QResizeEvent {
	var n = new(QResizeEvent)
	n.SetPointer(ptr)
	return n
}

func newQResizeEventFromPointer(ptr unsafe.Pointer) *QResizeEvent {
	var n = NewQResizeEventFromPointer(ptr)
	return n
}

func (ptr *QResizeEvent) QResizeEvent_PTR() *QResizeEvent {
	return ptr
}

func NewQResizeEvent(size core.QSize_ITF, oldSize core.QSize_ITF) *QResizeEvent {
	defer qt.Recovering("QResizeEvent::QResizeEvent")

	return newQResizeEventFromPointer(C.QResizeEvent_NewQResizeEvent(core.PointerFromQSize(size), core.PointerFromQSize(oldSize)))
}

func (ptr *QResizeEvent) OldSize() *core.QSize {
	defer qt.Recovering("QResizeEvent::oldSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QResizeEvent_OldSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QResizeEvent) Size() *core.QSize {
	defer qt.Recovering("QResizeEvent::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QResizeEvent_Size(ptr.Pointer()))
	}
	return nil
}

type QScreen struct {
	core.QObject
}

type QScreen_ITF interface {
	core.QObject_ITF
	QScreen_PTR() *QScreen
}

func PointerFromQScreen(ptr QScreen_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScreen_PTR().Pointer()
	}
	return nil
}

func NewQScreenFromPointer(ptr unsafe.Pointer) *QScreen {
	var n = new(QScreen)
	n.SetPointer(ptr)
	return n
}

func newQScreenFromPointer(ptr unsafe.Pointer) *QScreen {
	var n = NewQScreenFromPointer(ptr)
	for len(n.ObjectName()) < len("QScreen_") {
		n.SetObjectName("QScreen_" + qt.Identifier())
	}
	return n
}

func (ptr *QScreen) QScreen_PTR() *QScreen {
	return ptr
}

func (ptr *QScreen) AvailableGeometry() *core.QRect {
	defer qt.Recovering("QScreen::availableGeometry")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QScreen_AvailableGeometry(ptr.Pointer()))
	}
	return nil
}

func (ptr *QScreen) AvailableSize() *core.QSize {
	defer qt.Recovering("QScreen::availableSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QScreen_AvailableSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QScreen) AvailableVirtualGeometry() *core.QRect {
	defer qt.Recovering("QScreen::availableVirtualGeometry")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QScreen_AvailableVirtualGeometry(ptr.Pointer()))
	}
	return nil
}

func (ptr *QScreen) AvailableVirtualSize() *core.QSize {
	defer qt.Recovering("QScreen::availableVirtualSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QScreen_AvailableVirtualSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QScreen) Depth() int {
	defer qt.Recovering("QScreen::depth")

	if ptr.Pointer() != nil {
		return int(C.QScreen_Depth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) DevicePixelRatio() float64 {
	defer qt.Recovering("QScreen::devicePixelRatio")

	if ptr.Pointer() != nil {
		return float64(C.QScreen_DevicePixelRatio(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) Geometry() *core.QRect {
	defer qt.Recovering("QScreen::geometry")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QScreen_Geometry(ptr.Pointer()))
	}
	return nil
}

func (ptr *QScreen) LogicalDotsPerInch() float64 {
	defer qt.Recovering("QScreen::logicalDotsPerInch")

	if ptr.Pointer() != nil {
		return float64(C.QScreen_LogicalDotsPerInch(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) LogicalDotsPerInchX() float64 {
	defer qt.Recovering("QScreen::logicalDotsPerInchX")

	if ptr.Pointer() != nil {
		return float64(C.QScreen_LogicalDotsPerInchX(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) LogicalDotsPerInchY() float64 {
	defer qt.Recovering("QScreen::logicalDotsPerInchY")

	if ptr.Pointer() != nil {
		return float64(C.QScreen_LogicalDotsPerInchY(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) Name() string {
	defer qt.Recovering("QScreen::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QScreen_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QScreen) NativeOrientation() core.Qt__ScreenOrientation {
	defer qt.Recovering("QScreen::nativeOrientation")

	if ptr.Pointer() != nil {
		return core.Qt__ScreenOrientation(C.QScreen_NativeOrientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) Orientation() core.Qt__ScreenOrientation {
	defer qt.Recovering("QScreen::orientation")

	if ptr.Pointer() != nil {
		return core.Qt__ScreenOrientation(C.QScreen_Orientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) PhysicalDotsPerInch() float64 {
	defer qt.Recovering("QScreen::physicalDotsPerInch")

	if ptr.Pointer() != nil {
		return float64(C.QScreen_PhysicalDotsPerInch(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) PhysicalDotsPerInchX() float64 {
	defer qt.Recovering("QScreen::physicalDotsPerInchX")

	if ptr.Pointer() != nil {
		return float64(C.QScreen_PhysicalDotsPerInchX(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) PhysicalDotsPerInchY() float64 {
	defer qt.Recovering("QScreen::physicalDotsPerInchY")

	if ptr.Pointer() != nil {
		return float64(C.QScreen_PhysicalDotsPerInchY(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) PrimaryOrientation() core.Qt__ScreenOrientation {
	defer qt.Recovering("QScreen::primaryOrientation")

	if ptr.Pointer() != nil {
		return core.Qt__ScreenOrientation(C.QScreen_PrimaryOrientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) RefreshRate() float64 {
	defer qt.Recovering("QScreen::refreshRate")

	if ptr.Pointer() != nil {
		return float64(C.QScreen_RefreshRate(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) Size() *core.QSize {
	defer qt.Recovering("QScreen::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QScreen_Size(ptr.Pointer()))
	}
	return nil
}

func (ptr *QScreen) VirtualGeometry() *core.QRect {
	defer qt.Recovering("QScreen::virtualGeometry")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QScreen_VirtualGeometry(ptr.Pointer()))
	}
	return nil
}

func (ptr *QScreen) VirtualSize() *core.QSize {
	defer qt.Recovering("QScreen::virtualSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QScreen_VirtualSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QScreen) AngleBetween(a core.Qt__ScreenOrientation, b core.Qt__ScreenOrientation) int {
	defer qt.Recovering("QScreen::angleBetween")

	if ptr.Pointer() != nil {
		return int(C.QScreen_AngleBetween(ptr.Pointer(), C.int(a), C.int(b)))
	}
	return 0
}

func (ptr *QScreen) ConnectAvailableGeometryChanged(f func(geometry *core.QRect)) {
	defer qt.Recovering("connect QScreen::availableGeometryChanged")

	if ptr.Pointer() != nil {
		C.QScreen_ConnectAvailableGeometryChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "availableGeometryChanged", f)
	}
}

func (ptr *QScreen) DisconnectAvailableGeometryChanged() {
	defer qt.Recovering("disconnect QScreen::availableGeometryChanged")

	if ptr.Pointer() != nil {
		C.QScreen_DisconnectAvailableGeometryChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "availableGeometryChanged")
	}
}

//export callbackQScreenAvailableGeometryChanged
func callbackQScreenAvailableGeometryChanged(ptr unsafe.Pointer, ptrName *C.char, geometry unsafe.Pointer) {
	defer qt.Recovering("callback QScreen::availableGeometryChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "availableGeometryChanged"); signal != nil {
		signal.(func(*core.QRect))(core.NewQRectFromPointer(geometry))
	}

}

func (ptr *QScreen) AvailableGeometryChanged(geometry core.QRect_ITF) {
	defer qt.Recovering("QScreen::availableGeometryChanged")

	if ptr.Pointer() != nil {
		C.QScreen_AvailableGeometryChanged(ptr.Pointer(), core.PointerFromQRect(geometry))
	}
}

func (ptr *QScreen) ConnectGeometryChanged(f func(geometry *core.QRect)) {
	defer qt.Recovering("connect QScreen::geometryChanged")

	if ptr.Pointer() != nil {
		C.QScreen_ConnectGeometryChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "geometryChanged", f)
	}
}

func (ptr *QScreen) DisconnectGeometryChanged() {
	defer qt.Recovering("disconnect QScreen::geometryChanged")

	if ptr.Pointer() != nil {
		C.QScreen_DisconnectGeometryChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "geometryChanged")
	}
}

//export callbackQScreenGeometryChanged
func callbackQScreenGeometryChanged(ptr unsafe.Pointer, ptrName *C.char, geometry unsafe.Pointer) {
	defer qt.Recovering("callback QScreen::geometryChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "geometryChanged"); signal != nil {
		signal.(func(*core.QRect))(core.NewQRectFromPointer(geometry))
	}

}

func (ptr *QScreen) GeometryChanged(geometry core.QRect_ITF) {
	defer qt.Recovering("QScreen::geometryChanged")

	if ptr.Pointer() != nil {
		C.QScreen_GeometryChanged(ptr.Pointer(), core.PointerFromQRect(geometry))
	}
}

func (ptr *QScreen) IsLandscape(o core.Qt__ScreenOrientation) bool {
	defer qt.Recovering("QScreen::isLandscape")

	if ptr.Pointer() != nil {
		return C.QScreen_IsLandscape(ptr.Pointer(), C.int(o)) != 0
	}
	return false
}

func (ptr *QScreen) IsPortrait(o core.Qt__ScreenOrientation) bool {
	defer qt.Recovering("QScreen::isPortrait")

	if ptr.Pointer() != nil {
		return C.QScreen_IsPortrait(ptr.Pointer(), C.int(o)) != 0
	}
	return false
}

func (ptr *QScreen) ConnectLogicalDotsPerInchChanged(f func(dpi float64)) {
	defer qt.Recovering("connect QScreen::logicalDotsPerInchChanged")

	if ptr.Pointer() != nil {
		C.QScreen_ConnectLogicalDotsPerInchChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "logicalDotsPerInchChanged", f)
	}
}

func (ptr *QScreen) DisconnectLogicalDotsPerInchChanged() {
	defer qt.Recovering("disconnect QScreen::logicalDotsPerInchChanged")

	if ptr.Pointer() != nil {
		C.QScreen_DisconnectLogicalDotsPerInchChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "logicalDotsPerInchChanged")
	}
}

//export callbackQScreenLogicalDotsPerInchChanged
func callbackQScreenLogicalDotsPerInchChanged(ptr unsafe.Pointer, ptrName *C.char, dpi C.double) {
	defer qt.Recovering("callback QScreen::logicalDotsPerInchChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "logicalDotsPerInchChanged"); signal != nil {
		signal.(func(float64))(float64(dpi))
	}

}

func (ptr *QScreen) LogicalDotsPerInchChanged(dpi float64) {
	defer qt.Recovering("QScreen::logicalDotsPerInchChanged")

	if ptr.Pointer() != nil {
		C.QScreen_LogicalDotsPerInchChanged(ptr.Pointer(), C.double(dpi))
	}
}

func (ptr *QScreen) MapBetween(a core.Qt__ScreenOrientation, b core.Qt__ScreenOrientation, rect core.QRect_ITF) *core.QRect {
	defer qt.Recovering("QScreen::mapBetween")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QScreen_MapBetween(ptr.Pointer(), C.int(a), C.int(b), core.PointerFromQRect(rect)))
	}
	return nil
}

func (ptr *QScreen) ConnectOrientationChanged(f func(orientation core.Qt__ScreenOrientation)) {
	defer qt.Recovering("connect QScreen::orientationChanged")

	if ptr.Pointer() != nil {
		C.QScreen_ConnectOrientationChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "orientationChanged", f)
	}
}

func (ptr *QScreen) DisconnectOrientationChanged() {
	defer qt.Recovering("disconnect QScreen::orientationChanged")

	if ptr.Pointer() != nil {
		C.QScreen_DisconnectOrientationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "orientationChanged")
	}
}

//export callbackQScreenOrientationChanged
func callbackQScreenOrientationChanged(ptr unsafe.Pointer, ptrName *C.char, orientation C.int) {
	defer qt.Recovering("callback QScreen::orientationChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "orientationChanged"); signal != nil {
		signal.(func(core.Qt__ScreenOrientation))(core.Qt__ScreenOrientation(orientation))
	}

}

func (ptr *QScreen) OrientationChanged(orientation core.Qt__ScreenOrientation) {
	defer qt.Recovering("QScreen::orientationChanged")

	if ptr.Pointer() != nil {
		C.QScreen_OrientationChanged(ptr.Pointer(), C.int(orientation))
	}
}

func (ptr *QScreen) OrientationUpdateMask() core.Qt__ScreenOrientation {
	defer qt.Recovering("QScreen::orientationUpdateMask")

	if ptr.Pointer() != nil {
		return core.Qt__ScreenOrientation(C.QScreen_OrientationUpdateMask(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScreen) ConnectPhysicalDotsPerInchChanged(f func(dpi float64)) {
	defer qt.Recovering("connect QScreen::physicalDotsPerInchChanged")

	if ptr.Pointer() != nil {
		C.QScreen_ConnectPhysicalDotsPerInchChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "physicalDotsPerInchChanged", f)
	}
}

func (ptr *QScreen) DisconnectPhysicalDotsPerInchChanged() {
	defer qt.Recovering("disconnect QScreen::physicalDotsPerInchChanged")

	if ptr.Pointer() != nil {
		C.QScreen_DisconnectPhysicalDotsPerInchChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "physicalDotsPerInchChanged")
	}
}

//export callbackQScreenPhysicalDotsPerInchChanged
func callbackQScreenPhysicalDotsPerInchChanged(ptr unsafe.Pointer, ptrName *C.char, dpi C.double) {
	defer qt.Recovering("callback QScreen::physicalDotsPerInchChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "physicalDotsPerInchChanged"); signal != nil {
		signal.(func(float64))(float64(dpi))
	}

}

func (ptr *QScreen) PhysicalDotsPerInchChanged(dpi float64) {
	defer qt.Recovering("QScreen::physicalDotsPerInchChanged")

	if ptr.Pointer() != nil {
		C.QScreen_PhysicalDotsPerInchChanged(ptr.Pointer(), C.double(dpi))
	}
}

func (ptr *QScreen) ConnectPrimaryOrientationChanged(f func(orientation core.Qt__ScreenOrientation)) {
	defer qt.Recovering("connect QScreen::primaryOrientationChanged")

	if ptr.Pointer() != nil {
		C.QScreen_ConnectPrimaryOrientationChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "primaryOrientationChanged", f)
	}
}

func (ptr *QScreen) DisconnectPrimaryOrientationChanged() {
	defer qt.Recovering("disconnect QScreen::primaryOrientationChanged")

	if ptr.Pointer() != nil {
		C.QScreen_DisconnectPrimaryOrientationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "primaryOrientationChanged")
	}
}

//export callbackQScreenPrimaryOrientationChanged
func callbackQScreenPrimaryOrientationChanged(ptr unsafe.Pointer, ptrName *C.char, orientation C.int) {
	defer qt.Recovering("callback QScreen::primaryOrientationChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "primaryOrientationChanged"); signal != nil {
		signal.(func(core.Qt__ScreenOrientation))(core.Qt__ScreenOrientation(orientation))
	}

}

func (ptr *QScreen) PrimaryOrientationChanged(orientation core.Qt__ScreenOrientation) {
	defer qt.Recovering("QScreen::primaryOrientationChanged")

	if ptr.Pointer() != nil {
		C.QScreen_PrimaryOrientationChanged(ptr.Pointer(), C.int(orientation))
	}
}

func (ptr *QScreen) ConnectRefreshRateChanged(f func(refreshRate float64)) {
	defer qt.Recovering("connect QScreen::refreshRateChanged")

	if ptr.Pointer() != nil {
		C.QScreen_ConnectRefreshRateChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "refreshRateChanged", f)
	}
}

func (ptr *QScreen) DisconnectRefreshRateChanged() {
	defer qt.Recovering("disconnect QScreen::refreshRateChanged")

	if ptr.Pointer() != nil {
		C.QScreen_DisconnectRefreshRateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "refreshRateChanged")
	}
}

//export callbackQScreenRefreshRateChanged
func callbackQScreenRefreshRateChanged(ptr unsafe.Pointer, ptrName *C.char, refreshRate C.double) {
	defer qt.Recovering("callback QScreen::refreshRateChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "refreshRateChanged"); signal != nil {
		signal.(func(float64))(float64(refreshRate))
	}

}

func (ptr *QScreen) RefreshRateChanged(refreshRate float64) {
	defer qt.Recovering("QScreen::refreshRateChanged")

	if ptr.Pointer() != nil {
		C.QScreen_RefreshRateChanged(ptr.Pointer(), C.double(refreshRate))
	}
}

func (ptr *QScreen) SetOrientationUpdateMask(mask core.Qt__ScreenOrientation) {
	defer qt.Recovering("QScreen::setOrientationUpdateMask")

	if ptr.Pointer() != nil {
		C.QScreen_SetOrientationUpdateMask(ptr.Pointer(), C.int(mask))
	}
}

func (ptr *QScreen) ConnectVirtualGeometryChanged(f func(rect *core.QRect)) {
	defer qt.Recovering("connect QScreen::virtualGeometryChanged")

	if ptr.Pointer() != nil {
		C.QScreen_ConnectVirtualGeometryChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "virtualGeometryChanged", f)
	}
}

func (ptr *QScreen) DisconnectVirtualGeometryChanged() {
	defer qt.Recovering("disconnect QScreen::virtualGeometryChanged")

	if ptr.Pointer() != nil {
		C.QScreen_DisconnectVirtualGeometryChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "virtualGeometryChanged")
	}
}

//export callbackQScreenVirtualGeometryChanged
func callbackQScreenVirtualGeometryChanged(ptr unsafe.Pointer, ptrName *C.char, rect unsafe.Pointer) {
	defer qt.Recovering("callback QScreen::virtualGeometryChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "virtualGeometryChanged"); signal != nil {
		signal.(func(*core.QRect))(core.NewQRectFromPointer(rect))
	}

}

func (ptr *QScreen) VirtualGeometryChanged(rect core.QRect_ITF) {
	defer qt.Recovering("QScreen::virtualGeometryChanged")

	if ptr.Pointer() != nil {
		C.QScreen_VirtualGeometryChanged(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QScreen) DestroyQScreen() {
	defer qt.Recovering("QScreen::~QScreen")

	if ptr.Pointer() != nil {
		C.QScreen_DestroyQScreen(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QScreen) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QScreen::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QScreen) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QScreen::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQScreenTimerEvent
func callbackQScreenTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QScreen::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQScreenFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QScreen) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QScreen::timerEvent")

	if ptr.Pointer() != nil {
		C.QScreen_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QScreen) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QScreen::timerEvent")

	if ptr.Pointer() != nil {
		C.QScreen_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QScreen) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QScreen::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QScreen) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QScreen::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQScreenChildEvent
func callbackQScreenChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QScreen::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQScreenFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QScreen) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QScreen::childEvent")

	if ptr.Pointer() != nil {
		C.QScreen_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QScreen) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QScreen::childEvent")

	if ptr.Pointer() != nil {
		C.QScreen_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QScreen) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QScreen::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QScreen) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QScreen::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQScreenCustomEvent
func callbackQScreenCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QScreen::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQScreenFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QScreen) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QScreen::customEvent")

	if ptr.Pointer() != nil {
		C.QScreen_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QScreen) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QScreen::customEvent")

	if ptr.Pointer() != nil {
		C.QScreen_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QScrollEvent struct {
	core.QEvent
}

type QScrollEvent_ITF interface {
	core.QEvent_ITF
	QScrollEvent_PTR() *QScrollEvent
}

func PointerFromQScrollEvent(ptr QScrollEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScrollEvent_PTR().Pointer()
	}
	return nil
}

func NewQScrollEventFromPointer(ptr unsafe.Pointer) *QScrollEvent {
	var n = new(QScrollEvent)
	n.SetPointer(ptr)
	return n
}

func newQScrollEventFromPointer(ptr unsafe.Pointer) *QScrollEvent {
	var n = NewQScrollEventFromPointer(ptr)
	return n
}

func (ptr *QScrollEvent) QScrollEvent_PTR() *QScrollEvent {
	return ptr
}

//QScrollEvent::ScrollState
type QScrollEvent__ScrollState int64

const (
	QScrollEvent__ScrollStarted  = QScrollEvent__ScrollState(0)
	QScrollEvent__ScrollUpdated  = QScrollEvent__ScrollState(1)
	QScrollEvent__ScrollFinished = QScrollEvent__ScrollState(2)
)

func NewQScrollEvent(contentPos core.QPointF_ITF, overshootDistance core.QPointF_ITF, scrollState QScrollEvent__ScrollState) *QScrollEvent {
	defer qt.Recovering("QScrollEvent::QScrollEvent")

	return newQScrollEventFromPointer(C.QScrollEvent_NewQScrollEvent(core.PointerFromQPointF(contentPos), core.PointerFromQPointF(overshootDistance), C.int(scrollState)))
}

func (ptr *QScrollEvent) ScrollState() QScrollEvent__ScrollState {
	defer qt.Recovering("QScrollEvent::scrollState")

	if ptr.Pointer() != nil {
		return QScrollEvent__ScrollState(C.QScrollEvent_ScrollState(ptr.Pointer()))
	}
	return 0
}

func (ptr *QScrollEvent) DestroyQScrollEvent() {
	defer qt.Recovering("QScrollEvent::~QScrollEvent")

	if ptr.Pointer() != nil {
		C.QScrollEvent_DestroyQScrollEvent(ptr.Pointer())
	}
}

type QScrollPrepareEvent struct {
	core.QEvent
}

type QScrollPrepareEvent_ITF interface {
	core.QEvent_ITF
	QScrollPrepareEvent_PTR() *QScrollPrepareEvent
}

func PointerFromQScrollPrepareEvent(ptr QScrollPrepareEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QScrollPrepareEvent_PTR().Pointer()
	}
	return nil
}

func NewQScrollPrepareEventFromPointer(ptr unsafe.Pointer) *QScrollPrepareEvent {
	var n = new(QScrollPrepareEvent)
	n.SetPointer(ptr)
	return n
}

func newQScrollPrepareEventFromPointer(ptr unsafe.Pointer) *QScrollPrepareEvent {
	var n = NewQScrollPrepareEventFromPointer(ptr)
	return n
}

func (ptr *QScrollPrepareEvent) QScrollPrepareEvent_PTR() *QScrollPrepareEvent {
	return ptr
}

func NewQScrollPrepareEvent(startPos core.QPointF_ITF) *QScrollPrepareEvent {
	defer qt.Recovering("QScrollPrepareEvent::QScrollPrepareEvent")

	return newQScrollPrepareEventFromPointer(C.QScrollPrepareEvent_NewQScrollPrepareEvent(core.PointerFromQPointF(startPos)))
}

func (ptr *QScrollPrepareEvent) SetContentPos(pos core.QPointF_ITF) {
	defer qt.Recovering("QScrollPrepareEvent::setContentPos")

	if ptr.Pointer() != nil {
		C.QScrollPrepareEvent_SetContentPos(ptr.Pointer(), core.PointerFromQPointF(pos))
	}
}

func (ptr *QScrollPrepareEvent) SetContentPosRange(rect core.QRectF_ITF) {
	defer qt.Recovering("QScrollPrepareEvent::setContentPosRange")

	if ptr.Pointer() != nil {
		C.QScrollPrepareEvent_SetContentPosRange(ptr.Pointer(), core.PointerFromQRectF(rect))
	}
}

func (ptr *QScrollPrepareEvent) SetViewportSize(size core.QSizeF_ITF) {
	defer qt.Recovering("QScrollPrepareEvent::setViewportSize")

	if ptr.Pointer() != nil {
		C.QScrollPrepareEvent_SetViewportSize(ptr.Pointer(), core.PointerFromQSizeF(size))
	}
}

func (ptr *QScrollPrepareEvent) DestroyQScrollPrepareEvent() {
	defer qt.Recovering("QScrollPrepareEvent::~QScrollPrepareEvent")

	if ptr.Pointer() != nil {
		C.QScrollPrepareEvent_DestroyQScrollPrepareEvent(ptr.Pointer())
	}
}

type QSessionManager struct {
	core.QObject
}

type QSessionManager_ITF interface {
	core.QObject_ITF
	QSessionManager_PTR() *QSessionManager
}

func PointerFromQSessionManager(ptr QSessionManager_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSessionManager_PTR().Pointer()
	}
	return nil
}

func NewQSessionManagerFromPointer(ptr unsafe.Pointer) *QSessionManager {
	var n = new(QSessionManager)
	n.SetPointer(ptr)
	return n
}

func newQSessionManagerFromPointer(ptr unsafe.Pointer) *QSessionManager {
	var n = NewQSessionManagerFromPointer(ptr)
	for len(n.ObjectName()) < len("QSessionManager_") {
		n.SetObjectName("QSessionManager_" + qt.Identifier())
	}
	return n
}

func (ptr *QSessionManager) QSessionManager_PTR() *QSessionManager {
	return ptr
}

//QSessionManager::RestartHint
type QSessionManager__RestartHint int64

const (
	QSessionManager__RestartIfRunning   = QSessionManager__RestartHint(0)
	QSessionManager__RestartAnyway      = QSessionManager__RestartHint(1)
	QSessionManager__RestartImmediately = QSessionManager__RestartHint(2)
	QSessionManager__RestartNever       = QSessionManager__RestartHint(3)
)

func (ptr *QSessionManager) RestartHint() QSessionManager__RestartHint {
	defer qt.Recovering("QSessionManager::restartHint")

	if ptr.Pointer() != nil {
		return QSessionManager__RestartHint(C.QSessionManager_RestartHint(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSessionManager) SessionKey() string {
	defer qt.Recovering("QSessionManager::sessionKey")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSessionManager_SessionKey(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSessionManager) AllowsErrorInteraction() bool {
	defer qt.Recovering("QSessionManager::allowsErrorInteraction")

	if ptr.Pointer() != nil {
		return C.QSessionManager_AllowsErrorInteraction(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSessionManager) AllowsInteraction() bool {
	defer qt.Recovering("QSessionManager::allowsInteraction")

	if ptr.Pointer() != nil {
		return C.QSessionManager_AllowsInteraction(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSessionManager) Cancel() {
	defer qt.Recovering("QSessionManager::cancel")

	if ptr.Pointer() != nil {
		C.QSessionManager_Cancel(ptr.Pointer())
	}
}

func (ptr *QSessionManager) DiscardCommand() []string {
	defer qt.Recovering("QSessionManager::discardCommand")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QSessionManager_DiscardCommand(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QSessionManager) IsPhase2() bool {
	defer qt.Recovering("QSessionManager::isPhase2")

	if ptr.Pointer() != nil {
		return C.QSessionManager_IsPhase2(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSessionManager) Release() {
	defer qt.Recovering("QSessionManager::release")

	if ptr.Pointer() != nil {
		C.QSessionManager_Release(ptr.Pointer())
	}
}

func (ptr *QSessionManager) RequestPhase2() {
	defer qt.Recovering("QSessionManager::requestPhase2")

	if ptr.Pointer() != nil {
		C.QSessionManager_RequestPhase2(ptr.Pointer())
	}
}

func (ptr *QSessionManager) RestartCommand() []string {
	defer qt.Recovering("QSessionManager::restartCommand")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QSessionManager_RestartCommand(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QSessionManager) SessionId() string {
	defer qt.Recovering("QSessionManager::sessionId")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSessionManager_SessionId(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSessionManager) SetDiscardCommand(command []string) {
	defer qt.Recovering("QSessionManager::setDiscardCommand")

	if ptr.Pointer() != nil {
		C.QSessionManager_SetDiscardCommand(ptr.Pointer(), C.CString(strings.Join(command, "|")))
	}
}

func (ptr *QSessionManager) SetManagerProperty2(name string, value string) {
	defer qt.Recovering("QSessionManager::setManagerProperty")

	if ptr.Pointer() != nil {
		C.QSessionManager_SetManagerProperty2(ptr.Pointer(), C.CString(name), C.CString(value))
	}
}

func (ptr *QSessionManager) SetManagerProperty(name string, value []string) {
	defer qt.Recovering("QSessionManager::setManagerProperty")

	if ptr.Pointer() != nil {
		C.QSessionManager_SetManagerProperty(ptr.Pointer(), C.CString(name), C.CString(strings.Join(value, "|")))
	}
}

func (ptr *QSessionManager) SetRestartCommand(command []string) {
	defer qt.Recovering("QSessionManager::setRestartCommand")

	if ptr.Pointer() != nil {
		C.QSessionManager_SetRestartCommand(ptr.Pointer(), C.CString(strings.Join(command, "|")))
	}
}

func (ptr *QSessionManager) SetRestartHint(hint QSessionManager__RestartHint) {
	defer qt.Recovering("QSessionManager::setRestartHint")

	if ptr.Pointer() != nil {
		C.QSessionManager_SetRestartHint(ptr.Pointer(), C.int(hint))
	}
}

func (ptr *QSessionManager) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QSessionManager::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSessionManager) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSessionManager::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSessionManagerTimerEvent
func callbackQSessionManagerTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSessionManager::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQSessionManagerFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSessionManager) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QSessionManager::timerEvent")

	if ptr.Pointer() != nil {
		C.QSessionManager_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QSessionManager) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QSessionManager::timerEvent")

	if ptr.Pointer() != nil {
		C.QSessionManager_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QSessionManager) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QSessionManager::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSessionManager) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSessionManager::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSessionManagerChildEvent
func callbackQSessionManagerChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSessionManager::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQSessionManagerFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QSessionManager) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QSessionManager::childEvent")

	if ptr.Pointer() != nil {
		C.QSessionManager_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QSessionManager) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QSessionManager::childEvent")

	if ptr.Pointer() != nil {
		C.QSessionManager_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QSessionManager) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QSessionManager::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSessionManager) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSessionManager::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSessionManagerCustomEvent
func callbackQSessionManagerCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSessionManager::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQSessionManagerFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QSessionManager) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QSessionManager::customEvent")

	if ptr.Pointer() != nil {
		C.QSessionManager_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QSessionManager) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QSessionManager::customEvent")

	if ptr.Pointer() != nil {
		C.QSessionManager_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QShortcutEvent struct {
	core.QEvent
}

type QShortcutEvent_ITF interface {
	core.QEvent_ITF
	QShortcutEvent_PTR() *QShortcutEvent
}

func PointerFromQShortcutEvent(ptr QShortcutEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QShortcutEvent_PTR().Pointer()
	}
	return nil
}

func NewQShortcutEventFromPointer(ptr unsafe.Pointer) *QShortcutEvent {
	var n = new(QShortcutEvent)
	n.SetPointer(ptr)
	return n
}

func newQShortcutEventFromPointer(ptr unsafe.Pointer) *QShortcutEvent {
	var n = NewQShortcutEventFromPointer(ptr)
	return n
}

func (ptr *QShortcutEvent) QShortcutEvent_PTR() *QShortcutEvent {
	return ptr
}

func NewQShortcutEvent(key QKeySequence_ITF, id int, ambiguous bool) *QShortcutEvent {
	defer qt.Recovering("QShortcutEvent::QShortcutEvent")

	return newQShortcutEventFromPointer(C.QShortcutEvent_NewQShortcutEvent(PointerFromQKeySequence(key), C.int(id), C.int(qt.GoBoolToInt(ambiguous))))
}

func (ptr *QShortcutEvent) IsAmbiguous() bool {
	defer qt.Recovering("QShortcutEvent::isAmbiguous")

	if ptr.Pointer() != nil {
		return C.QShortcutEvent_IsAmbiguous(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QShortcutEvent) ShortcutId() int {
	defer qt.Recovering("QShortcutEvent::shortcutId")

	if ptr.Pointer() != nil {
		return int(C.QShortcutEvent_ShortcutId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QShortcutEvent) DestroyQShortcutEvent() {
	defer qt.Recovering("QShortcutEvent::~QShortcutEvent")

	if ptr.Pointer() != nil {
		C.QShortcutEvent_DestroyQShortcutEvent(ptr.Pointer())
	}
}

type QShowEvent struct {
	core.QEvent
}

type QShowEvent_ITF interface {
	core.QEvent_ITF
	QShowEvent_PTR() *QShowEvent
}

func PointerFromQShowEvent(ptr QShowEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QShowEvent_PTR().Pointer()
	}
	return nil
}

func NewQShowEventFromPointer(ptr unsafe.Pointer) *QShowEvent {
	var n = new(QShowEvent)
	n.SetPointer(ptr)
	return n
}

func newQShowEventFromPointer(ptr unsafe.Pointer) *QShowEvent {
	var n = NewQShowEventFromPointer(ptr)
	return n
}

func (ptr *QShowEvent) QShowEvent_PTR() *QShowEvent {
	return ptr
}

func NewQShowEvent() *QShowEvent {
	defer qt.Recovering("QShowEvent::QShowEvent")

	return newQShowEventFromPointer(C.QShowEvent_NewQShowEvent())
}

type QStandardItem struct {
	ptr unsafe.Pointer
}

type QStandardItem_ITF interface {
	QStandardItem_PTR() *QStandardItem
}

func (p *QStandardItem) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QStandardItem) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQStandardItem(ptr QStandardItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStandardItem_PTR().Pointer()
	}
	return nil
}

func NewQStandardItemFromPointer(ptr unsafe.Pointer) *QStandardItem {
	var n = new(QStandardItem)
	n.SetPointer(ptr)
	return n
}

func newQStandardItemFromPointer(ptr unsafe.Pointer) *QStandardItem {
	var n = NewQStandardItemFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QStandardItem_") {
		n.SetObjectNameAbs("QStandardItem_" + qt.Identifier())
	}
	return n
}

func (ptr *QStandardItem) QStandardItem_PTR() *QStandardItem {
	return ptr
}

//QStandardItem::ItemType
type QStandardItem__ItemType int64

const (
	QStandardItem__Type     = QStandardItem__ItemType(0)
	QStandardItem__UserType = QStandardItem__ItemType(1000)
)

func NewQStandardItem() *QStandardItem {
	defer qt.Recovering("QStandardItem::QStandardItem")

	return newQStandardItemFromPointer(C.QStandardItem_NewQStandardItem())
}

func NewQStandardItem3(icon QIcon_ITF, text string) *QStandardItem {
	defer qt.Recovering("QStandardItem::QStandardItem")

	return newQStandardItemFromPointer(C.QStandardItem_NewQStandardItem3(PointerFromQIcon(icon), C.CString(text)))
}

func NewQStandardItem2(text string) *QStandardItem {
	defer qt.Recovering("QStandardItem::QStandardItem")

	return newQStandardItemFromPointer(C.QStandardItem_NewQStandardItem2(C.CString(text)))
}

func NewQStandardItem4(rows int, columns int) *QStandardItem {
	defer qt.Recovering("QStandardItem::QStandardItem")

	return newQStandardItemFromPointer(C.QStandardItem_NewQStandardItem4(C.int(rows), C.int(columns)))
}

func (ptr *QStandardItem) AccessibleDescription() string {
	defer qt.Recovering("QStandardItem::accessibleDescription")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStandardItem_AccessibleDescription(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStandardItem) AccessibleText() string {
	defer qt.Recovering("QStandardItem::accessibleText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStandardItem_AccessibleText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStandardItem) AppendRow2(item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItem::appendRow")

	if ptr.Pointer() != nil {
		C.QStandardItem_AppendRow2(ptr.Pointer(), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItem) Background() *QBrush {
	defer qt.Recovering("QStandardItem::background")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QStandardItem_Background(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItem) CheckState() core.Qt__CheckState {
	defer qt.Recovering("QStandardItem::checkState")

	if ptr.Pointer() != nil {
		return core.Qt__CheckState(C.QStandardItem_CheckState(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStandardItem) Child(row int, column int) *QStandardItem {
	defer qt.Recovering("QStandardItem::child")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItem_Child(ptr.Pointer(), C.int(row), C.int(column)))
	}
	return nil
}

func (ptr *QStandardItem) Clone() *QStandardItem {
	defer qt.Recovering("QStandardItem::clone")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItem_Clone(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItem) Column() int {
	defer qt.Recovering("QStandardItem::column")

	if ptr.Pointer() != nil {
		return int(C.QStandardItem_Column(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStandardItem) ColumnCount() int {
	defer qt.Recovering("QStandardItem::columnCount")

	if ptr.Pointer() != nil {
		return int(C.QStandardItem_ColumnCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStandardItem) Data(role int) *core.QVariant {
	defer qt.Recovering("QStandardItem::data")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QStandardItem_Data(ptr.Pointer(), C.int(role)))
	}
	return nil
}

func (ptr *QStandardItem) Flags() core.Qt__ItemFlag {
	defer qt.Recovering("QStandardItem::flags")

	if ptr.Pointer() != nil {
		return core.Qt__ItemFlag(C.QStandardItem_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStandardItem) Foreground() *QBrush {
	defer qt.Recovering("QStandardItem::foreground")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QStandardItem_Foreground(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItem) HasChildren() bool {
	defer qt.Recovering("QStandardItem::hasChildren")

	if ptr.Pointer() != nil {
		return C.QStandardItem_HasChildren(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStandardItem) Icon() *QIcon {
	defer qt.Recovering("QStandardItem::icon")

	if ptr.Pointer() != nil {
		return NewQIconFromPointer(C.QStandardItem_Icon(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItem) Index() *core.QModelIndex {
	defer qt.Recovering("QStandardItem::index")

	if ptr.Pointer() != nil {
		return core.NewQModelIndexFromPointer(C.QStandardItem_Index(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItem) InsertColumns(column int, count int) {
	defer qt.Recovering("QStandardItem::insertColumns")

	if ptr.Pointer() != nil {
		C.QStandardItem_InsertColumns(ptr.Pointer(), C.int(column), C.int(count))
	}
}

func (ptr *QStandardItem) InsertRow2(row int, item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItem::insertRow")

	if ptr.Pointer() != nil {
		C.QStandardItem_InsertRow2(ptr.Pointer(), C.int(row), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItem) InsertRows2(row int, count int) {
	defer qt.Recovering("QStandardItem::insertRows")

	if ptr.Pointer() != nil {
		C.QStandardItem_InsertRows2(ptr.Pointer(), C.int(row), C.int(count))
	}
}

func (ptr *QStandardItem) IsCheckable() bool {
	defer qt.Recovering("QStandardItem::isCheckable")

	if ptr.Pointer() != nil {
		return C.QStandardItem_IsCheckable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStandardItem) IsDragEnabled() bool {
	defer qt.Recovering("QStandardItem::isDragEnabled")

	if ptr.Pointer() != nil {
		return C.QStandardItem_IsDragEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStandardItem) IsDropEnabled() bool {
	defer qt.Recovering("QStandardItem::isDropEnabled")

	if ptr.Pointer() != nil {
		return C.QStandardItem_IsDropEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStandardItem) IsEditable() bool {
	defer qt.Recovering("QStandardItem::isEditable")

	if ptr.Pointer() != nil {
		return C.QStandardItem_IsEditable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStandardItem) IsEnabled() bool {
	defer qt.Recovering("QStandardItem::isEnabled")

	if ptr.Pointer() != nil {
		return C.QStandardItem_IsEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStandardItem) IsSelectable() bool {
	defer qt.Recovering("QStandardItem::isSelectable")

	if ptr.Pointer() != nil {
		return C.QStandardItem_IsSelectable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStandardItem) IsTristate() bool {
	defer qt.Recovering("QStandardItem::isTristate")

	if ptr.Pointer() != nil {
		return C.QStandardItem_IsTristate(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStandardItem) Model() *QStandardItemModel {
	defer qt.Recovering("QStandardItem::model")

	if ptr.Pointer() != nil {
		return NewQStandardItemModelFromPointer(C.QStandardItem_Model(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItem) Parent() *QStandardItem {
	defer qt.Recovering("QStandardItem::parent")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItem_Parent(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItem) RemoveColumn(column int) {
	defer qt.Recovering("QStandardItem::removeColumn")

	if ptr.Pointer() != nil {
		C.QStandardItem_RemoveColumn(ptr.Pointer(), C.int(column))
	}
}

func (ptr *QStandardItem) RemoveColumns(column int, count int) {
	defer qt.Recovering("QStandardItem::removeColumns")

	if ptr.Pointer() != nil {
		C.QStandardItem_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count))
	}
}

func (ptr *QStandardItem) RemoveRow(row int) {
	defer qt.Recovering("QStandardItem::removeRow")

	if ptr.Pointer() != nil {
		C.QStandardItem_RemoveRow(ptr.Pointer(), C.int(row))
	}
}

func (ptr *QStandardItem) RemoveRows(row int, count int) {
	defer qt.Recovering("QStandardItem::removeRows")

	if ptr.Pointer() != nil {
		C.QStandardItem_RemoveRows(ptr.Pointer(), C.int(row), C.int(count))
	}
}

func (ptr *QStandardItem) Row() int {
	defer qt.Recovering("QStandardItem::row")

	if ptr.Pointer() != nil {
		return int(C.QStandardItem_Row(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStandardItem) RowCount() int {
	defer qt.Recovering("QStandardItem::rowCount")

	if ptr.Pointer() != nil {
		return int(C.QStandardItem_RowCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStandardItem) SetAccessibleDescription(accessibleDescription string) {
	defer qt.Recovering("QStandardItem::setAccessibleDescription")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetAccessibleDescription(ptr.Pointer(), C.CString(accessibleDescription))
	}
}

func (ptr *QStandardItem) SetAccessibleText(accessibleText string) {
	defer qt.Recovering("QStandardItem::setAccessibleText")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetAccessibleText(ptr.Pointer(), C.CString(accessibleText))
	}
}

func (ptr *QStandardItem) SetBackground(brush QBrush_ITF) {
	defer qt.Recovering("QStandardItem::setBackground")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetBackground(ptr.Pointer(), PointerFromQBrush(brush))
	}
}

func (ptr *QStandardItem) SetCheckState(state core.Qt__CheckState) {
	defer qt.Recovering("QStandardItem::setCheckState")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetCheckState(ptr.Pointer(), C.int(state))
	}
}

func (ptr *QStandardItem) SetCheckable(checkable bool) {
	defer qt.Recovering("QStandardItem::setCheckable")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetCheckable(ptr.Pointer(), C.int(qt.GoBoolToInt(checkable)))
	}
}

func (ptr *QStandardItem) SetChild2(row int, item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItem::setChild")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetChild2(ptr.Pointer(), C.int(row), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItem) SetChild(row int, column int, item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItem::setChild")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetChild(ptr.Pointer(), C.int(row), C.int(column), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItem) SetColumnCount(columns int) {
	defer qt.Recovering("QStandardItem::setColumnCount")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetColumnCount(ptr.Pointer(), C.int(columns))
	}
}

func (ptr *QStandardItem) ConnectSetData(f func(value *core.QVariant, role int)) {
	defer qt.Recovering("connect QStandardItem::setData")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectNameAbs(), "setData", f)
	}
}

func (ptr *QStandardItem) DisconnectSetData() {
	defer qt.Recovering("disconnect QStandardItem::setData")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectNameAbs(), "setData")
	}
}

//export callbackQStandardItemSetData
func callbackQStandardItemSetData(ptr unsafe.Pointer, ptrName *C.char, value unsafe.Pointer, role C.int) {
	defer qt.Recovering("callback QStandardItem::setData")

	if signal := qt.GetSignal(C.GoString(ptrName), "setData"); signal != nil {
		signal.(func(*core.QVariant, int))(core.NewQVariantFromPointer(value), int(role))
	} else {
		NewQStandardItemFromPointer(ptr).SetDataDefault(core.NewQVariantFromPointer(value), int(role))
	}
}

func (ptr *QStandardItem) SetData(value core.QVariant_ITF, role int) {
	defer qt.Recovering("QStandardItem::setData")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetData(ptr.Pointer(), core.PointerFromQVariant(value), C.int(role))
	}
}

func (ptr *QStandardItem) SetDataDefault(value core.QVariant_ITF, role int) {
	defer qt.Recovering("QStandardItem::setData")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetDataDefault(ptr.Pointer(), core.PointerFromQVariant(value), C.int(role))
	}
}

func (ptr *QStandardItem) SetDragEnabled(dragEnabled bool) {
	defer qt.Recovering("QStandardItem::setDragEnabled")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetDragEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(dragEnabled)))
	}
}

func (ptr *QStandardItem) SetDropEnabled(dropEnabled bool) {
	defer qt.Recovering("QStandardItem::setDropEnabled")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetDropEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(dropEnabled)))
	}
}

func (ptr *QStandardItem) SetEditable(editable bool) {
	defer qt.Recovering("QStandardItem::setEditable")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetEditable(ptr.Pointer(), C.int(qt.GoBoolToInt(editable)))
	}
}

func (ptr *QStandardItem) SetEnabled(enabled bool) {
	defer qt.Recovering("QStandardItem::setEnabled")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(enabled)))
	}
}

func (ptr *QStandardItem) SetFlags(flags core.Qt__ItemFlag) {
	defer qt.Recovering("QStandardItem::setFlags")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetFlags(ptr.Pointer(), C.int(flags))
	}
}

func (ptr *QStandardItem) SetFont(font QFont_ITF) {
	defer qt.Recovering("QStandardItem::setFont")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetFont(ptr.Pointer(), PointerFromQFont(font))
	}
}

func (ptr *QStandardItem) SetForeground(brush QBrush_ITF) {
	defer qt.Recovering("QStandardItem::setForeground")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetForeground(ptr.Pointer(), PointerFromQBrush(brush))
	}
}

func (ptr *QStandardItem) SetIcon(icon QIcon_ITF) {
	defer qt.Recovering("QStandardItem::setIcon")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetIcon(ptr.Pointer(), PointerFromQIcon(icon))
	}
}

func (ptr *QStandardItem) SetRowCount(rows int) {
	defer qt.Recovering("QStandardItem::setRowCount")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetRowCount(ptr.Pointer(), C.int(rows))
	}
}

func (ptr *QStandardItem) SetSelectable(selectable bool) {
	defer qt.Recovering("QStandardItem::setSelectable")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetSelectable(ptr.Pointer(), C.int(qt.GoBoolToInt(selectable)))
	}
}

func (ptr *QStandardItem) SetSizeHint(size core.QSize_ITF) {
	defer qt.Recovering("QStandardItem::setSizeHint")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetSizeHint(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QStandardItem) SetStatusTip(statusTip string) {
	defer qt.Recovering("QStandardItem::setStatusTip")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetStatusTip(ptr.Pointer(), C.CString(statusTip))
	}
}

func (ptr *QStandardItem) SetText(text string) {
	defer qt.Recovering("QStandardItem::setText")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetText(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QStandardItem) SetTextAlignment(alignment core.Qt__AlignmentFlag) {
	defer qt.Recovering("QStandardItem::setTextAlignment")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetTextAlignment(ptr.Pointer(), C.int(alignment))
	}
}

func (ptr *QStandardItem) SetToolTip(toolTip string) {
	defer qt.Recovering("QStandardItem::setToolTip")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetToolTip(ptr.Pointer(), C.CString(toolTip))
	}
}

func (ptr *QStandardItem) SetTristate(tristate bool) {
	defer qt.Recovering("QStandardItem::setTristate")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetTristate(ptr.Pointer(), C.int(qt.GoBoolToInt(tristate)))
	}
}

func (ptr *QStandardItem) SetWhatsThis(whatsThis string) {
	defer qt.Recovering("QStandardItem::setWhatsThis")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetWhatsThis(ptr.Pointer(), C.CString(whatsThis))
	}
}

func (ptr *QStandardItem) SizeHint() *core.QSize {
	defer qt.Recovering("QStandardItem::sizeHint")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QStandardItem_SizeHint(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItem) SortChildren(column int, order core.Qt__SortOrder) {
	defer qt.Recovering("QStandardItem::sortChildren")

	if ptr.Pointer() != nil {
		C.QStandardItem_SortChildren(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QStandardItem) StatusTip() string {
	defer qt.Recovering("QStandardItem::statusTip")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStandardItem_StatusTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStandardItem) TakeChild(row int, column int) *QStandardItem {
	defer qt.Recovering("QStandardItem::takeChild")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItem_TakeChild(ptr.Pointer(), C.int(row), C.int(column)))
	}
	return nil
}

func (ptr *QStandardItem) Text() string {
	defer qt.Recovering("QStandardItem::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStandardItem_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStandardItem) TextAlignment() core.Qt__AlignmentFlag {
	defer qt.Recovering("QStandardItem::textAlignment")

	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QStandardItem_TextAlignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStandardItem) ToolTip() string {
	defer qt.Recovering("QStandardItem::toolTip")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStandardItem_ToolTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStandardItem) Type() int {
	defer qt.Recovering("QStandardItem::type")

	if ptr.Pointer() != nil {
		return int(C.QStandardItem_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStandardItem) WhatsThis() string {
	defer qt.Recovering("QStandardItem::whatsThis")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStandardItem_WhatsThis(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStandardItem) DestroyQStandardItem() {
	defer qt.Recovering("QStandardItem::~QStandardItem")

	if ptr.Pointer() != nil {
		C.QStandardItem_DestroyQStandardItem(ptr.Pointer())
	}
}

func (ptr *QStandardItem) ObjectNameAbs() string {
	defer qt.Recovering("QStandardItem::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStandardItem_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStandardItem) SetObjectNameAbs(name string) {
	defer qt.Recovering("QStandardItem::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QStandardItem_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QStandardItemModel struct {
	core.QAbstractItemModel
}

type QStandardItemModel_ITF interface {
	core.QAbstractItemModel_ITF
	QStandardItemModel_PTR() *QStandardItemModel
}

func PointerFromQStandardItemModel(ptr QStandardItemModel_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStandardItemModel_PTR().Pointer()
	}
	return nil
}

func NewQStandardItemModelFromPointer(ptr unsafe.Pointer) *QStandardItemModel {
	var n = new(QStandardItemModel)
	n.SetPointer(ptr)
	return n
}

func newQStandardItemModelFromPointer(ptr unsafe.Pointer) *QStandardItemModel {
	var n = NewQStandardItemModelFromPointer(ptr)
	for len(n.ObjectName()) < len("QStandardItemModel_") {
		n.SetObjectName("QStandardItemModel_" + qt.Identifier())
	}
	return n
}

func (ptr *QStandardItemModel) QStandardItemModel_PTR() *QStandardItemModel {
	return ptr
}

func (ptr *QStandardItemModel) SetSortRole(role int) {
	defer qt.Recovering("QStandardItemModel::setSortRole")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetSortRole(ptr.Pointer(), C.int(role))
	}
}

func (ptr *QStandardItemModel) SortRole() int {
	defer qt.Recovering("QStandardItemModel::sortRole")

	if ptr.Pointer() != nil {
		return int(C.QStandardItemModel_SortRole(ptr.Pointer()))
	}
	return 0
}

func NewQStandardItemModel(parent core.QObject_ITF) *QStandardItemModel {
	defer qt.Recovering("QStandardItemModel::QStandardItemModel")

	return newQStandardItemModelFromPointer(C.QStandardItemModel_NewQStandardItemModel(core.PointerFromQObject(parent)))
}

func NewQStandardItemModel2(rows int, columns int, parent core.QObject_ITF) *QStandardItemModel {
	defer qt.Recovering("QStandardItemModel::QStandardItemModel")

	return newQStandardItemModelFromPointer(C.QStandardItemModel_NewQStandardItemModel2(C.int(rows), C.int(columns), core.PointerFromQObject(parent)))
}

func (ptr *QStandardItemModel) AppendRow2(item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItemModel::appendRow")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_AppendRow2(ptr.Pointer(), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItemModel) Clear() {
	defer qt.Recovering("QStandardItemModel::clear")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_Clear(ptr.Pointer())
	}
}

func (ptr *QStandardItemModel) ColumnCount(parent core.QModelIndex_ITF) int {
	defer qt.Recovering("QStandardItemModel::columnCount")

	if ptr.Pointer() != nil {
		return int(C.QStandardItemModel_ColumnCount(ptr.Pointer(), core.PointerFromQModelIndex(parent)))
	}
	return 0
}

func (ptr *QStandardItemModel) Data(index core.QModelIndex_ITF, role int) *core.QVariant {
	defer qt.Recovering("QStandardItemModel::data")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QStandardItemModel_Data(ptr.Pointer(), core.PointerFromQModelIndex(index), C.int(role)))
	}
	return nil
}

func (ptr *QStandardItemModel) DropMimeData(data core.QMimeData_ITF, action core.Qt__DropAction, row int, column int, parent core.QModelIndex_ITF) bool {
	defer qt.Recovering("QStandardItemModel::dropMimeData")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_DropMimeData(ptr.Pointer(), core.PointerFromQMimeData(data), C.int(action), C.int(row), C.int(column), core.PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) Flags(index core.QModelIndex_ITF) core.Qt__ItemFlag {
	defer qt.Recovering("QStandardItemModel::flags")

	if ptr.Pointer() != nil {
		return core.Qt__ItemFlag(C.QStandardItemModel_Flags(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return 0
}

func (ptr *QStandardItemModel) HasChildren(parent core.QModelIndex_ITF) bool {
	defer qt.Recovering("QStandardItemModel::hasChildren")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_HasChildren(ptr.Pointer(), core.PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) HeaderData(section int, orientation core.Qt__Orientation, role int) *core.QVariant {
	defer qt.Recovering("QStandardItemModel::headerData")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QStandardItemModel_HeaderData(ptr.Pointer(), C.int(section), C.int(orientation), C.int(role)))
	}
	return nil
}

func (ptr *QStandardItemModel) HorizontalHeaderItem(column int) *QStandardItem {
	defer qt.Recovering("QStandardItemModel::horizontalHeaderItem")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItemModel_HorizontalHeaderItem(ptr.Pointer(), C.int(column)))
	}
	return nil
}

func (ptr *QStandardItemModel) Index(row int, column int, parent core.QModelIndex_ITF) *core.QModelIndex {
	defer qt.Recovering("QStandardItemModel::index")

	if ptr.Pointer() != nil {
		return core.NewQModelIndexFromPointer(C.QStandardItemModel_Index(ptr.Pointer(), C.int(row), C.int(column), core.PointerFromQModelIndex(parent)))
	}
	return nil
}

func (ptr *QStandardItemModel) IndexFromItem(item QStandardItem_ITF) *core.QModelIndex {
	defer qt.Recovering("QStandardItemModel::indexFromItem")

	if ptr.Pointer() != nil {
		return core.NewQModelIndexFromPointer(C.QStandardItemModel_IndexFromItem(ptr.Pointer(), PointerFromQStandardItem(item)))
	}
	return nil
}

func (ptr *QStandardItemModel) InsertColumn2(column int, parent core.QModelIndex_ITF) bool {
	defer qt.Recovering("QStandardItemModel::insertColumn")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_InsertColumn2(ptr.Pointer(), C.int(column), core.PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) InsertColumns(column int, count int, parent core.QModelIndex_ITF) bool {
	defer qt.Recovering("QStandardItemModel::insertColumns")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_InsertColumns(ptr.Pointer(), C.int(column), C.int(count), core.PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) InsertRow2(row int, parent core.QModelIndex_ITF) bool {
	defer qt.Recovering("QStandardItemModel::insertRow")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_InsertRow2(ptr.Pointer(), C.int(row), core.PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) InsertRow3(row int, item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItemModel::insertRow")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_InsertRow3(ptr.Pointer(), C.int(row), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItemModel) InsertRows(row int, count int, parent core.QModelIndex_ITF) bool {
	defer qt.Recovering("QStandardItemModel::insertRows")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_InsertRows(ptr.Pointer(), C.int(row), C.int(count), core.PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) InvisibleRootItem() *QStandardItem {
	defer qt.Recovering("QStandardItemModel::invisibleRootItem")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItemModel_InvisibleRootItem(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItemModel) Item(row int, column int) *QStandardItem {
	defer qt.Recovering("QStandardItemModel::item")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItemModel_Item(ptr.Pointer(), C.int(row), C.int(column)))
	}
	return nil
}

func (ptr *QStandardItemModel) ConnectItemChanged(f func(item *QStandardItem)) {
	defer qt.Recovering("connect QStandardItemModel::itemChanged")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_ConnectItemChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "itemChanged", f)
	}
}

func (ptr *QStandardItemModel) DisconnectItemChanged() {
	defer qt.Recovering("disconnect QStandardItemModel::itemChanged")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_DisconnectItemChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "itemChanged")
	}
}

//export callbackQStandardItemModelItemChanged
func callbackQStandardItemModelItemChanged(ptr unsafe.Pointer, ptrName *C.char, item unsafe.Pointer) {
	defer qt.Recovering("callback QStandardItemModel::itemChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "itemChanged"); signal != nil {
		signal.(func(*QStandardItem))(NewQStandardItemFromPointer(item))
	}

}

func (ptr *QStandardItemModel) ItemChanged(item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItemModel::itemChanged")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_ItemChanged(ptr.Pointer(), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItemModel) ItemFromIndex(index core.QModelIndex_ITF) *QStandardItem {
	defer qt.Recovering("QStandardItemModel::itemFromIndex")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItemModel_ItemFromIndex(ptr.Pointer(), core.PointerFromQModelIndex(index)))
	}
	return nil
}

func (ptr *QStandardItemModel) ItemPrototype() *QStandardItem {
	defer qt.Recovering("QStandardItemModel::itemPrototype")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItemModel_ItemPrototype(ptr.Pointer()))
	}
	return nil
}

func (ptr *QStandardItemModel) MimeTypes() []string {
	defer qt.Recovering("QStandardItemModel::mimeTypes")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QStandardItemModel_MimeTypes(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QStandardItemModel) Parent(child core.QModelIndex_ITF) *core.QModelIndex {
	defer qt.Recovering("QStandardItemModel::parent")

	if ptr.Pointer() != nil {
		return core.NewQModelIndexFromPointer(C.QStandardItemModel_Parent(ptr.Pointer(), core.PointerFromQModelIndex(child)))
	}
	return nil
}

func (ptr *QStandardItemModel) RemoveColumns(column int, count int, parent core.QModelIndex_ITF) bool {
	defer qt.Recovering("QStandardItemModel::removeColumns")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_RemoveColumns(ptr.Pointer(), C.int(column), C.int(count), core.PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) RemoveRows(row int, count int, parent core.QModelIndex_ITF) bool {
	defer qt.Recovering("QStandardItemModel::removeRows")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_RemoveRows(ptr.Pointer(), C.int(row), C.int(count), core.PointerFromQModelIndex(parent)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) RowCount(parent core.QModelIndex_ITF) int {
	defer qt.Recovering("QStandardItemModel::rowCount")

	if ptr.Pointer() != nil {
		return int(C.QStandardItemModel_RowCount(ptr.Pointer(), core.PointerFromQModelIndex(parent)))
	}
	return 0
}

func (ptr *QStandardItemModel) SetColumnCount(columns int) {
	defer qt.Recovering("QStandardItemModel::setColumnCount")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetColumnCount(ptr.Pointer(), C.int(columns))
	}
}

func (ptr *QStandardItemModel) SetData(index core.QModelIndex_ITF, value core.QVariant_ITF, role int) bool {
	defer qt.Recovering("QStandardItemModel::setData")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_SetData(ptr.Pointer(), core.PointerFromQModelIndex(index), core.PointerFromQVariant(value), C.int(role)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) SetHeaderData(section int, orientation core.Qt__Orientation, value core.QVariant_ITF, role int) bool {
	defer qt.Recovering("QStandardItemModel::setHeaderData")

	if ptr.Pointer() != nil {
		return C.QStandardItemModel_SetHeaderData(ptr.Pointer(), C.int(section), C.int(orientation), core.PointerFromQVariant(value), C.int(role)) != 0
	}
	return false
}

func (ptr *QStandardItemModel) SetHorizontalHeaderItem(column int, item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItemModel::setHorizontalHeaderItem")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetHorizontalHeaderItem(ptr.Pointer(), C.int(column), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItemModel) SetHorizontalHeaderLabels(labels []string) {
	defer qt.Recovering("QStandardItemModel::setHorizontalHeaderLabels")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetHorizontalHeaderLabels(ptr.Pointer(), C.CString(strings.Join(labels, "|")))
	}
}

func (ptr *QStandardItemModel) SetItem2(row int, item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItemModel::setItem")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetItem2(ptr.Pointer(), C.int(row), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItemModel) SetItem(row int, column int, item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItemModel::setItem")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetItem(ptr.Pointer(), C.int(row), C.int(column), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItemModel) SetItemPrototype(item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItemModel::setItemPrototype")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetItemPrototype(ptr.Pointer(), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItemModel) SetRowCount(rows int) {
	defer qt.Recovering("QStandardItemModel::setRowCount")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetRowCount(ptr.Pointer(), C.int(rows))
	}
}

func (ptr *QStandardItemModel) SetVerticalHeaderItem(row int, item QStandardItem_ITF) {
	defer qt.Recovering("QStandardItemModel::setVerticalHeaderItem")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetVerticalHeaderItem(ptr.Pointer(), C.int(row), PointerFromQStandardItem(item))
	}
}

func (ptr *QStandardItemModel) SetVerticalHeaderLabels(labels []string) {
	defer qt.Recovering("QStandardItemModel::setVerticalHeaderLabels")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SetVerticalHeaderLabels(ptr.Pointer(), C.CString(strings.Join(labels, "|")))
	}
}

func (ptr *QStandardItemModel) Sibling(row int, column int, idx core.QModelIndex_ITF) *core.QModelIndex {
	defer qt.Recovering("QStandardItemModel::sibling")

	if ptr.Pointer() != nil {
		return core.NewQModelIndexFromPointer(C.QStandardItemModel_Sibling(ptr.Pointer(), C.int(row), C.int(column), core.PointerFromQModelIndex(idx)))
	}
	return nil
}

func (ptr *QStandardItemModel) ConnectSort(f func(column int, order core.Qt__SortOrder)) {
	defer qt.Recovering("connect QStandardItemModel::sort")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
	}
}

func (ptr *QStandardItemModel) DisconnectSort() {
	defer qt.Recovering("disconnect QStandardItemModel::sort")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "sort")
	}
}

//export callbackQStandardItemModelSort
func callbackQStandardItemModelSort(ptr unsafe.Pointer, ptrName *C.char, column C.int, order C.int) {
	defer qt.Recovering("callback QStandardItemModel::sort")

	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
		signal.(func(int, core.Qt__SortOrder))(int(column), core.Qt__SortOrder(order))
	} else {
		NewQStandardItemModelFromPointer(ptr).SortDefault(int(column), core.Qt__SortOrder(order))
	}
}

func (ptr *QStandardItemModel) Sort(column int, order core.Qt__SortOrder) {
	defer qt.Recovering("QStandardItemModel::sort")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_Sort(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QStandardItemModel) SortDefault(column int, order core.Qt__SortOrder) {
	defer qt.Recovering("QStandardItemModel::sort")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_SortDefault(ptr.Pointer(), C.int(column), C.int(order))
	}
}

func (ptr *QStandardItemModel) SupportedDropActions() core.Qt__DropAction {
	defer qt.Recovering("QStandardItemModel::supportedDropActions")

	if ptr.Pointer() != nil {
		return core.Qt__DropAction(C.QStandardItemModel_SupportedDropActions(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStandardItemModel) TakeHorizontalHeaderItem(column int) *QStandardItem {
	defer qt.Recovering("QStandardItemModel::takeHorizontalHeaderItem")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItemModel_TakeHorizontalHeaderItem(ptr.Pointer(), C.int(column)))
	}
	return nil
}

func (ptr *QStandardItemModel) TakeItem(row int, column int) *QStandardItem {
	defer qt.Recovering("QStandardItemModel::takeItem")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItemModel_TakeItem(ptr.Pointer(), C.int(row), C.int(column)))
	}
	return nil
}

func (ptr *QStandardItemModel) TakeVerticalHeaderItem(row int) *QStandardItem {
	defer qt.Recovering("QStandardItemModel::takeVerticalHeaderItem")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItemModel_TakeVerticalHeaderItem(ptr.Pointer(), C.int(row)))
	}
	return nil
}

func (ptr *QStandardItemModel) VerticalHeaderItem(row int) *QStandardItem {
	defer qt.Recovering("QStandardItemModel::verticalHeaderItem")

	if ptr.Pointer() != nil {
		return NewQStandardItemFromPointer(C.QStandardItemModel_VerticalHeaderItem(ptr.Pointer(), C.int(row)))
	}
	return nil
}

func (ptr *QStandardItemModel) DestroyQStandardItemModel() {
	defer qt.Recovering("QStandardItemModel::~QStandardItemModel")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_DestroyQStandardItemModel(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QStandardItemModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
	defer qt.Recovering("connect QStandardItemModel::fetchMore")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
	}
}

func (ptr *QStandardItemModel) DisconnectFetchMore() {
	defer qt.Recovering("disconnect QStandardItemModel::fetchMore")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
	}
}

//export callbackQStandardItemModelFetchMore
func callbackQStandardItemModelFetchMore(ptr unsafe.Pointer, ptrName *C.char, parent unsafe.Pointer) {
	defer qt.Recovering("callback QStandardItemModel::fetchMore")

	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
	} else {
		NewQStandardItemModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
	}
}

func (ptr *QStandardItemModel) FetchMore(parent core.QModelIndex_ITF) {
	defer qt.Recovering("QStandardItemModel::fetchMore")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_FetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent))
	}
}

func (ptr *QStandardItemModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
	defer qt.Recovering("QStandardItemModel::fetchMore")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
	}
}

func (ptr *QStandardItemModel) ConnectRevert(f func()) {
	defer qt.Recovering("connect QStandardItemModel::revert")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
	}
}

func (ptr *QStandardItemModel) DisconnectRevert() {
	defer qt.Recovering("disconnect QStandardItemModel::revert")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "revert")
	}
}

//export callbackQStandardItemModelRevert
func callbackQStandardItemModelRevert(ptr unsafe.Pointer, ptrName *C.char) bool {
	defer qt.Recovering("callback QStandardItemModel::revert")

	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
		signal.(func())()
		return true
	}
	return false

}

func (ptr *QStandardItemModel) Revert() {
	defer qt.Recovering("QStandardItemModel::revert")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_Revert(ptr.Pointer())
	}
}

func (ptr *QStandardItemModel) RevertDefault() {
	defer qt.Recovering("QStandardItemModel::revert")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_RevertDefault(ptr.Pointer())
	}
}

func (ptr *QStandardItemModel) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QStandardItemModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QStandardItemModel) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QStandardItemModel::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQStandardItemModelTimerEvent
func callbackQStandardItemModelTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStandardItemModel::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQStandardItemModelFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QStandardItemModel) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QStandardItemModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QStandardItemModel) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QStandardItemModel::timerEvent")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QStandardItemModel) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QStandardItemModel::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QStandardItemModel) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QStandardItemModel::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQStandardItemModelChildEvent
func callbackQStandardItemModelChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStandardItemModel::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQStandardItemModelFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QStandardItemModel) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QStandardItemModel::childEvent")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QStandardItemModel) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QStandardItemModel::childEvent")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QStandardItemModel) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QStandardItemModel::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QStandardItemModel) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QStandardItemModel::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQStandardItemModelCustomEvent
func callbackQStandardItemModelCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStandardItemModel::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQStandardItemModelFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QStandardItemModel) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QStandardItemModel::customEvent")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QStandardItemModel) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QStandardItemModel::customEvent")

	if ptr.Pointer() != nil {
		C.QStandardItemModel_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QStaticText struct {
	ptr unsafe.Pointer
}

type QStaticText_ITF interface {
	QStaticText_PTR() *QStaticText
}

func (p *QStaticText) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QStaticText) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQStaticText(ptr QStaticText_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStaticText_PTR().Pointer()
	}
	return nil
}

func NewQStaticTextFromPointer(ptr unsafe.Pointer) *QStaticText {
	var n = new(QStaticText)
	n.SetPointer(ptr)
	return n
}

func newQStaticTextFromPointer(ptr unsafe.Pointer) *QStaticText {
	var n = NewQStaticTextFromPointer(ptr)
	return n
}

func (ptr *QStaticText) QStaticText_PTR() *QStaticText {
	return ptr
}

//QStaticText::PerformanceHint
type QStaticText__PerformanceHint int64

const (
	QStaticText__ModerateCaching   = QStaticText__PerformanceHint(0)
	QStaticText__AggressiveCaching = QStaticText__PerformanceHint(1)
)

func NewQStaticText() *QStaticText {
	defer qt.Recovering("QStaticText::QStaticText")

	return newQStaticTextFromPointer(C.QStaticText_NewQStaticText())
}

func NewQStaticText3(other QStaticText_ITF) *QStaticText {
	defer qt.Recovering("QStaticText::QStaticText")

	return newQStaticTextFromPointer(C.QStaticText_NewQStaticText3(PointerFromQStaticText(other)))
}

func NewQStaticText2(text string) *QStaticText {
	defer qt.Recovering("QStaticText::QStaticText")

	return newQStaticTextFromPointer(C.QStaticText_NewQStaticText2(C.CString(text)))
}

func (ptr *QStaticText) PerformanceHint() QStaticText__PerformanceHint {
	defer qt.Recovering("QStaticText::performanceHint")

	if ptr.Pointer() != nil {
		return QStaticText__PerformanceHint(C.QStaticText_PerformanceHint(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStaticText) Prepare(matrix QTransform_ITF, font QFont_ITF) {
	defer qt.Recovering("QStaticText::prepare")

	if ptr.Pointer() != nil {
		C.QStaticText_Prepare(ptr.Pointer(), PointerFromQTransform(matrix), PointerFromQFont(font))
	}
}

func (ptr *QStaticText) SetPerformanceHint(performanceHint QStaticText__PerformanceHint) {
	defer qt.Recovering("QStaticText::setPerformanceHint")

	if ptr.Pointer() != nil {
		C.QStaticText_SetPerformanceHint(ptr.Pointer(), C.int(performanceHint))
	}
}

func (ptr *QStaticText) SetText(text string) {
	defer qt.Recovering("QStaticText::setText")

	if ptr.Pointer() != nil {
		C.QStaticText_SetText(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QStaticText) SetTextFormat(textFormat core.Qt__TextFormat) {
	defer qt.Recovering("QStaticText::setTextFormat")

	if ptr.Pointer() != nil {
		C.QStaticText_SetTextFormat(ptr.Pointer(), C.int(textFormat))
	}
}

func (ptr *QStaticText) SetTextOption(textOption QTextOption_ITF) {
	defer qt.Recovering("QStaticText::setTextOption")

	if ptr.Pointer() != nil {
		C.QStaticText_SetTextOption(ptr.Pointer(), PointerFromQTextOption(textOption))
	}
}

func (ptr *QStaticText) SetTextWidth(textWidth float64) {
	defer qt.Recovering("QStaticText::setTextWidth")

	if ptr.Pointer() != nil {
		C.QStaticText_SetTextWidth(ptr.Pointer(), C.double(textWidth))
	}
}

func (ptr *QStaticText) Swap(other QStaticText_ITF) {
	defer qt.Recovering("QStaticText::swap")

	if ptr.Pointer() != nil {
		C.QStaticText_Swap(ptr.Pointer(), PointerFromQStaticText(other))
	}
}

func (ptr *QStaticText) Text() string {
	defer qt.Recovering("QStaticText::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStaticText_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QStaticText) TextFormat() core.Qt__TextFormat {
	defer qt.Recovering("QStaticText::textFormat")

	if ptr.Pointer() != nil {
		return core.Qt__TextFormat(C.QStaticText_TextFormat(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStaticText) TextWidth() float64 {
	defer qt.Recovering("QStaticText::textWidth")

	if ptr.Pointer() != nil {
		return float64(C.QStaticText_TextWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStaticText) DestroyQStaticText() {
	defer qt.Recovering("QStaticText::~QStaticText")

	if ptr.Pointer() != nil {
		C.QStaticText_DestroyQStaticText(ptr.Pointer())
	}
}

type QStatusTipEvent struct {
	core.QEvent
}

type QStatusTipEvent_ITF interface {
	core.QEvent_ITF
	QStatusTipEvent_PTR() *QStatusTipEvent
}

func PointerFromQStatusTipEvent(ptr QStatusTipEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStatusTipEvent_PTR().Pointer()
	}
	return nil
}

func NewQStatusTipEventFromPointer(ptr unsafe.Pointer) *QStatusTipEvent {
	var n = new(QStatusTipEvent)
	n.SetPointer(ptr)
	return n
}

func newQStatusTipEventFromPointer(ptr unsafe.Pointer) *QStatusTipEvent {
	var n = NewQStatusTipEventFromPointer(ptr)
	return n
}

func (ptr *QStatusTipEvent) QStatusTipEvent_PTR() *QStatusTipEvent {
	return ptr
}

func NewQStatusTipEvent(tip string) *QStatusTipEvent {
	defer qt.Recovering("QStatusTipEvent::QStatusTipEvent")

	return newQStatusTipEventFromPointer(C.QStatusTipEvent_NewQStatusTipEvent(C.CString(tip)))
}

func (ptr *QStatusTipEvent) Tip() string {
	defer qt.Recovering("QStatusTipEvent::tip")

	if ptr.Pointer() != nil {
		return C.GoString(C.QStatusTipEvent_Tip(ptr.Pointer()))
	}
	return ""
}

type QStyleHints struct {
	core.QObject
}

type QStyleHints_ITF interface {
	core.QObject_ITF
	QStyleHints_PTR() *QStyleHints
}

func PointerFromQStyleHints(ptr QStyleHints_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QStyleHints_PTR().Pointer()
	}
	return nil
}

func NewQStyleHintsFromPointer(ptr unsafe.Pointer) *QStyleHints {
	var n = new(QStyleHints)
	n.SetPointer(ptr)
	return n
}

func newQStyleHintsFromPointer(ptr unsafe.Pointer) *QStyleHints {
	var n = NewQStyleHintsFromPointer(ptr)
	for len(n.ObjectName()) < len("QStyleHints_") {
		n.SetObjectName("QStyleHints_" + qt.Identifier())
	}
	return n
}

func (ptr *QStyleHints) QStyleHints_PTR() *QStyleHints {
	return ptr
}

func (ptr *QStyleHints) CursorFlashTime() int {
	defer qt.Recovering("QStyleHints::cursorFlashTime")

	if ptr.Pointer() != nil {
		return int(C.QStyleHints_CursorFlashTime(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) FontSmoothingGamma() float64 {
	defer qt.Recovering("QStyleHints::fontSmoothingGamma")

	if ptr.Pointer() != nil {
		return float64(C.QStyleHints_FontSmoothingGamma(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) KeyboardAutoRepeatRate() int {
	defer qt.Recovering("QStyleHints::keyboardAutoRepeatRate")

	if ptr.Pointer() != nil {
		return int(C.QStyleHints_KeyboardAutoRepeatRate(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) KeyboardInputInterval() int {
	defer qt.Recovering("QStyleHints::keyboardInputInterval")

	if ptr.Pointer() != nil {
		return int(C.QStyleHints_KeyboardInputInterval(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) MouseDoubleClickInterval() int {
	defer qt.Recovering("QStyleHints::mouseDoubleClickInterval")

	if ptr.Pointer() != nil {
		return int(C.QStyleHints_MouseDoubleClickInterval(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) MousePressAndHoldInterval() int {
	defer qt.Recovering("QStyleHints::mousePressAndHoldInterval")

	if ptr.Pointer() != nil {
		return int(C.QStyleHints_MousePressAndHoldInterval(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) PasswordMaskDelay() int {
	defer qt.Recovering("QStyleHints::passwordMaskDelay")

	if ptr.Pointer() != nil {
		return int(C.QStyleHints_PasswordMaskDelay(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) SetFocusOnTouchRelease() bool {
	defer qt.Recovering("QStyleHints::setFocusOnTouchRelease")

	if ptr.Pointer() != nil {
		return C.QStyleHints_SetFocusOnTouchRelease(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStyleHints) ShowIsFullScreen() bool {
	defer qt.Recovering("QStyleHints::showIsFullScreen")

	if ptr.Pointer() != nil {
		return C.QStyleHints_ShowIsFullScreen(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStyleHints) SingleClickActivation() bool {
	defer qt.Recovering("QStyleHints::singleClickActivation")

	if ptr.Pointer() != nil {
		return C.QStyleHints_SingleClickActivation(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStyleHints) StartDragDistance() int {
	defer qt.Recovering("QStyleHints::startDragDistance")

	if ptr.Pointer() != nil {
		return int(C.QStyleHints_StartDragDistance(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) StartDragTime() int {
	defer qt.Recovering("QStyleHints::startDragTime")

	if ptr.Pointer() != nil {
		return int(C.QStyleHints_StartDragTime(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) StartDragVelocity() int {
	defer qt.Recovering("QStyleHints::startDragVelocity")

	if ptr.Pointer() != nil {
		return int(C.QStyleHints_StartDragVelocity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) TabFocusBehavior() core.Qt__TabFocusBehavior {
	defer qt.Recovering("QStyleHints::tabFocusBehavior")

	if ptr.Pointer() != nil {
		return core.Qt__TabFocusBehavior(C.QStyleHints_TabFocusBehavior(ptr.Pointer()))
	}
	return 0
}

func (ptr *QStyleHints) UseRtlExtensions() bool {
	defer qt.Recovering("QStyleHints::useRtlExtensions")

	if ptr.Pointer() != nil {
		return C.QStyleHints_UseRtlExtensions(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QStyleHints) ConnectCursorFlashTimeChanged(f func(cursorFlashTime int)) {
	defer qt.Recovering("connect QStyleHints::cursorFlashTimeChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_ConnectCursorFlashTimeChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "cursorFlashTimeChanged", f)
	}
}

func (ptr *QStyleHints) DisconnectCursorFlashTimeChanged() {
	defer qt.Recovering("disconnect QStyleHints::cursorFlashTimeChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_DisconnectCursorFlashTimeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "cursorFlashTimeChanged")
	}
}

//export callbackQStyleHintsCursorFlashTimeChanged
func callbackQStyleHintsCursorFlashTimeChanged(ptr unsafe.Pointer, ptrName *C.char, cursorFlashTime C.int) {
	defer qt.Recovering("callback QStyleHints::cursorFlashTimeChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "cursorFlashTimeChanged"); signal != nil {
		signal.(func(int))(int(cursorFlashTime))
	}

}

func (ptr *QStyleHints) CursorFlashTimeChanged(cursorFlashTime int) {
	defer qt.Recovering("QStyleHints::cursorFlashTimeChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_CursorFlashTimeChanged(ptr.Pointer(), C.int(cursorFlashTime))
	}
}

func (ptr *QStyleHints) ConnectKeyboardInputIntervalChanged(f func(keyboardInputInterval int)) {
	defer qt.Recovering("connect QStyleHints::keyboardInputIntervalChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_ConnectKeyboardInputIntervalChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "keyboardInputIntervalChanged", f)
	}
}

func (ptr *QStyleHints) DisconnectKeyboardInputIntervalChanged() {
	defer qt.Recovering("disconnect QStyleHints::keyboardInputIntervalChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_DisconnectKeyboardInputIntervalChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "keyboardInputIntervalChanged")
	}
}

//export callbackQStyleHintsKeyboardInputIntervalChanged
func callbackQStyleHintsKeyboardInputIntervalChanged(ptr unsafe.Pointer, ptrName *C.char, keyboardInputInterval C.int) {
	defer qt.Recovering("callback QStyleHints::keyboardInputIntervalChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "keyboardInputIntervalChanged"); signal != nil {
		signal.(func(int))(int(keyboardInputInterval))
	}

}

func (ptr *QStyleHints) KeyboardInputIntervalChanged(keyboardInputInterval int) {
	defer qt.Recovering("QStyleHints::keyboardInputIntervalChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_KeyboardInputIntervalChanged(ptr.Pointer(), C.int(keyboardInputInterval))
	}
}

func (ptr *QStyleHints) ConnectMouseDoubleClickIntervalChanged(f func(mouseDoubleClickInterval int)) {
	defer qt.Recovering("connect QStyleHints::mouseDoubleClickIntervalChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_ConnectMouseDoubleClickIntervalChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "mouseDoubleClickIntervalChanged", f)
	}
}

func (ptr *QStyleHints) DisconnectMouseDoubleClickIntervalChanged() {
	defer qt.Recovering("disconnect QStyleHints::mouseDoubleClickIntervalChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_DisconnectMouseDoubleClickIntervalChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "mouseDoubleClickIntervalChanged")
	}
}

//export callbackQStyleHintsMouseDoubleClickIntervalChanged
func callbackQStyleHintsMouseDoubleClickIntervalChanged(ptr unsafe.Pointer, ptrName *C.char, mouseDoubleClickInterval C.int) {
	defer qt.Recovering("callback QStyleHints::mouseDoubleClickIntervalChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseDoubleClickIntervalChanged"); signal != nil {
		signal.(func(int))(int(mouseDoubleClickInterval))
	}

}

func (ptr *QStyleHints) MouseDoubleClickIntervalChanged(mouseDoubleClickInterval int) {
	defer qt.Recovering("QStyleHints::mouseDoubleClickIntervalChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_MouseDoubleClickIntervalChanged(ptr.Pointer(), C.int(mouseDoubleClickInterval))
	}
}

func (ptr *QStyleHints) ConnectStartDragDistanceChanged(f func(startDragDistance int)) {
	defer qt.Recovering("connect QStyleHints::startDragDistanceChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_ConnectStartDragDistanceChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "startDragDistanceChanged", f)
	}
}

func (ptr *QStyleHints) DisconnectStartDragDistanceChanged() {
	defer qt.Recovering("disconnect QStyleHints::startDragDistanceChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_DisconnectStartDragDistanceChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "startDragDistanceChanged")
	}
}

//export callbackQStyleHintsStartDragDistanceChanged
func callbackQStyleHintsStartDragDistanceChanged(ptr unsafe.Pointer, ptrName *C.char, startDragDistance C.int) {
	defer qt.Recovering("callback QStyleHints::startDragDistanceChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "startDragDistanceChanged"); signal != nil {
		signal.(func(int))(int(startDragDistance))
	}

}

func (ptr *QStyleHints) StartDragDistanceChanged(startDragDistance int) {
	defer qt.Recovering("QStyleHints::startDragDistanceChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_StartDragDistanceChanged(ptr.Pointer(), C.int(startDragDistance))
	}
}

func (ptr *QStyleHints) ConnectStartDragTimeChanged(f func(startDragTime int)) {
	defer qt.Recovering("connect QStyleHints::startDragTimeChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_ConnectStartDragTimeChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "startDragTimeChanged", f)
	}
}

func (ptr *QStyleHints) DisconnectStartDragTimeChanged() {
	defer qt.Recovering("disconnect QStyleHints::startDragTimeChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_DisconnectStartDragTimeChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "startDragTimeChanged")
	}
}

//export callbackQStyleHintsStartDragTimeChanged
func callbackQStyleHintsStartDragTimeChanged(ptr unsafe.Pointer, ptrName *C.char, startDragTime C.int) {
	defer qt.Recovering("callback QStyleHints::startDragTimeChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "startDragTimeChanged"); signal != nil {
		signal.(func(int))(int(startDragTime))
	}

}

func (ptr *QStyleHints) StartDragTimeChanged(startDragTime int) {
	defer qt.Recovering("QStyleHints::startDragTimeChanged")

	if ptr.Pointer() != nil {
		C.QStyleHints_StartDragTimeChanged(ptr.Pointer(), C.int(startDragTime))
	}
}

func (ptr *QStyleHints) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QStyleHints::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QStyleHints) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QStyleHints::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQStyleHintsTimerEvent
func callbackQStyleHintsTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStyleHints::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQStyleHintsFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QStyleHints) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QStyleHints::timerEvent")

	if ptr.Pointer() != nil {
		C.QStyleHints_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QStyleHints) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QStyleHints::timerEvent")

	if ptr.Pointer() != nil {
		C.QStyleHints_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QStyleHints) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QStyleHints::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QStyleHints) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QStyleHints::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQStyleHintsChildEvent
func callbackQStyleHintsChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStyleHints::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQStyleHintsFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QStyleHints) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QStyleHints::childEvent")

	if ptr.Pointer() != nil {
		C.QStyleHints_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QStyleHints) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QStyleHints::childEvent")

	if ptr.Pointer() != nil {
		C.QStyleHints_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QStyleHints) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QStyleHints::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QStyleHints) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QStyleHints::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQStyleHintsCustomEvent
func callbackQStyleHintsCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QStyleHints::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQStyleHintsFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QStyleHints) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QStyleHints::customEvent")

	if ptr.Pointer() != nil {
		C.QStyleHints_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QStyleHints) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QStyleHints::customEvent")

	if ptr.Pointer() != nil {
		C.QStyleHints_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QSupportedWritingSystems struct {
	ptr unsafe.Pointer
}

type QSupportedWritingSystems_ITF interface {
	QSupportedWritingSystems_PTR() *QSupportedWritingSystems
}

func (p *QSupportedWritingSystems) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSupportedWritingSystems) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSupportedWritingSystems(ptr QSupportedWritingSystems_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSupportedWritingSystems_PTR().Pointer()
	}
	return nil
}

func NewQSupportedWritingSystemsFromPointer(ptr unsafe.Pointer) *QSupportedWritingSystems {
	var n = new(QSupportedWritingSystems)
	n.SetPointer(ptr)
	return n
}

func newQSupportedWritingSystemsFromPointer(ptr unsafe.Pointer) *QSupportedWritingSystems {
	var n = NewQSupportedWritingSystemsFromPointer(ptr)
	return n
}

func (ptr *QSupportedWritingSystems) QSupportedWritingSystems_PTR() *QSupportedWritingSystems {
	return ptr
}

type QSurface struct {
	ptr unsafe.Pointer
}

type QSurface_ITF interface {
	QSurface_PTR() *QSurface
}

func (p *QSurface) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSurface) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSurface(ptr QSurface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSurface_PTR().Pointer()
	}
	return nil
}

func NewQSurfaceFromPointer(ptr unsafe.Pointer) *QSurface {
	var n = new(QSurface)
	n.SetPointer(ptr)
	return n
}

func newQSurfaceFromPointer(ptr unsafe.Pointer) *QSurface {
	var n = NewQSurfaceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QSurface_") {
		n.SetObjectNameAbs("QSurface_" + qt.Identifier())
	}
	return n
}

func (ptr *QSurface) QSurface_PTR() *QSurface {
	return ptr
}

//QSurface::SurfaceClass
type QSurface__SurfaceClass int64

const (
	QSurface__Window    = QSurface__SurfaceClass(0)
	QSurface__Offscreen = QSurface__SurfaceClass(1)
)

//QSurface::SurfaceType
type QSurface__SurfaceType int64

const (
	QSurface__RasterSurface   = QSurface__SurfaceType(0)
	QSurface__OpenGLSurface   = QSurface__SurfaceType(1)
	QSurface__RasterGLSurface = QSurface__SurfaceType(2)
)

func (ptr *QSurface) Size() *core.QSize {
	defer qt.Recovering("QSurface::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QSurface_Size(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSurface) SupportsOpenGL() bool {
	defer qt.Recovering("QSurface::supportsOpenGL")

	if ptr.Pointer() != nil {
		return C.QSurface_SupportsOpenGL(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSurface) SurfaceClass() QSurface__SurfaceClass {
	defer qt.Recovering("QSurface::surfaceClass")

	if ptr.Pointer() != nil {
		return QSurface__SurfaceClass(C.QSurface_SurfaceClass(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurface) SurfaceType() QSurface__SurfaceType {
	defer qt.Recovering("QSurface::surfaceType")

	if ptr.Pointer() != nil {
		return QSurface__SurfaceType(C.QSurface_SurfaceType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurface) DestroyQSurface() {
	defer qt.Recovering("QSurface::~QSurface")

	if ptr.Pointer() != nil {
		C.QSurface_DestroyQSurface(ptr.Pointer())
	}
}

func (ptr *QSurface) ObjectNameAbs() string {
	defer qt.Recovering("QSurface::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QSurface_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QSurface) SetObjectNameAbs(name string) {
	defer qt.Recovering("QSurface::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QSurface_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QSurfaceFormat struct {
	ptr unsafe.Pointer
}

type QSurfaceFormat_ITF interface {
	QSurfaceFormat_PTR() *QSurfaceFormat
}

func (p *QSurfaceFormat) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QSurfaceFormat) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQSurfaceFormat(ptr QSurfaceFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSurfaceFormat_PTR().Pointer()
	}
	return nil
}

func NewQSurfaceFormatFromPointer(ptr unsafe.Pointer) *QSurfaceFormat {
	var n = new(QSurfaceFormat)
	n.SetPointer(ptr)
	return n
}

func newQSurfaceFormatFromPointer(ptr unsafe.Pointer) *QSurfaceFormat {
	var n = NewQSurfaceFormatFromPointer(ptr)
	return n
}

func (ptr *QSurfaceFormat) QSurfaceFormat_PTR() *QSurfaceFormat {
	return ptr
}

//QSurfaceFormat::FormatOption
type QSurfaceFormat__FormatOption int64

const (
	QSurfaceFormat__StereoBuffers       = QSurfaceFormat__FormatOption(0x0001)
	QSurfaceFormat__DebugContext        = QSurfaceFormat__FormatOption(0x0002)
	QSurfaceFormat__DeprecatedFunctions = QSurfaceFormat__FormatOption(0x0004)
	QSurfaceFormat__ResetNotification   = QSurfaceFormat__FormatOption(0x0008)
)

//QSurfaceFormat::OpenGLContextProfile
type QSurfaceFormat__OpenGLContextProfile int64

const (
	QSurfaceFormat__NoProfile            = QSurfaceFormat__OpenGLContextProfile(0)
	QSurfaceFormat__CoreProfile          = QSurfaceFormat__OpenGLContextProfile(1)
	QSurfaceFormat__CompatibilityProfile = QSurfaceFormat__OpenGLContextProfile(2)
)

//QSurfaceFormat::RenderableType
type QSurfaceFormat__RenderableType int64

const (
	QSurfaceFormat__DefaultRenderableType = QSurfaceFormat__RenderableType(0x0)
	QSurfaceFormat__OpenGL                = QSurfaceFormat__RenderableType(0x1)
	QSurfaceFormat__OpenGLES              = QSurfaceFormat__RenderableType(0x2)
	QSurfaceFormat__OpenVG                = QSurfaceFormat__RenderableType(0x4)
)

//QSurfaceFormat::SwapBehavior
type QSurfaceFormat__SwapBehavior int64

const (
	QSurfaceFormat__DefaultSwapBehavior = QSurfaceFormat__SwapBehavior(0)
	QSurfaceFormat__SingleBuffer        = QSurfaceFormat__SwapBehavior(1)
	QSurfaceFormat__DoubleBuffer        = QSurfaceFormat__SwapBehavior(2)
	QSurfaceFormat__TripleBuffer        = QSurfaceFormat__SwapBehavior(3)
)

func NewQSurfaceFormat() *QSurfaceFormat {
	defer qt.Recovering("QSurfaceFormat::QSurfaceFormat")

	return newQSurfaceFormatFromPointer(C.QSurfaceFormat_NewQSurfaceFormat())
}

func NewQSurfaceFormat2(options QSurfaceFormat__FormatOption) *QSurfaceFormat {
	defer qt.Recovering("QSurfaceFormat::QSurfaceFormat")

	return newQSurfaceFormatFromPointer(C.QSurfaceFormat_NewQSurfaceFormat2(C.int(options)))
}

func NewQSurfaceFormat3(other QSurfaceFormat_ITF) *QSurfaceFormat {
	defer qt.Recovering("QSurfaceFormat::QSurfaceFormat")

	return newQSurfaceFormatFromPointer(C.QSurfaceFormat_NewQSurfaceFormat3(PointerFromQSurfaceFormat(other)))
}

func (ptr *QSurfaceFormat) AlphaBufferSize() int {
	defer qt.Recovering("QSurfaceFormat::alphaBufferSize")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_AlphaBufferSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) BlueBufferSize() int {
	defer qt.Recovering("QSurfaceFormat::blueBufferSize")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_BlueBufferSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) DepthBufferSize() int {
	defer qt.Recovering("QSurfaceFormat::depthBufferSize")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_DepthBufferSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) GreenBufferSize() int {
	defer qt.Recovering("QSurfaceFormat::greenBufferSize")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_GreenBufferSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) HasAlpha() bool {
	defer qt.Recovering("QSurfaceFormat::hasAlpha")

	if ptr.Pointer() != nil {
		return C.QSurfaceFormat_HasAlpha(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSurfaceFormat) MajorVersion() int {
	defer qt.Recovering("QSurfaceFormat::majorVersion")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_MajorVersion(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) MinorVersion() int {
	defer qt.Recovering("QSurfaceFormat::minorVersion")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_MinorVersion(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) Options() QSurfaceFormat__FormatOption {
	defer qt.Recovering("QSurfaceFormat::options")

	if ptr.Pointer() != nil {
		return QSurfaceFormat__FormatOption(C.QSurfaceFormat_Options(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) Profile() QSurfaceFormat__OpenGLContextProfile {
	defer qt.Recovering("QSurfaceFormat::profile")

	if ptr.Pointer() != nil {
		return QSurfaceFormat__OpenGLContextProfile(C.QSurfaceFormat_Profile(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) RedBufferSize() int {
	defer qt.Recovering("QSurfaceFormat::redBufferSize")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_RedBufferSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) RenderableType() QSurfaceFormat__RenderableType {
	defer qt.Recovering("QSurfaceFormat::renderableType")

	if ptr.Pointer() != nil {
		return QSurfaceFormat__RenderableType(C.QSurfaceFormat_RenderableType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) Samples() int {
	defer qt.Recovering("QSurfaceFormat::samples")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_Samples(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) SetAlphaBufferSize(size int) {
	defer qt.Recovering("QSurfaceFormat::setAlphaBufferSize")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetAlphaBufferSize(ptr.Pointer(), C.int(size))
	}
}

func (ptr *QSurfaceFormat) SetBlueBufferSize(size int) {
	defer qt.Recovering("QSurfaceFormat::setBlueBufferSize")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetBlueBufferSize(ptr.Pointer(), C.int(size))
	}
}

func QSurfaceFormat_SetDefaultFormat(format QSurfaceFormat_ITF) {
	defer qt.Recovering("QSurfaceFormat::setDefaultFormat")

	C.QSurfaceFormat_QSurfaceFormat_SetDefaultFormat(PointerFromQSurfaceFormat(format))
}

func (ptr *QSurfaceFormat) SetDepthBufferSize(size int) {
	defer qt.Recovering("QSurfaceFormat::setDepthBufferSize")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetDepthBufferSize(ptr.Pointer(), C.int(size))
	}
}

func (ptr *QSurfaceFormat) SetGreenBufferSize(size int) {
	defer qt.Recovering("QSurfaceFormat::setGreenBufferSize")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetGreenBufferSize(ptr.Pointer(), C.int(size))
	}
}

func (ptr *QSurfaceFormat) SetMajorVersion(major int) {
	defer qt.Recovering("QSurfaceFormat::setMajorVersion")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetMajorVersion(ptr.Pointer(), C.int(major))
	}
}

func (ptr *QSurfaceFormat) SetMinorVersion(minor int) {
	defer qt.Recovering("QSurfaceFormat::setMinorVersion")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetMinorVersion(ptr.Pointer(), C.int(minor))
	}
}

func (ptr *QSurfaceFormat) SetOption(option QSurfaceFormat__FormatOption, on bool) {
	defer qt.Recovering("QSurfaceFormat::setOption")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetOption(ptr.Pointer(), C.int(option), C.int(qt.GoBoolToInt(on)))
	}
}

func (ptr *QSurfaceFormat) SetOptions(options QSurfaceFormat__FormatOption) {
	defer qt.Recovering("QSurfaceFormat::setOptions")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetOptions(ptr.Pointer(), C.int(options))
	}
}

func (ptr *QSurfaceFormat) SetProfile(profile QSurfaceFormat__OpenGLContextProfile) {
	defer qt.Recovering("QSurfaceFormat::setProfile")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetProfile(ptr.Pointer(), C.int(profile))
	}
}

func (ptr *QSurfaceFormat) SetRedBufferSize(size int) {
	defer qt.Recovering("QSurfaceFormat::setRedBufferSize")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetRedBufferSize(ptr.Pointer(), C.int(size))
	}
}

func (ptr *QSurfaceFormat) SetRenderableType(ty QSurfaceFormat__RenderableType) {
	defer qt.Recovering("QSurfaceFormat::setRenderableType")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetRenderableType(ptr.Pointer(), C.int(ty))
	}
}

func (ptr *QSurfaceFormat) SetSamples(numSamples int) {
	defer qt.Recovering("QSurfaceFormat::setSamples")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetSamples(ptr.Pointer(), C.int(numSamples))
	}
}

func (ptr *QSurfaceFormat) SetStencilBufferSize(size int) {
	defer qt.Recovering("QSurfaceFormat::setStencilBufferSize")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetStencilBufferSize(ptr.Pointer(), C.int(size))
	}
}

func (ptr *QSurfaceFormat) SetStereo(enable bool) {
	defer qt.Recovering("QSurfaceFormat::setStereo")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetStereo(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QSurfaceFormat) SetSwapBehavior(behavior QSurfaceFormat__SwapBehavior) {
	defer qt.Recovering("QSurfaceFormat::setSwapBehavior")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetSwapBehavior(ptr.Pointer(), C.int(behavior))
	}
}

func (ptr *QSurfaceFormat) SetSwapInterval(interval int) {
	defer qt.Recovering("QSurfaceFormat::setSwapInterval")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetSwapInterval(ptr.Pointer(), C.int(interval))
	}
}

func (ptr *QSurfaceFormat) SetVersion(major int, minor int) {
	defer qt.Recovering("QSurfaceFormat::setVersion")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_SetVersion(ptr.Pointer(), C.int(major), C.int(minor))
	}
}

func (ptr *QSurfaceFormat) StencilBufferSize() int {
	defer qt.Recovering("QSurfaceFormat::stencilBufferSize")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_StencilBufferSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) Stereo() bool {
	defer qt.Recovering("QSurfaceFormat::stereo")

	if ptr.Pointer() != nil {
		return C.QSurfaceFormat_Stereo(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QSurfaceFormat) SwapBehavior() QSurfaceFormat__SwapBehavior {
	defer qt.Recovering("QSurfaceFormat::swapBehavior")

	if ptr.Pointer() != nil {
		return QSurfaceFormat__SwapBehavior(C.QSurfaceFormat_SwapBehavior(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) SwapInterval() int {
	defer qt.Recovering("QSurfaceFormat::swapInterval")

	if ptr.Pointer() != nil {
		return int(C.QSurfaceFormat_SwapInterval(ptr.Pointer()))
	}
	return 0
}

func (ptr *QSurfaceFormat) TestOption(option QSurfaceFormat__FormatOption) bool {
	defer qt.Recovering("QSurfaceFormat::testOption")

	if ptr.Pointer() != nil {
		return C.QSurfaceFormat_TestOption(ptr.Pointer(), C.int(option)) != 0
	}
	return false
}

func (ptr *QSurfaceFormat) DestroyQSurfaceFormat() {
	defer qt.Recovering("QSurfaceFormat::~QSurfaceFormat")

	if ptr.Pointer() != nil {
		C.QSurfaceFormat_DestroyQSurfaceFormat(ptr.Pointer())
	}
}

type QSyntaxHighlighter struct {
	core.QObject
}

type QSyntaxHighlighter_ITF interface {
	core.QObject_ITF
	QSyntaxHighlighter_PTR() *QSyntaxHighlighter
}

func PointerFromQSyntaxHighlighter(ptr QSyntaxHighlighter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QSyntaxHighlighter_PTR().Pointer()
	}
	return nil
}

func NewQSyntaxHighlighterFromPointer(ptr unsafe.Pointer) *QSyntaxHighlighter {
	var n = new(QSyntaxHighlighter)
	n.SetPointer(ptr)
	return n
}

func newQSyntaxHighlighterFromPointer(ptr unsafe.Pointer) *QSyntaxHighlighter {
	var n = NewQSyntaxHighlighterFromPointer(ptr)
	for len(n.ObjectName()) < len("QSyntaxHighlighter_") {
		n.SetObjectName("QSyntaxHighlighter_" + qt.Identifier())
	}
	return n
}

func (ptr *QSyntaxHighlighter) QSyntaxHighlighter_PTR() *QSyntaxHighlighter {
	return ptr
}

func (ptr *QSyntaxHighlighter) Document() *QTextDocument {
	defer qt.Recovering("QSyntaxHighlighter::document")

	if ptr.Pointer() != nil {
		return NewQTextDocumentFromPointer(C.QSyntaxHighlighter_Document(ptr.Pointer()))
	}
	return nil
}

func (ptr *QSyntaxHighlighter) Rehighlight() {
	defer qt.Recovering("QSyntaxHighlighter::rehighlight")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_Rehighlight(ptr.Pointer())
	}
}

func (ptr *QSyntaxHighlighter) RehighlightBlock(block QTextBlock_ITF) {
	defer qt.Recovering("QSyntaxHighlighter::rehighlightBlock")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_RehighlightBlock(ptr.Pointer(), PointerFromQTextBlock(block))
	}
}

func (ptr *QSyntaxHighlighter) SetDocument(doc QTextDocument_ITF) {
	defer qt.Recovering("QSyntaxHighlighter::setDocument")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_SetDocument(ptr.Pointer(), PointerFromQTextDocument(doc))
	}
}

func (ptr *QSyntaxHighlighter) DestroyQSyntaxHighlighter() {
	defer qt.Recovering("QSyntaxHighlighter::~QSyntaxHighlighter")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_DestroyQSyntaxHighlighter(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSyntaxHighlighter) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QSyntaxHighlighter::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QSyntaxHighlighter) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QSyntaxHighlighter::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQSyntaxHighlighterTimerEvent
func callbackQSyntaxHighlighterTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSyntaxHighlighter::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQSyntaxHighlighterFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QSyntaxHighlighter) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QSyntaxHighlighter::timerEvent")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QSyntaxHighlighter) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QSyntaxHighlighter::timerEvent")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QSyntaxHighlighter) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QSyntaxHighlighter::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QSyntaxHighlighter) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QSyntaxHighlighter::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQSyntaxHighlighterChildEvent
func callbackQSyntaxHighlighterChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSyntaxHighlighter::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQSyntaxHighlighterFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QSyntaxHighlighter) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QSyntaxHighlighter::childEvent")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QSyntaxHighlighter) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QSyntaxHighlighter::childEvent")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QSyntaxHighlighter) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QSyntaxHighlighter::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QSyntaxHighlighter) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QSyntaxHighlighter::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQSyntaxHighlighterCustomEvent
func callbackQSyntaxHighlighterCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QSyntaxHighlighter::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQSyntaxHighlighterFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QSyntaxHighlighter) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QSyntaxHighlighter::customEvent")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QSyntaxHighlighter) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QSyntaxHighlighter::customEvent")

	if ptr.Pointer() != nil {
		C.QSyntaxHighlighter_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QTabletEvent struct {
	QInputEvent
}

type QTabletEvent_ITF interface {
	QInputEvent_ITF
	QTabletEvent_PTR() *QTabletEvent
}

func PointerFromQTabletEvent(ptr QTabletEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTabletEvent_PTR().Pointer()
	}
	return nil
}

func NewQTabletEventFromPointer(ptr unsafe.Pointer) *QTabletEvent {
	var n = new(QTabletEvent)
	n.SetPointer(ptr)
	return n
}

func newQTabletEventFromPointer(ptr unsafe.Pointer) *QTabletEvent {
	var n = NewQTabletEventFromPointer(ptr)
	return n
}

func (ptr *QTabletEvent) QTabletEvent_PTR() *QTabletEvent {
	return ptr
}

//QTabletEvent::PointerType
type QTabletEvent__PointerType int64

const (
	QTabletEvent__UnknownPointer = QTabletEvent__PointerType(0)
	QTabletEvent__Pen            = QTabletEvent__PointerType(1)
	QTabletEvent__Cursor         = QTabletEvent__PointerType(2)
	QTabletEvent__Eraser         = QTabletEvent__PointerType(3)
)

//QTabletEvent::TabletDevice
type QTabletEvent__TabletDevice int64

const (
	QTabletEvent__NoDevice       = QTabletEvent__TabletDevice(0)
	QTabletEvent__Puck           = QTabletEvent__TabletDevice(1)
	QTabletEvent__Stylus         = QTabletEvent__TabletDevice(2)
	QTabletEvent__Airbrush       = QTabletEvent__TabletDevice(3)
	QTabletEvent__FourDMouse     = QTabletEvent__TabletDevice(4)
	QTabletEvent__XFreeEraser    = QTabletEvent__TabletDevice(5)
	QTabletEvent__RotationStylus = QTabletEvent__TabletDevice(6)
)

func NewQTabletEvent(ty core.QEvent__Type, pos core.QPointF_ITF, globalPos core.QPointF_ITF, device int, pointerType int, pressure float64, xTilt int, yTilt int, tangentialPressure float64, rotation float64, z int, keyState core.Qt__KeyboardModifier, uniqueID int64, button core.Qt__MouseButton, buttons core.Qt__MouseButton) *QTabletEvent {
	defer qt.Recovering("QTabletEvent::QTabletEvent")

	return newQTabletEventFromPointer(C.QTabletEvent_NewQTabletEvent(C.int(ty), core.PointerFromQPointF(pos), core.PointerFromQPointF(globalPos), C.int(device), C.int(pointerType), C.double(pressure), C.int(xTilt), C.int(yTilt), C.double(tangentialPressure), C.double(rotation), C.int(z), C.int(keyState), C.longlong(uniqueID), C.int(button), C.int(buttons)))
}

func (ptr *QTabletEvent) Button() core.Qt__MouseButton {
	defer qt.Recovering("QTabletEvent::button")

	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QTabletEvent_Button(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) Buttons() core.Qt__MouseButton {
	defer qt.Recovering("QTabletEvent::buttons")

	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QTabletEvent_Buttons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) Device() QTabletEvent__TabletDevice {
	defer qt.Recovering("QTabletEvent::device")

	if ptr.Pointer() != nil {
		return QTabletEvent__TabletDevice(C.QTabletEvent_Device(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) GlobalPos() *core.QPoint {
	defer qt.Recovering("QTabletEvent::globalPos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QTabletEvent_GlobalPos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTabletEvent) GlobalX() int {
	defer qt.Recovering("QTabletEvent::globalX")

	if ptr.Pointer() != nil {
		return int(C.QTabletEvent_GlobalX(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) GlobalY() int {
	defer qt.Recovering("QTabletEvent::globalY")

	if ptr.Pointer() != nil {
		return int(C.QTabletEvent_GlobalY(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) HiResGlobalX() float64 {
	defer qt.Recovering("QTabletEvent::hiResGlobalX")

	if ptr.Pointer() != nil {
		return float64(C.QTabletEvent_HiResGlobalX(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) HiResGlobalY() float64 {
	defer qt.Recovering("QTabletEvent::hiResGlobalY")

	if ptr.Pointer() != nil {
		return float64(C.QTabletEvent_HiResGlobalY(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) PointerType() QTabletEvent__PointerType {
	defer qt.Recovering("QTabletEvent::pointerType")

	if ptr.Pointer() != nil {
		return QTabletEvent__PointerType(C.QTabletEvent_PointerType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) Pos() *core.QPoint {
	defer qt.Recovering("QTabletEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QTabletEvent_Pos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTabletEvent) Pressure() float64 {
	defer qt.Recovering("QTabletEvent::pressure")

	if ptr.Pointer() != nil {
		return float64(C.QTabletEvent_Pressure(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) Rotation() float64 {
	defer qt.Recovering("QTabletEvent::rotation")

	if ptr.Pointer() != nil {
		return float64(C.QTabletEvent_Rotation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) TangentialPressure() float64 {
	defer qt.Recovering("QTabletEvent::tangentialPressure")

	if ptr.Pointer() != nil {
		return float64(C.QTabletEvent_TangentialPressure(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) UniqueId() int64 {
	defer qt.Recovering("QTabletEvent::uniqueId")

	if ptr.Pointer() != nil {
		return int64(C.QTabletEvent_UniqueId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) X() int {
	defer qt.Recovering("QTabletEvent::x")

	if ptr.Pointer() != nil {
		return int(C.QTabletEvent_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) XTilt() int {
	defer qt.Recovering("QTabletEvent::xTilt")

	if ptr.Pointer() != nil {
		return int(C.QTabletEvent_XTilt(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) Y() int {
	defer qt.Recovering("QTabletEvent::y")

	if ptr.Pointer() != nil {
		return int(C.QTabletEvent_Y(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) YTilt() int {
	defer qt.Recovering("QTabletEvent::yTilt")

	if ptr.Pointer() != nil {
		return int(C.QTabletEvent_YTilt(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTabletEvent) Z() int {
	defer qt.Recovering("QTabletEvent::z")

	if ptr.Pointer() != nil {
		return int(C.QTabletEvent_Z(ptr.Pointer()))
	}
	return 0
}

type QTextBlock struct {
	ptr unsafe.Pointer
}

type QTextBlock_ITF interface {
	QTextBlock_PTR() *QTextBlock
}

func (p *QTextBlock) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextBlock) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextBlock(ptr QTextBlock_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextBlock_PTR().Pointer()
	}
	return nil
}

func NewQTextBlockFromPointer(ptr unsafe.Pointer) *QTextBlock {
	var n = new(QTextBlock)
	n.SetPointer(ptr)
	return n
}

func newQTextBlockFromPointer(ptr unsafe.Pointer) *QTextBlock {
	var n = NewQTextBlockFromPointer(ptr)
	return n
}

func (ptr *QTextBlock) QTextBlock_PTR() *QTextBlock {
	return ptr
}

func (ptr *QTextBlock) IsValid() bool {
	defer qt.Recovering("QTextBlock::isValid")

	if ptr.Pointer() != nil {
		return C.QTextBlock_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func NewQTextBlock(other QTextBlock_ITF) *QTextBlock {
	defer qt.Recovering("QTextBlock::QTextBlock")

	return newQTextBlockFromPointer(C.QTextBlock_NewQTextBlock(PointerFromQTextBlock(other)))
}

func (ptr *QTextBlock) BlockFormatIndex() int {
	defer qt.Recovering("QTextBlock::blockFormatIndex")

	if ptr.Pointer() != nil {
		return int(C.QTextBlock_BlockFormatIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlock) CharFormatIndex() int {
	defer qt.Recovering("QTextBlock::charFormatIndex")

	if ptr.Pointer() != nil {
		return int(C.QTextBlock_CharFormatIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlock) ClearLayout() {
	defer qt.Recovering("QTextBlock::clearLayout")

	if ptr.Pointer() != nil {
		C.QTextBlock_ClearLayout(ptr.Pointer())
	}
}

func (ptr *QTextBlock) Contains(position int) bool {
	defer qt.Recovering("QTextBlock::contains")

	if ptr.Pointer() != nil {
		return C.QTextBlock_Contains(ptr.Pointer(), C.int(position)) != 0
	}
	return false
}

func (ptr *QTextBlock) BlockNumber() int {
	defer qt.Recovering("QTextBlock::blockNumber")

	if ptr.Pointer() != nil {
		return int(C.QTextBlock_BlockNumber(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlock) Document() *QTextDocument {
	defer qt.Recovering("QTextBlock::document")

	if ptr.Pointer() != nil {
		return NewQTextDocumentFromPointer(C.QTextBlock_Document(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextBlock) FirstLineNumber() int {
	defer qt.Recovering("QTextBlock::firstLineNumber")

	if ptr.Pointer() != nil {
		return int(C.QTextBlock_FirstLineNumber(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlock) IsVisible() bool {
	defer qt.Recovering("QTextBlock::isVisible")

	if ptr.Pointer() != nil {
		return C.QTextBlock_IsVisible(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextBlock) Layout() *QTextLayout {
	defer qt.Recovering("QTextBlock::layout")

	if ptr.Pointer() != nil {
		return NewQTextLayoutFromPointer(C.QTextBlock_Layout(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextBlock) Length() int {
	defer qt.Recovering("QTextBlock::length")

	if ptr.Pointer() != nil {
		return int(C.QTextBlock_Length(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlock) LineCount() int {
	defer qt.Recovering("QTextBlock::lineCount")

	if ptr.Pointer() != nil {
		return int(C.QTextBlock_LineCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlock) Position() int {
	defer qt.Recovering("QTextBlock::position")

	if ptr.Pointer() != nil {
		return int(C.QTextBlock_Position(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlock) Revision() int {
	defer qt.Recovering("QTextBlock::revision")

	if ptr.Pointer() != nil {
		return int(C.QTextBlock_Revision(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlock) SetLineCount(count int) {
	defer qt.Recovering("QTextBlock::setLineCount")

	if ptr.Pointer() != nil {
		C.QTextBlock_SetLineCount(ptr.Pointer(), C.int(count))
	}
}

func (ptr *QTextBlock) SetRevision(rev int) {
	defer qt.Recovering("QTextBlock::setRevision")

	if ptr.Pointer() != nil {
		C.QTextBlock_SetRevision(ptr.Pointer(), C.int(rev))
	}
}

func (ptr *QTextBlock) SetUserData(data QTextBlockUserData_ITF) {
	defer qt.Recovering("QTextBlock::setUserData")

	if ptr.Pointer() != nil {
		C.QTextBlock_SetUserData(ptr.Pointer(), PointerFromQTextBlockUserData(data))
	}
}

func (ptr *QTextBlock) SetUserState(state int) {
	defer qt.Recovering("QTextBlock::setUserState")

	if ptr.Pointer() != nil {
		C.QTextBlock_SetUserState(ptr.Pointer(), C.int(state))
	}
}

func (ptr *QTextBlock) SetVisible(visible bool) {
	defer qt.Recovering("QTextBlock::setVisible")

	if ptr.Pointer() != nil {
		C.QTextBlock_SetVisible(ptr.Pointer(), C.int(qt.GoBoolToInt(visible)))
	}
}

func (ptr *QTextBlock) Text() string {
	defer qt.Recovering("QTextBlock::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextBlock_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextBlock) TextDirection() core.Qt__LayoutDirection {
	defer qt.Recovering("QTextBlock::textDirection")

	if ptr.Pointer() != nil {
		return core.Qt__LayoutDirection(C.QTextBlock_TextDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlock) TextList() *QTextList {
	defer qt.Recovering("QTextBlock::textList")

	if ptr.Pointer() != nil {
		return NewQTextListFromPointer(C.QTextBlock_TextList(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextBlock) UserData() *QTextBlockUserData {
	defer qt.Recovering("QTextBlock::userData")

	if ptr.Pointer() != nil {
		return NewQTextBlockUserDataFromPointer(C.QTextBlock_UserData(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextBlock) UserState() int {
	defer qt.Recovering("QTextBlock::userState")

	if ptr.Pointer() != nil {
		return int(C.QTextBlock_UserState(ptr.Pointer()))
	}
	return 0
}

type QTextBlockFormat struct {
	QTextFormat
}

type QTextBlockFormat_ITF interface {
	QTextFormat_ITF
	QTextBlockFormat_PTR() *QTextBlockFormat
}

func PointerFromQTextBlockFormat(ptr QTextBlockFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextBlockFormat_PTR().Pointer()
	}
	return nil
}

func NewQTextBlockFormatFromPointer(ptr unsafe.Pointer) *QTextBlockFormat {
	var n = new(QTextBlockFormat)
	n.SetPointer(ptr)
	return n
}

func newQTextBlockFormatFromPointer(ptr unsafe.Pointer) *QTextBlockFormat {
	var n = NewQTextBlockFormatFromPointer(ptr)
	return n
}

func (ptr *QTextBlockFormat) QTextBlockFormat_PTR() *QTextBlockFormat {
	return ptr
}

//QTextBlockFormat::LineHeightTypes
type QTextBlockFormat__LineHeightTypes int64

const (
	QTextBlockFormat__SingleHeight       = QTextBlockFormat__LineHeightTypes(0)
	QTextBlockFormat__ProportionalHeight = QTextBlockFormat__LineHeightTypes(1)
	QTextBlockFormat__FixedHeight        = QTextBlockFormat__LineHeightTypes(2)
	QTextBlockFormat__MinimumHeight      = QTextBlockFormat__LineHeightTypes(3)
	QTextBlockFormat__LineDistanceHeight = QTextBlockFormat__LineHeightTypes(4)
)

func NewQTextBlockFormat() *QTextBlockFormat {
	defer qt.Recovering("QTextBlockFormat::QTextBlockFormat")

	return newQTextBlockFormatFromPointer(C.QTextBlockFormat_NewQTextBlockFormat())
}

func (ptr *QTextBlockFormat) Alignment() core.Qt__AlignmentFlag {
	defer qt.Recovering("QTextBlockFormat::alignment")

	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QTextBlockFormat_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlockFormat) BottomMargin() float64 {
	defer qt.Recovering("QTextBlockFormat::bottomMargin")

	if ptr.Pointer() != nil {
		return float64(C.QTextBlockFormat_BottomMargin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlockFormat) Indent() int {
	defer qt.Recovering("QTextBlockFormat::indent")

	if ptr.Pointer() != nil {
		return int(C.QTextBlockFormat_Indent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlockFormat) IsValid() bool {
	defer qt.Recovering("QTextBlockFormat::isValid")

	if ptr.Pointer() != nil {
		return C.QTextBlockFormat_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextBlockFormat) LeftMargin() float64 {
	defer qt.Recovering("QTextBlockFormat::leftMargin")

	if ptr.Pointer() != nil {
		return float64(C.QTextBlockFormat_LeftMargin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlockFormat) LineHeight2() float64 {
	defer qt.Recovering("QTextBlockFormat::lineHeight")

	if ptr.Pointer() != nil {
		return float64(C.QTextBlockFormat_LineHeight2(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlockFormat) LineHeight(scriptLineHeight float64, scaling float64) float64 {
	defer qt.Recovering("QTextBlockFormat::lineHeight")

	if ptr.Pointer() != nil {
		return float64(C.QTextBlockFormat_LineHeight(ptr.Pointer(), C.double(scriptLineHeight), C.double(scaling)))
	}
	return 0
}

func (ptr *QTextBlockFormat) LineHeightType() int {
	defer qt.Recovering("QTextBlockFormat::lineHeightType")

	if ptr.Pointer() != nil {
		return int(C.QTextBlockFormat_LineHeightType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlockFormat) NonBreakableLines() bool {
	defer qt.Recovering("QTextBlockFormat::nonBreakableLines")

	if ptr.Pointer() != nil {
		return C.QTextBlockFormat_NonBreakableLines(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextBlockFormat) PageBreakPolicy() QTextFormat__PageBreakFlag {
	defer qt.Recovering("QTextBlockFormat::pageBreakPolicy")

	if ptr.Pointer() != nil {
		return QTextFormat__PageBreakFlag(C.QTextBlockFormat_PageBreakPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlockFormat) RightMargin() float64 {
	defer qt.Recovering("QTextBlockFormat::rightMargin")

	if ptr.Pointer() != nil {
		return float64(C.QTextBlockFormat_RightMargin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlockFormat) SetAlignment(alignment core.Qt__AlignmentFlag) {
	defer qt.Recovering("QTextBlockFormat::setAlignment")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetAlignment(ptr.Pointer(), C.int(alignment))
	}
}

func (ptr *QTextBlockFormat) SetBottomMargin(margin float64) {
	defer qt.Recovering("QTextBlockFormat::setBottomMargin")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetBottomMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextBlockFormat) SetIndent(indentation int) {
	defer qt.Recovering("QTextBlockFormat::setIndent")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetIndent(ptr.Pointer(), C.int(indentation))
	}
}

func (ptr *QTextBlockFormat) SetLeftMargin(margin float64) {
	defer qt.Recovering("QTextBlockFormat::setLeftMargin")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetLeftMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextBlockFormat) SetLineHeight(height float64, heightType int) {
	defer qt.Recovering("QTextBlockFormat::setLineHeight")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetLineHeight(ptr.Pointer(), C.double(height), C.int(heightType))
	}
}

func (ptr *QTextBlockFormat) SetNonBreakableLines(b bool) {
	defer qt.Recovering("QTextBlockFormat::setNonBreakableLines")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetNonBreakableLines(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
	}
}

func (ptr *QTextBlockFormat) SetPageBreakPolicy(policy QTextFormat__PageBreakFlag) {
	defer qt.Recovering("QTextBlockFormat::setPageBreakPolicy")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetPageBreakPolicy(ptr.Pointer(), C.int(policy))
	}
}

func (ptr *QTextBlockFormat) SetRightMargin(margin float64) {
	defer qt.Recovering("QTextBlockFormat::setRightMargin")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetRightMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextBlockFormat) SetTextIndent(indent float64) {
	defer qt.Recovering("QTextBlockFormat::setTextIndent")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetTextIndent(ptr.Pointer(), C.double(indent))
	}
}

func (ptr *QTextBlockFormat) SetTopMargin(margin float64) {
	defer qt.Recovering("QTextBlockFormat::setTopMargin")

	if ptr.Pointer() != nil {
		C.QTextBlockFormat_SetTopMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextBlockFormat) TextIndent() float64 {
	defer qt.Recovering("QTextBlockFormat::textIndent")

	if ptr.Pointer() != nil {
		return float64(C.QTextBlockFormat_TextIndent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextBlockFormat) TopMargin() float64 {
	defer qt.Recovering("QTextBlockFormat::topMargin")

	if ptr.Pointer() != nil {
		return float64(C.QTextBlockFormat_TopMargin(ptr.Pointer()))
	}
	return 0
}

type QTextBlockGroup struct {
	QTextObject
}

type QTextBlockGroup_ITF interface {
	QTextObject_ITF
	QTextBlockGroup_PTR() *QTextBlockGroup
}

func PointerFromQTextBlockGroup(ptr QTextBlockGroup_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextBlockGroup_PTR().Pointer()
	}
	return nil
}

func NewQTextBlockGroupFromPointer(ptr unsafe.Pointer) *QTextBlockGroup {
	var n = new(QTextBlockGroup)
	n.SetPointer(ptr)
	return n
}

func newQTextBlockGroupFromPointer(ptr unsafe.Pointer) *QTextBlockGroup {
	var n = NewQTextBlockGroupFromPointer(ptr)
	for len(n.ObjectName()) < len("QTextBlockGroup_") {
		n.SetObjectName("QTextBlockGroup_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextBlockGroup) QTextBlockGroup_PTR() *QTextBlockGroup {
	return ptr
}

func (ptr *QTextBlockGroup) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QTextBlockGroup::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTextBlockGroup) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTextBlockGroup::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTextBlockGroupTimerEvent
func callbackQTextBlockGroupTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextBlockGroup::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQTextBlockGroupFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QTextBlockGroup) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextBlockGroup::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextBlockGroup_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextBlockGroup) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextBlockGroup::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextBlockGroup_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextBlockGroup) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QTextBlockGroup::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTextBlockGroup) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTextBlockGroup::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTextBlockGroupChildEvent
func callbackQTextBlockGroupChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextBlockGroup::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQTextBlockGroupFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QTextBlockGroup) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextBlockGroup::childEvent")

	if ptr.Pointer() != nil {
		C.QTextBlockGroup_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextBlockGroup) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextBlockGroup::childEvent")

	if ptr.Pointer() != nil {
		C.QTextBlockGroup_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextBlockGroup) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QTextBlockGroup::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTextBlockGroup) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTextBlockGroup::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTextBlockGroupCustomEvent
func callbackQTextBlockGroupCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextBlockGroup::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQTextBlockGroupFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QTextBlockGroup) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QTextBlockGroup::customEvent")

	if ptr.Pointer() != nil {
		C.QTextBlockGroup_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QTextBlockGroup) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QTextBlockGroup::customEvent")

	if ptr.Pointer() != nil {
		C.QTextBlockGroup_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QTextBlockUserData struct {
	ptr unsafe.Pointer
}

type QTextBlockUserData_ITF interface {
	QTextBlockUserData_PTR() *QTextBlockUserData
}

func (p *QTextBlockUserData) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextBlockUserData) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextBlockUserData(ptr QTextBlockUserData_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextBlockUserData_PTR().Pointer()
	}
	return nil
}

func NewQTextBlockUserDataFromPointer(ptr unsafe.Pointer) *QTextBlockUserData {
	var n = new(QTextBlockUserData)
	n.SetPointer(ptr)
	return n
}

func newQTextBlockUserDataFromPointer(ptr unsafe.Pointer) *QTextBlockUserData {
	var n = NewQTextBlockUserDataFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QTextBlockUserData_") {
		n.SetObjectNameAbs("QTextBlockUserData_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextBlockUserData) QTextBlockUserData_PTR() *QTextBlockUserData {
	return ptr
}

func (ptr *QTextBlockUserData) DestroyQTextBlockUserData() {
	defer qt.Recovering("QTextBlockUserData::~QTextBlockUserData")

	if ptr.Pointer() != nil {
		C.QTextBlockUserData_DestroyQTextBlockUserData(ptr.Pointer())
	}
}

func (ptr *QTextBlockUserData) ObjectNameAbs() string {
	defer qt.Recovering("QTextBlockUserData::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextBlockUserData_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextBlockUserData) SetObjectNameAbs(name string) {
	defer qt.Recovering("QTextBlockUserData::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QTextBlockUserData_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QTextCharFormat struct {
	QTextFormat
}

type QTextCharFormat_ITF interface {
	QTextFormat_ITF
	QTextCharFormat_PTR() *QTextCharFormat
}

func PointerFromQTextCharFormat(ptr QTextCharFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextCharFormat_PTR().Pointer()
	}
	return nil
}

func NewQTextCharFormatFromPointer(ptr unsafe.Pointer) *QTextCharFormat {
	var n = new(QTextCharFormat)
	n.SetPointer(ptr)
	return n
}

func newQTextCharFormatFromPointer(ptr unsafe.Pointer) *QTextCharFormat {
	var n = NewQTextCharFormatFromPointer(ptr)
	return n
}

func (ptr *QTextCharFormat) QTextCharFormat_PTR() *QTextCharFormat {
	return ptr
}

//QTextCharFormat::FontPropertiesInheritanceBehavior
type QTextCharFormat__FontPropertiesInheritanceBehavior int64

const (
	QTextCharFormat__FontPropertiesSpecifiedOnly = QTextCharFormat__FontPropertiesInheritanceBehavior(0)
	QTextCharFormat__FontPropertiesAll           = QTextCharFormat__FontPropertiesInheritanceBehavior(1)
)

//QTextCharFormat::UnderlineStyle
type QTextCharFormat__UnderlineStyle int64

var (
	QTextCharFormat__NoUnderline         = QTextCharFormat__UnderlineStyle(0)
	QTextCharFormat__SingleUnderline     = QTextCharFormat__UnderlineStyle(1)
	QTextCharFormat__DashUnderline       = QTextCharFormat__UnderlineStyle(2)
	QTextCharFormat__DotLine             = QTextCharFormat__UnderlineStyle(3)
	QTextCharFormat__DashDotLine         = QTextCharFormat__UnderlineStyle(4)
	QTextCharFormat__DashDotDotLine      = QTextCharFormat__UnderlineStyle(5)
	QTextCharFormat__WaveUnderline       = QTextCharFormat__UnderlineStyle(6)
	QTextCharFormat__SpellCheckUnderline = QTextCharFormat__UnderlineStyle(7)
)

//QTextCharFormat::VerticalAlignment
type QTextCharFormat__VerticalAlignment int64

const (
	QTextCharFormat__AlignNormal      = QTextCharFormat__VerticalAlignment(0)
	QTextCharFormat__AlignSuperScript = QTextCharFormat__VerticalAlignment(1)
	QTextCharFormat__AlignSubScript   = QTextCharFormat__VerticalAlignment(2)
	QTextCharFormat__AlignMiddle      = QTextCharFormat__VerticalAlignment(3)
	QTextCharFormat__AlignTop         = QTextCharFormat__VerticalAlignment(4)
	QTextCharFormat__AlignBottom      = QTextCharFormat__VerticalAlignment(5)
	QTextCharFormat__AlignBaseline    = QTextCharFormat__VerticalAlignment(6)
)

func NewQTextCharFormat() *QTextCharFormat {
	defer qt.Recovering("QTextCharFormat::QTextCharFormat")

	return newQTextCharFormatFromPointer(C.QTextCharFormat_NewQTextCharFormat())
}

func (ptr *QTextCharFormat) AnchorNames() []string {
	defer qt.Recovering("QTextCharFormat::anchorNames")

	if ptr.Pointer() != nil {
		return strings.Split(C.GoString(C.QTextCharFormat_AnchorNames(ptr.Pointer())), "|")
	}
	return make([]string, 0)
}

func (ptr *QTextCharFormat) FontUnderline() bool {
	defer qt.Recovering("QTextCharFormat::fontUnderline")

	if ptr.Pointer() != nil {
		return C.QTextCharFormat_FontUnderline(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCharFormat) SetUnderlineStyle(style QTextCharFormat__UnderlineStyle) {
	defer qt.Recovering("QTextCharFormat::setUnderlineStyle")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetUnderlineStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QTextCharFormat) AnchorHref() string {
	defer qt.Recovering("QTextCharFormat::anchorHref")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextCharFormat_AnchorHref(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextCharFormat) FontCapitalization() QFont__Capitalization {
	defer qt.Recovering("QTextCharFormat::fontCapitalization")

	if ptr.Pointer() != nil {
		return QFont__Capitalization(C.QTextCharFormat_FontCapitalization(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) FontFamily() string {
	defer qt.Recovering("QTextCharFormat::fontFamily")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextCharFormat_FontFamily(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextCharFormat) FontFixedPitch() bool {
	defer qt.Recovering("QTextCharFormat::fontFixedPitch")

	if ptr.Pointer() != nil {
		return C.QTextCharFormat_FontFixedPitch(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCharFormat) FontHintingPreference() QFont__HintingPreference {
	defer qt.Recovering("QTextCharFormat::fontHintingPreference")

	if ptr.Pointer() != nil {
		return QFont__HintingPreference(C.QTextCharFormat_FontHintingPreference(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) FontItalic() bool {
	defer qt.Recovering("QTextCharFormat::fontItalic")

	if ptr.Pointer() != nil {
		return C.QTextCharFormat_FontItalic(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCharFormat) FontKerning() bool {
	defer qt.Recovering("QTextCharFormat::fontKerning")

	if ptr.Pointer() != nil {
		return C.QTextCharFormat_FontKerning(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCharFormat) FontLetterSpacing() float64 {
	defer qt.Recovering("QTextCharFormat::fontLetterSpacing")

	if ptr.Pointer() != nil {
		return float64(C.QTextCharFormat_FontLetterSpacing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) FontLetterSpacingType() QFont__SpacingType {
	defer qt.Recovering("QTextCharFormat::fontLetterSpacingType")

	if ptr.Pointer() != nil {
		return QFont__SpacingType(C.QTextCharFormat_FontLetterSpacingType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) FontOverline() bool {
	defer qt.Recovering("QTextCharFormat::fontOverline")

	if ptr.Pointer() != nil {
		return C.QTextCharFormat_FontOverline(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCharFormat) FontPointSize() float64 {
	defer qt.Recovering("QTextCharFormat::fontPointSize")

	if ptr.Pointer() != nil {
		return float64(C.QTextCharFormat_FontPointSize(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) FontStretch() int {
	defer qt.Recovering("QTextCharFormat::fontStretch")

	if ptr.Pointer() != nil {
		return int(C.QTextCharFormat_FontStretch(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) FontStrikeOut() bool {
	defer qt.Recovering("QTextCharFormat::fontStrikeOut")

	if ptr.Pointer() != nil {
		return C.QTextCharFormat_FontStrikeOut(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCharFormat) FontStyleHint() QFont__StyleHint {
	defer qt.Recovering("QTextCharFormat::fontStyleHint")

	if ptr.Pointer() != nil {
		return QFont__StyleHint(C.QTextCharFormat_FontStyleHint(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) FontStyleStrategy() QFont__StyleStrategy {
	defer qt.Recovering("QTextCharFormat::fontStyleStrategy")

	if ptr.Pointer() != nil {
		return QFont__StyleStrategy(C.QTextCharFormat_FontStyleStrategy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) FontWeight() int {
	defer qt.Recovering("QTextCharFormat::fontWeight")

	if ptr.Pointer() != nil {
		return int(C.QTextCharFormat_FontWeight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) FontWordSpacing() float64 {
	defer qt.Recovering("QTextCharFormat::fontWordSpacing")

	if ptr.Pointer() != nil {
		return float64(C.QTextCharFormat_FontWordSpacing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) IsAnchor() bool {
	defer qt.Recovering("QTextCharFormat::isAnchor")

	if ptr.Pointer() != nil {
		return C.QTextCharFormat_IsAnchor(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCharFormat) IsValid() bool {
	defer qt.Recovering("QTextCharFormat::isValid")

	if ptr.Pointer() != nil {
		return C.QTextCharFormat_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCharFormat) SetAnchor(anchor bool) {
	defer qt.Recovering("QTextCharFormat::setAnchor")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetAnchor(ptr.Pointer(), C.int(qt.GoBoolToInt(anchor)))
	}
}

func (ptr *QTextCharFormat) SetAnchorHref(value string) {
	defer qt.Recovering("QTextCharFormat::setAnchorHref")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetAnchorHref(ptr.Pointer(), C.CString(value))
	}
}

func (ptr *QTextCharFormat) SetAnchorNames(names []string) {
	defer qt.Recovering("QTextCharFormat::setAnchorNames")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetAnchorNames(ptr.Pointer(), C.CString(strings.Join(names, "|")))
	}
}

func (ptr *QTextCharFormat) SetFont2(font QFont_ITF) {
	defer qt.Recovering("QTextCharFormat::setFont")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFont2(ptr.Pointer(), PointerFromQFont(font))
	}
}

func (ptr *QTextCharFormat) SetFont(font QFont_ITF, behavior QTextCharFormat__FontPropertiesInheritanceBehavior) {
	defer qt.Recovering("QTextCharFormat::setFont")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFont(ptr.Pointer(), PointerFromQFont(font), C.int(behavior))
	}
}

func (ptr *QTextCharFormat) SetFontCapitalization(capitalization QFont__Capitalization) {
	defer qt.Recovering("QTextCharFormat::setFontCapitalization")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontCapitalization(ptr.Pointer(), C.int(capitalization))
	}
}

func (ptr *QTextCharFormat) SetFontFamily(family string) {
	defer qt.Recovering("QTextCharFormat::setFontFamily")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontFamily(ptr.Pointer(), C.CString(family))
	}
}

func (ptr *QTextCharFormat) SetFontFixedPitch(fixedPitch bool) {
	defer qt.Recovering("QTextCharFormat::setFontFixedPitch")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontFixedPitch(ptr.Pointer(), C.int(qt.GoBoolToInt(fixedPitch)))
	}
}

func (ptr *QTextCharFormat) SetFontHintingPreference(hintingPreference QFont__HintingPreference) {
	defer qt.Recovering("QTextCharFormat::setFontHintingPreference")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontHintingPreference(ptr.Pointer(), C.int(hintingPreference))
	}
}

func (ptr *QTextCharFormat) SetFontItalic(italic bool) {
	defer qt.Recovering("QTextCharFormat::setFontItalic")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontItalic(ptr.Pointer(), C.int(qt.GoBoolToInt(italic)))
	}
}

func (ptr *QTextCharFormat) SetFontKerning(enable bool) {
	defer qt.Recovering("QTextCharFormat::setFontKerning")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontKerning(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QTextCharFormat) SetFontLetterSpacing(spacing float64) {
	defer qt.Recovering("QTextCharFormat::setFontLetterSpacing")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontLetterSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QTextCharFormat) SetFontLetterSpacingType(letterSpacingType QFont__SpacingType) {
	defer qt.Recovering("QTextCharFormat::setFontLetterSpacingType")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontLetterSpacingType(ptr.Pointer(), C.int(letterSpacingType))
	}
}

func (ptr *QTextCharFormat) SetFontOverline(overline bool) {
	defer qt.Recovering("QTextCharFormat::setFontOverline")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontOverline(ptr.Pointer(), C.int(qt.GoBoolToInt(overline)))
	}
}

func (ptr *QTextCharFormat) SetFontPointSize(size float64) {
	defer qt.Recovering("QTextCharFormat::setFontPointSize")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontPointSize(ptr.Pointer(), C.double(size))
	}
}

func (ptr *QTextCharFormat) SetFontStretch(factor int) {
	defer qt.Recovering("QTextCharFormat::setFontStretch")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontStretch(ptr.Pointer(), C.int(factor))
	}
}

func (ptr *QTextCharFormat) SetFontStrikeOut(strikeOut bool) {
	defer qt.Recovering("QTextCharFormat::setFontStrikeOut")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontStrikeOut(ptr.Pointer(), C.int(qt.GoBoolToInt(strikeOut)))
	}
}

func (ptr *QTextCharFormat) SetFontStyleHint(hint QFont__StyleHint, strategy QFont__StyleStrategy) {
	defer qt.Recovering("QTextCharFormat::setFontStyleHint")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontStyleHint(ptr.Pointer(), C.int(hint), C.int(strategy))
	}
}

func (ptr *QTextCharFormat) SetFontStyleStrategy(strategy QFont__StyleStrategy) {
	defer qt.Recovering("QTextCharFormat::setFontStyleStrategy")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontStyleStrategy(ptr.Pointer(), C.int(strategy))
	}
}

func (ptr *QTextCharFormat) SetFontUnderline(underline bool) {
	defer qt.Recovering("QTextCharFormat::setFontUnderline")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontUnderline(ptr.Pointer(), C.int(qt.GoBoolToInt(underline)))
	}
}

func (ptr *QTextCharFormat) SetFontWeight(weight int) {
	defer qt.Recovering("QTextCharFormat::setFontWeight")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontWeight(ptr.Pointer(), C.int(weight))
	}
}

func (ptr *QTextCharFormat) SetFontWordSpacing(spacing float64) {
	defer qt.Recovering("QTextCharFormat::setFontWordSpacing")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetFontWordSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QTextCharFormat) SetTextOutline(pen QPen_ITF) {
	defer qt.Recovering("QTextCharFormat::setTextOutline")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetTextOutline(ptr.Pointer(), PointerFromQPen(pen))
	}
}

func (ptr *QTextCharFormat) SetToolTip(text string) {
	defer qt.Recovering("QTextCharFormat::setToolTip")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetToolTip(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QTextCharFormat) SetUnderlineColor(color QColor_ITF) {
	defer qt.Recovering("QTextCharFormat::setUnderlineColor")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetUnderlineColor(ptr.Pointer(), PointerFromQColor(color))
	}
}

func (ptr *QTextCharFormat) SetVerticalAlignment(alignment QTextCharFormat__VerticalAlignment) {
	defer qt.Recovering("QTextCharFormat::setVerticalAlignment")

	if ptr.Pointer() != nil {
		C.QTextCharFormat_SetVerticalAlignment(ptr.Pointer(), C.int(alignment))
	}
}

func (ptr *QTextCharFormat) ToolTip() string {
	defer qt.Recovering("QTextCharFormat::toolTip")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextCharFormat_ToolTip(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextCharFormat) UnderlineColor() *QColor {
	defer qt.Recovering("QTextCharFormat::underlineColor")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QTextCharFormat_UnderlineColor(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextCharFormat) UnderlineStyle() QTextCharFormat__UnderlineStyle {
	defer qt.Recovering("QTextCharFormat::underlineStyle")

	if ptr.Pointer() != nil {
		return QTextCharFormat__UnderlineStyle(C.QTextCharFormat_UnderlineStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCharFormat) VerticalAlignment() QTextCharFormat__VerticalAlignment {
	defer qt.Recovering("QTextCharFormat::verticalAlignment")

	if ptr.Pointer() != nil {
		return QTextCharFormat__VerticalAlignment(C.QTextCharFormat_VerticalAlignment(ptr.Pointer()))
	}
	return 0
}

type QTextCursor struct {
	ptr unsafe.Pointer
}

type QTextCursor_ITF interface {
	QTextCursor_PTR() *QTextCursor
}

func (p *QTextCursor) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextCursor) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextCursor(ptr QTextCursor_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextCursor_PTR().Pointer()
	}
	return nil
}

func NewQTextCursorFromPointer(ptr unsafe.Pointer) *QTextCursor {
	var n = new(QTextCursor)
	n.SetPointer(ptr)
	return n
}

func newQTextCursorFromPointer(ptr unsafe.Pointer) *QTextCursor {
	var n = NewQTextCursorFromPointer(ptr)
	return n
}

func (ptr *QTextCursor) QTextCursor_PTR() *QTextCursor {
	return ptr
}

//QTextCursor::MoveMode
type QTextCursor__MoveMode int64

const (
	QTextCursor__MoveAnchor = QTextCursor__MoveMode(0)
	QTextCursor__KeepAnchor = QTextCursor__MoveMode(1)
)

//QTextCursor::MoveOperation
type QTextCursor__MoveOperation int64

const (
	QTextCursor__NoMove            = QTextCursor__MoveOperation(0)
	QTextCursor__Start             = QTextCursor__MoveOperation(1)
	QTextCursor__Up                = QTextCursor__MoveOperation(2)
	QTextCursor__StartOfLine       = QTextCursor__MoveOperation(3)
	QTextCursor__StartOfBlock      = QTextCursor__MoveOperation(4)
	QTextCursor__StartOfWord       = QTextCursor__MoveOperation(5)
	QTextCursor__PreviousBlock     = QTextCursor__MoveOperation(6)
	QTextCursor__PreviousCharacter = QTextCursor__MoveOperation(7)
	QTextCursor__PreviousWord      = QTextCursor__MoveOperation(8)
	QTextCursor__Left              = QTextCursor__MoveOperation(9)
	QTextCursor__WordLeft          = QTextCursor__MoveOperation(10)
	QTextCursor__End               = QTextCursor__MoveOperation(11)
	QTextCursor__Down              = QTextCursor__MoveOperation(12)
	QTextCursor__EndOfLine         = QTextCursor__MoveOperation(13)
	QTextCursor__EndOfWord         = QTextCursor__MoveOperation(14)
	QTextCursor__EndOfBlock        = QTextCursor__MoveOperation(15)
	QTextCursor__NextBlock         = QTextCursor__MoveOperation(16)
	QTextCursor__NextCharacter     = QTextCursor__MoveOperation(17)
	QTextCursor__NextWord          = QTextCursor__MoveOperation(18)
	QTextCursor__Right             = QTextCursor__MoveOperation(19)
	QTextCursor__WordRight         = QTextCursor__MoveOperation(20)
	QTextCursor__NextCell          = QTextCursor__MoveOperation(21)
	QTextCursor__PreviousCell      = QTextCursor__MoveOperation(22)
	QTextCursor__NextRow           = QTextCursor__MoveOperation(23)
	QTextCursor__PreviousRow       = QTextCursor__MoveOperation(24)
)

//QTextCursor::SelectionType
type QTextCursor__SelectionType int64

const (
	QTextCursor__WordUnderCursor  = QTextCursor__SelectionType(0)
	QTextCursor__LineUnderCursor  = QTextCursor__SelectionType(1)
	QTextCursor__BlockUnderCursor = QTextCursor__SelectionType(2)
	QTextCursor__Document         = QTextCursor__SelectionType(3)
)

func (ptr *QTextCursor) InsertBlock3(format QTextBlockFormat_ITF, charFormat QTextCharFormat_ITF) {
	defer qt.Recovering("QTextCursor::insertBlock")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertBlock3(ptr.Pointer(), PointerFromQTextBlockFormat(format), PointerFromQTextCharFormat(charFormat))
	}
}

func (ptr *QTextCursor) InsertTable2(rows int, columns int) *QTextTable {
	defer qt.Recovering("QTextCursor::insertTable")

	if ptr.Pointer() != nil {
		return NewQTextTableFromPointer(C.QTextCursor_InsertTable2(ptr.Pointer(), C.int(rows), C.int(columns)))
	}
	return nil
}

func (ptr *QTextCursor) InsertTable(rows int, columns int, format QTextTableFormat_ITF) *QTextTable {
	defer qt.Recovering("QTextCursor::insertTable")

	if ptr.Pointer() != nil {
		return NewQTextTableFromPointer(C.QTextCursor_InsertTable(ptr.Pointer(), C.int(rows), C.int(columns), PointerFromQTextTableFormat(format)))
	}
	return nil
}

func (ptr *QTextCursor) InsertText2(text string, format QTextCharFormat_ITF) {
	defer qt.Recovering("QTextCursor::insertText")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertText2(ptr.Pointer(), C.CString(text), PointerFromQTextCharFormat(format))
	}
}

func (ptr *QTextCursor) MovePosition(operation QTextCursor__MoveOperation, mode QTextCursor__MoveMode, n int) bool {
	defer qt.Recovering("QTextCursor::movePosition")

	if ptr.Pointer() != nil {
		return C.QTextCursor_MovePosition(ptr.Pointer(), C.int(operation), C.int(mode), C.int(n)) != 0
	}
	return false
}

func NewQTextCursor() *QTextCursor {
	defer qt.Recovering("QTextCursor::QTextCursor")

	return newQTextCursorFromPointer(C.QTextCursor_NewQTextCursor())
}

func NewQTextCursor2(document QTextDocument_ITF) *QTextCursor {
	defer qt.Recovering("QTextCursor::QTextCursor")

	return newQTextCursorFromPointer(C.QTextCursor_NewQTextCursor2(PointerFromQTextDocument(document)))
}

func NewQTextCursor4(frame QTextFrame_ITF) *QTextCursor {
	defer qt.Recovering("QTextCursor::QTextCursor")

	return newQTextCursorFromPointer(C.QTextCursor_NewQTextCursor4(PointerFromQTextFrame(frame)))
}

func NewQTextCursor5(block QTextBlock_ITF) *QTextCursor {
	defer qt.Recovering("QTextCursor::QTextCursor")

	return newQTextCursorFromPointer(C.QTextCursor_NewQTextCursor5(PointerFromQTextBlock(block)))
}

func NewQTextCursor7(cursor QTextCursor_ITF) *QTextCursor {
	defer qt.Recovering("QTextCursor::QTextCursor")

	return newQTextCursorFromPointer(C.QTextCursor_NewQTextCursor7(PointerFromQTextCursor(cursor)))
}

func (ptr *QTextCursor) Anchor() int {
	defer qt.Recovering("QTextCursor::anchor")

	if ptr.Pointer() != nil {
		return int(C.QTextCursor_Anchor(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCursor) AtBlockEnd() bool {
	defer qt.Recovering("QTextCursor::atBlockEnd")

	if ptr.Pointer() != nil {
		return C.QTextCursor_AtBlockEnd(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCursor) AtBlockStart() bool {
	defer qt.Recovering("QTextCursor::atBlockStart")

	if ptr.Pointer() != nil {
		return C.QTextCursor_AtBlockStart(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCursor) AtEnd() bool {
	defer qt.Recovering("QTextCursor::atEnd")

	if ptr.Pointer() != nil {
		return C.QTextCursor_AtEnd(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCursor) AtStart() bool {
	defer qt.Recovering("QTextCursor::atStart")

	if ptr.Pointer() != nil {
		return C.QTextCursor_AtStart(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCursor) BeginEditBlock() {
	defer qt.Recovering("QTextCursor::beginEditBlock")

	if ptr.Pointer() != nil {
		C.QTextCursor_BeginEditBlock(ptr.Pointer())
	}
}

func (ptr *QTextCursor) BlockNumber() int {
	defer qt.Recovering("QTextCursor::blockNumber")

	if ptr.Pointer() != nil {
		return int(C.QTextCursor_BlockNumber(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCursor) ClearSelection() {
	defer qt.Recovering("QTextCursor::clearSelection")

	if ptr.Pointer() != nil {
		C.QTextCursor_ClearSelection(ptr.Pointer())
	}
}

func (ptr *QTextCursor) ColumnNumber() int {
	defer qt.Recovering("QTextCursor::columnNumber")

	if ptr.Pointer() != nil {
		return int(C.QTextCursor_ColumnNumber(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCursor) CreateList2(style QTextListFormat__Style) *QTextList {
	defer qt.Recovering("QTextCursor::createList")

	if ptr.Pointer() != nil {
		return NewQTextListFromPointer(C.QTextCursor_CreateList2(ptr.Pointer(), C.int(style)))
	}
	return nil
}

func (ptr *QTextCursor) CreateList(format QTextListFormat_ITF) *QTextList {
	defer qt.Recovering("QTextCursor::createList")

	if ptr.Pointer() != nil {
		return NewQTextListFromPointer(C.QTextCursor_CreateList(ptr.Pointer(), PointerFromQTextListFormat(format)))
	}
	return nil
}

func (ptr *QTextCursor) CurrentFrame() *QTextFrame {
	defer qt.Recovering("QTextCursor::currentFrame")

	if ptr.Pointer() != nil {
		return NewQTextFrameFromPointer(C.QTextCursor_CurrentFrame(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextCursor) CurrentList() *QTextList {
	defer qt.Recovering("QTextCursor::currentList")

	if ptr.Pointer() != nil {
		return NewQTextListFromPointer(C.QTextCursor_CurrentList(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextCursor) CurrentTable() *QTextTable {
	defer qt.Recovering("QTextCursor::currentTable")

	if ptr.Pointer() != nil {
		return NewQTextTableFromPointer(C.QTextCursor_CurrentTable(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextCursor) DeleteChar() {
	defer qt.Recovering("QTextCursor::deleteChar")

	if ptr.Pointer() != nil {
		C.QTextCursor_DeleteChar(ptr.Pointer())
	}
}

func (ptr *QTextCursor) DeletePreviousChar() {
	defer qt.Recovering("QTextCursor::deletePreviousChar")

	if ptr.Pointer() != nil {
		C.QTextCursor_DeletePreviousChar(ptr.Pointer())
	}
}

func (ptr *QTextCursor) Document() *QTextDocument {
	defer qt.Recovering("QTextCursor::document")

	if ptr.Pointer() != nil {
		return NewQTextDocumentFromPointer(C.QTextCursor_Document(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextCursor) EndEditBlock() {
	defer qt.Recovering("QTextCursor::endEditBlock")

	if ptr.Pointer() != nil {
		C.QTextCursor_EndEditBlock(ptr.Pointer())
	}
}

func (ptr *QTextCursor) HasComplexSelection() bool {
	defer qt.Recovering("QTextCursor::hasComplexSelection")

	if ptr.Pointer() != nil {
		return C.QTextCursor_HasComplexSelection(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCursor) HasSelection() bool {
	defer qt.Recovering("QTextCursor::hasSelection")

	if ptr.Pointer() != nil {
		return C.QTextCursor_HasSelection(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCursor) InsertBlock() {
	defer qt.Recovering("QTextCursor::insertBlock")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertBlock(ptr.Pointer())
	}
}

func (ptr *QTextCursor) InsertBlock2(format QTextBlockFormat_ITF) {
	defer qt.Recovering("QTextCursor::insertBlock")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertBlock2(ptr.Pointer(), PointerFromQTextBlockFormat(format))
	}
}

func (ptr *QTextCursor) InsertFragment(fragment QTextDocumentFragment_ITF) {
	defer qt.Recovering("QTextCursor::insertFragment")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertFragment(ptr.Pointer(), PointerFromQTextDocumentFragment(fragment))
	}
}

func (ptr *QTextCursor) InsertFrame(format QTextFrameFormat_ITF) *QTextFrame {
	defer qt.Recovering("QTextCursor::insertFrame")

	if ptr.Pointer() != nil {
		return NewQTextFrameFromPointer(C.QTextCursor_InsertFrame(ptr.Pointer(), PointerFromQTextFrameFormat(format)))
	}
	return nil
}

func (ptr *QTextCursor) InsertHtml(html string) {
	defer qt.Recovering("QTextCursor::insertHtml")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertHtml(ptr.Pointer(), C.CString(html))
	}
}

func (ptr *QTextCursor) InsertImage4(image QImage_ITF, name string) {
	defer qt.Recovering("QTextCursor::insertImage")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertImage4(ptr.Pointer(), PointerFromQImage(image), C.CString(name))
	}
}

func (ptr *QTextCursor) InsertImage3(name string) {
	defer qt.Recovering("QTextCursor::insertImage")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertImage3(ptr.Pointer(), C.CString(name))
	}
}

func (ptr *QTextCursor) InsertImage(format QTextImageFormat_ITF) {
	defer qt.Recovering("QTextCursor::insertImage")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertImage(ptr.Pointer(), PointerFromQTextImageFormat(format))
	}
}

func (ptr *QTextCursor) InsertImage2(format QTextImageFormat_ITF, alignment QTextFrameFormat__Position) {
	defer qt.Recovering("QTextCursor::insertImage")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertImage2(ptr.Pointer(), PointerFromQTextImageFormat(format), C.int(alignment))
	}
}

func (ptr *QTextCursor) InsertList2(style QTextListFormat__Style) *QTextList {
	defer qt.Recovering("QTextCursor::insertList")

	if ptr.Pointer() != nil {
		return NewQTextListFromPointer(C.QTextCursor_InsertList2(ptr.Pointer(), C.int(style)))
	}
	return nil
}

func (ptr *QTextCursor) InsertList(format QTextListFormat_ITF) *QTextList {
	defer qt.Recovering("QTextCursor::insertList")

	if ptr.Pointer() != nil {
		return NewQTextListFromPointer(C.QTextCursor_InsertList(ptr.Pointer(), PointerFromQTextListFormat(format)))
	}
	return nil
}

func (ptr *QTextCursor) InsertText(text string) {
	defer qt.Recovering("QTextCursor::insertText")

	if ptr.Pointer() != nil {
		C.QTextCursor_InsertText(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QTextCursor) IsCopyOf(other QTextCursor_ITF) bool {
	defer qt.Recovering("QTextCursor::isCopyOf")

	if ptr.Pointer() != nil {
		return C.QTextCursor_IsCopyOf(ptr.Pointer(), PointerFromQTextCursor(other)) != 0
	}
	return false
}

func (ptr *QTextCursor) IsNull() bool {
	defer qt.Recovering("QTextCursor::isNull")

	if ptr.Pointer() != nil {
		return C.QTextCursor_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCursor) JoinPreviousEditBlock() {
	defer qt.Recovering("QTextCursor::joinPreviousEditBlock")

	if ptr.Pointer() != nil {
		C.QTextCursor_JoinPreviousEditBlock(ptr.Pointer())
	}
}

func (ptr *QTextCursor) KeepPositionOnInsert() bool {
	defer qt.Recovering("QTextCursor::keepPositionOnInsert")

	if ptr.Pointer() != nil {
		return C.QTextCursor_KeepPositionOnInsert(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCursor) MergeBlockCharFormat(modifier QTextCharFormat_ITF) {
	defer qt.Recovering("QTextCursor::mergeBlockCharFormat")

	if ptr.Pointer() != nil {
		C.QTextCursor_MergeBlockCharFormat(ptr.Pointer(), PointerFromQTextCharFormat(modifier))
	}
}

func (ptr *QTextCursor) MergeBlockFormat(modifier QTextBlockFormat_ITF) {
	defer qt.Recovering("QTextCursor::mergeBlockFormat")

	if ptr.Pointer() != nil {
		C.QTextCursor_MergeBlockFormat(ptr.Pointer(), PointerFromQTextBlockFormat(modifier))
	}
}

func (ptr *QTextCursor) MergeCharFormat(modifier QTextCharFormat_ITF) {
	defer qt.Recovering("QTextCursor::mergeCharFormat")

	if ptr.Pointer() != nil {
		C.QTextCursor_MergeCharFormat(ptr.Pointer(), PointerFromQTextCharFormat(modifier))
	}
}

func (ptr *QTextCursor) Position() int {
	defer qt.Recovering("QTextCursor::position")

	if ptr.Pointer() != nil {
		return int(C.QTextCursor_Position(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCursor) PositionInBlock() int {
	defer qt.Recovering("QTextCursor::positionInBlock")

	if ptr.Pointer() != nil {
		return int(C.QTextCursor_PositionInBlock(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCursor) RemoveSelectedText() {
	defer qt.Recovering("QTextCursor::removeSelectedText")

	if ptr.Pointer() != nil {
		C.QTextCursor_RemoveSelectedText(ptr.Pointer())
	}
}

func (ptr *QTextCursor) Select(selection QTextCursor__SelectionType) {
	defer qt.Recovering("QTextCursor::select")

	if ptr.Pointer() != nil {
		C.QTextCursor_Select(ptr.Pointer(), C.int(selection))
	}
}

func (ptr *QTextCursor) SelectedTableCells(firstRow int, numRows int, firstColumn int, numColumns int) {
	defer qt.Recovering("QTextCursor::selectedTableCells")

	if ptr.Pointer() != nil {
		C.QTextCursor_SelectedTableCells(ptr.Pointer(), C.int(firstRow), C.int(numRows), C.int(firstColumn), C.int(numColumns))
	}
}

func (ptr *QTextCursor) SelectedText() string {
	defer qt.Recovering("QTextCursor::selectedText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextCursor_SelectedText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextCursor) SelectionEnd() int {
	defer qt.Recovering("QTextCursor::selectionEnd")

	if ptr.Pointer() != nil {
		return int(C.QTextCursor_SelectionEnd(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCursor) SelectionStart() int {
	defer qt.Recovering("QTextCursor::selectionStart")

	if ptr.Pointer() != nil {
		return int(C.QTextCursor_SelectionStart(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCursor) SetBlockCharFormat(format QTextCharFormat_ITF) {
	defer qt.Recovering("QTextCursor::setBlockCharFormat")

	if ptr.Pointer() != nil {
		C.QTextCursor_SetBlockCharFormat(ptr.Pointer(), PointerFromQTextCharFormat(format))
	}
}

func (ptr *QTextCursor) SetBlockFormat(format QTextBlockFormat_ITF) {
	defer qt.Recovering("QTextCursor::setBlockFormat")

	if ptr.Pointer() != nil {
		C.QTextCursor_SetBlockFormat(ptr.Pointer(), PointerFromQTextBlockFormat(format))
	}
}

func (ptr *QTextCursor) SetCharFormat(format QTextCharFormat_ITF) {
	defer qt.Recovering("QTextCursor::setCharFormat")

	if ptr.Pointer() != nil {
		C.QTextCursor_SetCharFormat(ptr.Pointer(), PointerFromQTextCharFormat(format))
	}
}

func (ptr *QTextCursor) SetKeepPositionOnInsert(b bool) {
	defer qt.Recovering("QTextCursor::setKeepPositionOnInsert")

	if ptr.Pointer() != nil {
		C.QTextCursor_SetKeepPositionOnInsert(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
	}
}

func (ptr *QTextCursor) SetPosition(pos int, m QTextCursor__MoveMode) {
	defer qt.Recovering("QTextCursor::setPosition")

	if ptr.Pointer() != nil {
		C.QTextCursor_SetPosition(ptr.Pointer(), C.int(pos), C.int(m))
	}
}

func (ptr *QTextCursor) SetVerticalMovementX(x int) {
	defer qt.Recovering("QTextCursor::setVerticalMovementX")

	if ptr.Pointer() != nil {
		C.QTextCursor_SetVerticalMovementX(ptr.Pointer(), C.int(x))
	}
}

func (ptr *QTextCursor) SetVisualNavigation(b bool) {
	defer qt.Recovering("QTextCursor::setVisualNavigation")

	if ptr.Pointer() != nil {
		C.QTextCursor_SetVisualNavigation(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
	}
}

func (ptr *QTextCursor) Swap(other QTextCursor_ITF) {
	defer qt.Recovering("QTextCursor::swap")

	if ptr.Pointer() != nil {
		C.QTextCursor_Swap(ptr.Pointer(), PointerFromQTextCursor(other))
	}
}

func (ptr *QTextCursor) VerticalMovementX() int {
	defer qt.Recovering("QTextCursor::verticalMovementX")

	if ptr.Pointer() != nil {
		return int(C.QTextCursor_VerticalMovementX(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextCursor) VisualNavigation() bool {
	defer qt.Recovering("QTextCursor::visualNavigation")

	if ptr.Pointer() != nil {
		return C.QTextCursor_VisualNavigation(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextCursor) DestroyQTextCursor() {
	defer qt.Recovering("QTextCursor::~QTextCursor")

	if ptr.Pointer() != nil {
		C.QTextCursor_DestroyQTextCursor(ptr.Pointer())
	}
}

type QTextDocument struct {
	core.QObject
}

type QTextDocument_ITF interface {
	core.QObject_ITF
	QTextDocument_PTR() *QTextDocument
}

func PointerFromQTextDocument(ptr QTextDocument_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextDocument_PTR().Pointer()
	}
	return nil
}

func NewQTextDocumentFromPointer(ptr unsafe.Pointer) *QTextDocument {
	var n = new(QTextDocument)
	n.SetPointer(ptr)
	return n
}

func newQTextDocumentFromPointer(ptr unsafe.Pointer) *QTextDocument {
	var n = NewQTextDocumentFromPointer(ptr)
	for len(n.ObjectName()) < len("QTextDocument_") {
		n.SetObjectName("QTextDocument_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextDocument) QTextDocument_PTR() *QTextDocument {
	return ptr
}

//QTextDocument::FindFlag
type QTextDocument__FindFlag int64

const (
	QTextDocument__FindBackward        = QTextDocument__FindFlag(0x00001)
	QTextDocument__FindCaseSensitively = QTextDocument__FindFlag(0x00002)
	QTextDocument__FindWholeWords      = QTextDocument__FindFlag(0x00004)
)

//QTextDocument::MetaInformation
type QTextDocument__MetaInformation int64

const (
	QTextDocument__DocumentTitle = QTextDocument__MetaInformation(0)
	QTextDocument__DocumentUrl   = QTextDocument__MetaInformation(1)
)

//QTextDocument::ResourceType
type QTextDocument__ResourceType int64

const (
	QTextDocument__HtmlResource       = QTextDocument__ResourceType(1)
	QTextDocument__ImageResource      = QTextDocument__ResourceType(2)
	QTextDocument__StyleSheetResource = QTextDocument__ResourceType(3)
	QTextDocument__UserResource       = QTextDocument__ResourceType(100)
)

//QTextDocument::Stacks
type QTextDocument__Stacks int64

const (
	QTextDocument__UndoStack         = QTextDocument__Stacks(0x01)
	QTextDocument__RedoStack         = QTextDocument__Stacks(0x02)
	QTextDocument__UndoAndRedoStacks = QTextDocument__Stacks(QTextDocument__UndoStack | QTextDocument__RedoStack)
)

func (ptr *QTextDocument) BaseUrl() *core.QUrl {
	defer qt.Recovering("QTextDocument::baseUrl")

	if ptr.Pointer() != nil {
		return core.NewQUrlFromPointer(C.QTextDocument_BaseUrl(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextDocument) BlockCount() int {
	defer qt.Recovering("QTextDocument::blockCount")

	if ptr.Pointer() != nil {
		return int(C.QTextDocument_BlockCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) CreateObject(format QTextFormat_ITF) *QTextObject {
	defer qt.Recovering("QTextDocument::createObject")

	if ptr.Pointer() != nil {
		return NewQTextObjectFromPointer(C.QTextDocument_CreateObject(ptr.Pointer(), PointerFromQTextFormat(format)))
	}
	return nil
}

func (ptr *QTextDocument) DefaultStyleSheet() string {
	defer qt.Recovering("QTextDocument::defaultStyleSheet")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextDocument_DefaultStyleSheet(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextDocument) DocumentMargin() float64 {
	defer qt.Recovering("QTextDocument::documentMargin")

	if ptr.Pointer() != nil {
		return float64(C.QTextDocument_DocumentMargin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) IndentWidth() float64 {
	defer qt.Recovering("QTextDocument::indentWidth")

	if ptr.Pointer() != nil {
		return float64(C.QTextDocument_IndentWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) IsModified() bool {
	defer qt.Recovering("QTextDocument::isModified")

	if ptr.Pointer() != nil {
		return C.QTextDocument_IsModified(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextDocument) IsUndoRedoEnabled() bool {
	defer qt.Recovering("QTextDocument::isUndoRedoEnabled")

	if ptr.Pointer() != nil {
		return C.QTextDocument_IsUndoRedoEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextDocument) MarkContentsDirty(position int, length int) {
	defer qt.Recovering("QTextDocument::markContentsDirty")

	if ptr.Pointer() != nil {
		C.QTextDocument_MarkContentsDirty(ptr.Pointer(), C.int(position), C.int(length))
	}
}

func (ptr *QTextDocument) MaximumBlockCount() int {
	defer qt.Recovering("QTextDocument::maximumBlockCount")

	if ptr.Pointer() != nil {
		return int(C.QTextDocument_MaximumBlockCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) SetBaseUrl(url core.QUrl_ITF) {
	defer qt.Recovering("QTextDocument::setBaseUrl")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetBaseUrl(ptr.Pointer(), core.PointerFromQUrl(url))
	}
}

func (ptr *QTextDocument) SetDefaultStyleSheet(sheet string) {
	defer qt.Recovering("QTextDocument::setDefaultStyleSheet")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetDefaultStyleSheet(ptr.Pointer(), C.CString(sheet))
	}
}

func (ptr *QTextDocument) SetDocumentMargin(margin float64) {
	defer qt.Recovering("QTextDocument::setDocumentMargin")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetDocumentMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextDocument) SetMaximumBlockCount(maximum int) {
	defer qt.Recovering("QTextDocument::setMaximumBlockCount")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetMaximumBlockCount(ptr.Pointer(), C.int(maximum))
	}
}

func (ptr *QTextDocument) SetModified(m bool) {
	defer qt.Recovering("QTextDocument::setModified")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetModified(ptr.Pointer(), C.int(qt.GoBoolToInt(m)))
	}
}

func (ptr *QTextDocument) SetPageSize(size core.QSizeF_ITF) {
	defer qt.Recovering("QTextDocument::setPageSize")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetPageSize(ptr.Pointer(), core.PointerFromQSizeF(size))
	}
}

func (ptr *QTextDocument) SetTextWidth(width float64) {
	defer qt.Recovering("QTextDocument::setTextWidth")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetTextWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QTextDocument) SetUndoRedoEnabled(enable bool) {
	defer qt.Recovering("QTextDocument::setUndoRedoEnabled")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetUndoRedoEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QTextDocument) SetUseDesignMetrics(b bool) {
	defer qt.Recovering("QTextDocument::setUseDesignMetrics")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetUseDesignMetrics(ptr.Pointer(), C.int(qt.GoBoolToInt(b)))
	}
}

func (ptr *QTextDocument) TextWidth() float64 {
	defer qt.Recovering("QTextDocument::textWidth")

	if ptr.Pointer() != nil {
		return float64(C.QTextDocument_TextWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) UseDesignMetrics() bool {
	defer qt.Recovering("QTextDocument::useDesignMetrics")

	if ptr.Pointer() != nil {
		return C.QTextDocument_UseDesignMetrics(ptr.Pointer()) != 0
	}
	return false
}

func NewQTextDocument(parent core.QObject_ITF) *QTextDocument {
	defer qt.Recovering("QTextDocument::QTextDocument")

	return newQTextDocumentFromPointer(C.QTextDocument_NewQTextDocument(core.PointerFromQObject(parent)))
}

func NewQTextDocument2(text string, parent core.QObject_ITF) *QTextDocument {
	defer qt.Recovering("QTextDocument::QTextDocument")

	return newQTextDocumentFromPointer(C.QTextDocument_NewQTextDocument2(C.CString(text), core.PointerFromQObject(parent)))
}

func (ptr *QTextDocument) AddResource(ty int, name core.QUrl_ITF, resource core.QVariant_ITF) {
	defer qt.Recovering("QTextDocument::addResource")

	if ptr.Pointer() != nil {
		C.QTextDocument_AddResource(ptr.Pointer(), C.int(ty), core.PointerFromQUrl(name), core.PointerFromQVariant(resource))
	}
}

func (ptr *QTextDocument) AdjustSize() {
	defer qt.Recovering("QTextDocument::adjustSize")

	if ptr.Pointer() != nil {
		C.QTextDocument_AdjustSize(ptr.Pointer())
	}
}

func (ptr *QTextDocument) AvailableRedoSteps() int {
	defer qt.Recovering("QTextDocument::availableRedoSteps")

	if ptr.Pointer() != nil {
		return int(C.QTextDocument_AvailableRedoSteps(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) AvailableUndoSteps() int {
	defer qt.Recovering("QTextDocument::availableUndoSteps")

	if ptr.Pointer() != nil {
		return int(C.QTextDocument_AvailableUndoSteps(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) ConnectBaseUrlChanged(f func(url *core.QUrl)) {
	defer qt.Recovering("connect QTextDocument::baseUrlChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_ConnectBaseUrlChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "baseUrlChanged", f)
	}
}

func (ptr *QTextDocument) DisconnectBaseUrlChanged() {
	defer qt.Recovering("disconnect QTextDocument::baseUrlChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_DisconnectBaseUrlChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "baseUrlChanged")
	}
}

//export callbackQTextDocumentBaseUrlChanged
func callbackQTextDocumentBaseUrlChanged(ptr unsafe.Pointer, ptrName *C.char, url unsafe.Pointer) {
	defer qt.Recovering("callback QTextDocument::baseUrlChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "baseUrlChanged"); signal != nil {
		signal.(func(*core.QUrl))(core.NewQUrlFromPointer(url))
	}

}

func (ptr *QTextDocument) BaseUrlChanged(url core.QUrl_ITF) {
	defer qt.Recovering("QTextDocument::baseUrlChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_BaseUrlChanged(ptr.Pointer(), core.PointerFromQUrl(url))
	}
}

func (ptr *QTextDocument) ConnectBlockCountChanged(f func(newBlockCount int)) {
	defer qt.Recovering("connect QTextDocument::blockCountChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_ConnectBlockCountChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "blockCountChanged", f)
	}
}

func (ptr *QTextDocument) DisconnectBlockCountChanged() {
	defer qt.Recovering("disconnect QTextDocument::blockCountChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_DisconnectBlockCountChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "blockCountChanged")
	}
}

//export callbackQTextDocumentBlockCountChanged
func callbackQTextDocumentBlockCountChanged(ptr unsafe.Pointer, ptrName *C.char, newBlockCount C.int) {
	defer qt.Recovering("callback QTextDocument::blockCountChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "blockCountChanged"); signal != nil {
		signal.(func(int))(int(newBlockCount))
	}

}

func (ptr *QTextDocument) BlockCountChanged(newBlockCount int) {
	defer qt.Recovering("QTextDocument::blockCountChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_BlockCountChanged(ptr.Pointer(), C.int(newBlockCount))
	}
}

func (ptr *QTextDocument) CharacterCount() int {
	defer qt.Recovering("QTextDocument::characterCount")

	if ptr.Pointer() != nil {
		return int(C.QTextDocument_CharacterCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) ConnectClear(f func()) {
	defer qt.Recovering("connect QTextDocument::clear")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "clear", f)
	}
}

func (ptr *QTextDocument) DisconnectClear() {
	defer qt.Recovering("disconnect QTextDocument::clear")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "clear")
	}
}

//export callbackQTextDocumentClear
func callbackQTextDocumentClear(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QTextDocument::clear")

	if signal := qt.GetSignal(C.GoString(ptrName), "clear"); signal != nil {
		signal.(func())()
	} else {
		NewQTextDocumentFromPointer(ptr).ClearDefault()
	}
}

func (ptr *QTextDocument) Clear() {
	defer qt.Recovering("QTextDocument::clear")

	if ptr.Pointer() != nil {
		C.QTextDocument_Clear(ptr.Pointer())
	}
}

func (ptr *QTextDocument) ClearDefault() {
	defer qt.Recovering("QTextDocument::clear")

	if ptr.Pointer() != nil {
		C.QTextDocument_ClearDefault(ptr.Pointer())
	}
}

func (ptr *QTextDocument) ClearUndoRedoStacks(stacksToClear QTextDocument__Stacks) {
	defer qt.Recovering("QTextDocument::clearUndoRedoStacks")

	if ptr.Pointer() != nil {
		C.QTextDocument_ClearUndoRedoStacks(ptr.Pointer(), C.int(stacksToClear))
	}
}

func (ptr *QTextDocument) Clone(parent core.QObject_ITF) *QTextDocument {
	defer qt.Recovering("QTextDocument::clone")

	if ptr.Pointer() != nil {
		return NewQTextDocumentFromPointer(C.QTextDocument_Clone(ptr.Pointer(), core.PointerFromQObject(parent)))
	}
	return nil
}

func (ptr *QTextDocument) ConnectContentsChange(f func(position int, charsRemoved int, charsAdded int)) {
	defer qt.Recovering("connect QTextDocument::contentsChange")

	if ptr.Pointer() != nil {
		C.QTextDocument_ConnectContentsChange(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "contentsChange", f)
	}
}

func (ptr *QTextDocument) DisconnectContentsChange() {
	defer qt.Recovering("disconnect QTextDocument::contentsChange")

	if ptr.Pointer() != nil {
		C.QTextDocument_DisconnectContentsChange(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "contentsChange")
	}
}

//export callbackQTextDocumentContentsChange
func callbackQTextDocumentContentsChange(ptr unsafe.Pointer, ptrName *C.char, position C.int, charsRemoved C.int, charsAdded C.int) {
	defer qt.Recovering("callback QTextDocument::contentsChange")

	if signal := qt.GetSignal(C.GoString(ptrName), "contentsChange"); signal != nil {
		signal.(func(int, int, int))(int(position), int(charsRemoved), int(charsAdded))
	}

}

func (ptr *QTextDocument) ContentsChange(position int, charsRemoved int, charsAdded int) {
	defer qt.Recovering("QTextDocument::contentsChange")

	if ptr.Pointer() != nil {
		C.QTextDocument_ContentsChange(ptr.Pointer(), C.int(position), C.int(charsRemoved), C.int(charsAdded))
	}
}

func (ptr *QTextDocument) ConnectContentsChanged(f func()) {
	defer qt.Recovering("connect QTextDocument::contentsChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_ConnectContentsChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "contentsChanged", f)
	}
}

func (ptr *QTextDocument) DisconnectContentsChanged() {
	defer qt.Recovering("disconnect QTextDocument::contentsChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_DisconnectContentsChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "contentsChanged")
	}
}

//export callbackQTextDocumentContentsChanged
func callbackQTextDocumentContentsChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QTextDocument::contentsChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "contentsChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QTextDocument) ContentsChanged() {
	defer qt.Recovering("QTextDocument::contentsChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_ContentsChanged(ptr.Pointer())
	}
}

func (ptr *QTextDocument) DefaultCursorMoveStyle() core.Qt__CursorMoveStyle {
	defer qt.Recovering("QTextDocument::defaultCursorMoveStyle")

	if ptr.Pointer() != nil {
		return core.Qt__CursorMoveStyle(C.QTextDocument_DefaultCursorMoveStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) DocumentLayout() *QAbstractTextDocumentLayout {
	defer qt.Recovering("QTextDocument::documentLayout")

	if ptr.Pointer() != nil {
		return NewQAbstractTextDocumentLayoutFromPointer(C.QTextDocument_DocumentLayout(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextDocument) ConnectDocumentLayoutChanged(f func()) {
	defer qt.Recovering("connect QTextDocument::documentLayoutChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_ConnectDocumentLayoutChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "documentLayoutChanged", f)
	}
}

func (ptr *QTextDocument) DisconnectDocumentLayoutChanged() {
	defer qt.Recovering("disconnect QTextDocument::documentLayoutChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_DisconnectDocumentLayoutChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "documentLayoutChanged")
	}
}

//export callbackQTextDocumentDocumentLayoutChanged
func callbackQTextDocumentDocumentLayoutChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QTextDocument::documentLayoutChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "documentLayoutChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QTextDocument) DocumentLayoutChanged() {
	defer qt.Recovering("QTextDocument::documentLayoutChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_DocumentLayoutChanged(ptr.Pointer())
	}
}

func (ptr *QTextDocument) DrawContents(p QPainter_ITF, rect core.QRectF_ITF) {
	defer qt.Recovering("QTextDocument::drawContents")

	if ptr.Pointer() != nil {
		C.QTextDocument_DrawContents(ptr.Pointer(), PointerFromQPainter(p), core.PointerFromQRectF(rect))
	}
}

func (ptr *QTextDocument) IdealWidth() float64 {
	defer qt.Recovering("QTextDocument::idealWidth")

	if ptr.Pointer() != nil {
		return float64(C.QTextDocument_IdealWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) IsEmpty() bool {
	defer qt.Recovering("QTextDocument::isEmpty")

	if ptr.Pointer() != nil {
		return C.QTextDocument_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextDocument) IsRedoAvailable() bool {
	defer qt.Recovering("QTextDocument::isRedoAvailable")

	if ptr.Pointer() != nil {
		return C.QTextDocument_IsRedoAvailable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextDocument) IsUndoAvailable() bool {
	defer qt.Recovering("QTextDocument::isUndoAvailable")

	if ptr.Pointer() != nil {
		return C.QTextDocument_IsUndoAvailable(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextDocument) LineCount() int {
	defer qt.Recovering("QTextDocument::lineCount")

	if ptr.Pointer() != nil {
		return int(C.QTextDocument_LineCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) LoadResource(ty int, name core.QUrl_ITF) *core.QVariant {
	defer qt.Recovering("QTextDocument::loadResource")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QTextDocument_LoadResource(ptr.Pointer(), C.int(ty), core.PointerFromQUrl(name)))
	}
	return nil
}

func (ptr *QTextDocument) MetaInformation(info QTextDocument__MetaInformation) string {
	defer qt.Recovering("QTextDocument::metaInformation")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextDocument_MetaInformation(ptr.Pointer(), C.int(info)))
	}
	return ""
}

func (ptr *QTextDocument) ConnectModificationChanged(f func(changed bool)) {
	defer qt.Recovering("connect QTextDocument::modificationChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_ConnectModificationChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "modificationChanged", f)
	}
}

func (ptr *QTextDocument) DisconnectModificationChanged() {
	defer qt.Recovering("disconnect QTextDocument::modificationChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_DisconnectModificationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "modificationChanged")
	}
}

//export callbackQTextDocumentModificationChanged
func callbackQTextDocumentModificationChanged(ptr unsafe.Pointer, ptrName *C.char, changed C.int) {
	defer qt.Recovering("callback QTextDocument::modificationChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "modificationChanged"); signal != nil {
		signal.(func(bool))(int(changed) != 0)
	}

}

func (ptr *QTextDocument) ModificationChanged(changed bool) {
	defer qt.Recovering("QTextDocument::modificationChanged")

	if ptr.Pointer() != nil {
		C.QTextDocument_ModificationChanged(ptr.Pointer(), C.int(qt.GoBoolToInt(changed)))
	}
}

func (ptr *QTextDocument) Object(objectIndex int) *QTextObject {
	defer qt.Recovering("QTextDocument::object")

	if ptr.Pointer() != nil {
		return NewQTextObjectFromPointer(C.QTextDocument_Object(ptr.Pointer(), C.int(objectIndex)))
	}
	return nil
}

func (ptr *QTextDocument) ObjectForFormat(f QTextFormat_ITF) *QTextObject {
	defer qt.Recovering("QTextDocument::objectForFormat")

	if ptr.Pointer() != nil {
		return NewQTextObjectFromPointer(C.QTextDocument_ObjectForFormat(ptr.Pointer(), PointerFromQTextFormat(f)))
	}
	return nil
}

func (ptr *QTextDocument) PageCount() int {
	defer qt.Recovering("QTextDocument::pageCount")

	if ptr.Pointer() != nil {
		return int(C.QTextDocument_PageCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) Print(printer QPagedPaintDevice_ITF) {
	defer qt.Recovering("QTextDocument::print")

	if ptr.Pointer() != nil {
		C.QTextDocument_Print(ptr.Pointer(), PointerFromQPagedPaintDevice(printer))
	}
}

func (ptr *QTextDocument) Redo2() {
	defer qt.Recovering("QTextDocument::redo")

	if ptr.Pointer() != nil {
		C.QTextDocument_Redo2(ptr.Pointer())
	}
}

func (ptr *QTextDocument) Redo(cursor QTextCursor_ITF) {
	defer qt.Recovering("QTextDocument::redo")

	if ptr.Pointer() != nil {
		C.QTextDocument_Redo(ptr.Pointer(), PointerFromQTextCursor(cursor))
	}
}

func (ptr *QTextDocument) ConnectRedoAvailable(f func(available bool)) {
	defer qt.Recovering("connect QTextDocument::redoAvailable")

	if ptr.Pointer() != nil {
		C.QTextDocument_ConnectRedoAvailable(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "redoAvailable", f)
	}
}

func (ptr *QTextDocument) DisconnectRedoAvailable() {
	defer qt.Recovering("disconnect QTextDocument::redoAvailable")

	if ptr.Pointer() != nil {
		C.QTextDocument_DisconnectRedoAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "redoAvailable")
	}
}

//export callbackQTextDocumentRedoAvailable
func callbackQTextDocumentRedoAvailable(ptr unsafe.Pointer, ptrName *C.char, available C.int) {
	defer qt.Recovering("callback QTextDocument::redoAvailable")

	if signal := qt.GetSignal(C.GoString(ptrName), "redoAvailable"); signal != nil {
		signal.(func(bool))(int(available) != 0)
	}

}

func (ptr *QTextDocument) RedoAvailable(available bool) {
	defer qt.Recovering("QTextDocument::redoAvailable")

	if ptr.Pointer() != nil {
		C.QTextDocument_RedoAvailable(ptr.Pointer(), C.int(qt.GoBoolToInt(available)))
	}
}

func (ptr *QTextDocument) Resource(ty int, name core.QUrl_ITF) *core.QVariant {
	defer qt.Recovering("QTextDocument::resource")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QTextDocument_Resource(ptr.Pointer(), C.int(ty), core.PointerFromQUrl(name)))
	}
	return nil
}

func (ptr *QTextDocument) Revision() int {
	defer qt.Recovering("QTextDocument::revision")

	if ptr.Pointer() != nil {
		return int(C.QTextDocument_Revision(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextDocument) RootFrame() *QTextFrame {
	defer qt.Recovering("QTextDocument::rootFrame")

	if ptr.Pointer() != nil {
		return NewQTextFrameFromPointer(C.QTextDocument_RootFrame(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextDocument) SetDefaultCursorMoveStyle(style core.Qt__CursorMoveStyle) {
	defer qt.Recovering("QTextDocument::setDefaultCursorMoveStyle")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetDefaultCursorMoveStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QTextDocument) SetDefaultFont(font QFont_ITF) {
	defer qt.Recovering("QTextDocument::setDefaultFont")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetDefaultFont(ptr.Pointer(), PointerFromQFont(font))
	}
}

func (ptr *QTextDocument) SetDefaultTextOption(option QTextOption_ITF) {
	defer qt.Recovering("QTextDocument::setDefaultTextOption")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetDefaultTextOption(ptr.Pointer(), PointerFromQTextOption(option))
	}
}

func (ptr *QTextDocument) SetDocumentLayout(layout QAbstractTextDocumentLayout_ITF) {
	defer qt.Recovering("QTextDocument::setDocumentLayout")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetDocumentLayout(ptr.Pointer(), PointerFromQAbstractTextDocumentLayout(layout))
	}
}

func (ptr *QTextDocument) SetHtml(html string) {
	defer qt.Recovering("QTextDocument::setHtml")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetHtml(ptr.Pointer(), C.CString(html))
	}
}

func (ptr *QTextDocument) SetIndentWidth(width float64) {
	defer qt.Recovering("QTextDocument::setIndentWidth")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetIndentWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QTextDocument) SetMetaInformation(info QTextDocument__MetaInformation, stri string) {
	defer qt.Recovering("QTextDocument::setMetaInformation")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetMetaInformation(ptr.Pointer(), C.int(info), C.CString(stri))
	}
}

func (ptr *QTextDocument) SetPlainText(text string) {
	defer qt.Recovering("QTextDocument::setPlainText")

	if ptr.Pointer() != nil {
		C.QTextDocument_SetPlainText(ptr.Pointer(), C.CString(text))
	}
}

func (ptr *QTextDocument) ToHtml(encoding core.QByteArray_ITF) string {
	defer qt.Recovering("QTextDocument::toHtml")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextDocument_ToHtml(ptr.Pointer(), core.PointerFromQByteArray(encoding)))
	}
	return ""
}

func (ptr *QTextDocument) ToPlainText() string {
	defer qt.Recovering("QTextDocument::toPlainText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextDocument_ToPlainText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextDocument) Undo2() {
	defer qt.Recovering("QTextDocument::undo")

	if ptr.Pointer() != nil {
		C.QTextDocument_Undo2(ptr.Pointer())
	}
}

func (ptr *QTextDocument) Undo(cursor QTextCursor_ITF) {
	defer qt.Recovering("QTextDocument::undo")

	if ptr.Pointer() != nil {
		C.QTextDocument_Undo(ptr.Pointer(), PointerFromQTextCursor(cursor))
	}
}

func (ptr *QTextDocument) ConnectUndoAvailable(f func(available bool)) {
	defer qt.Recovering("connect QTextDocument::undoAvailable")

	if ptr.Pointer() != nil {
		C.QTextDocument_ConnectUndoAvailable(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "undoAvailable", f)
	}
}

func (ptr *QTextDocument) DisconnectUndoAvailable() {
	defer qt.Recovering("disconnect QTextDocument::undoAvailable")

	if ptr.Pointer() != nil {
		C.QTextDocument_DisconnectUndoAvailable(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "undoAvailable")
	}
}

//export callbackQTextDocumentUndoAvailable
func callbackQTextDocumentUndoAvailable(ptr unsafe.Pointer, ptrName *C.char, available C.int) {
	defer qt.Recovering("callback QTextDocument::undoAvailable")

	if signal := qt.GetSignal(C.GoString(ptrName), "undoAvailable"); signal != nil {
		signal.(func(bool))(int(available) != 0)
	}

}

func (ptr *QTextDocument) UndoAvailable(available bool) {
	defer qt.Recovering("QTextDocument::undoAvailable")

	if ptr.Pointer() != nil {
		C.QTextDocument_UndoAvailable(ptr.Pointer(), C.int(qt.GoBoolToInt(available)))
	}
}

func (ptr *QTextDocument) ConnectUndoCommandAdded(f func()) {
	defer qt.Recovering("connect QTextDocument::undoCommandAdded")

	if ptr.Pointer() != nil {
		C.QTextDocument_ConnectUndoCommandAdded(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "undoCommandAdded", f)
	}
}

func (ptr *QTextDocument) DisconnectUndoCommandAdded() {
	defer qt.Recovering("disconnect QTextDocument::undoCommandAdded")

	if ptr.Pointer() != nil {
		C.QTextDocument_DisconnectUndoCommandAdded(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "undoCommandAdded")
	}
}

//export callbackQTextDocumentUndoCommandAdded
func callbackQTextDocumentUndoCommandAdded(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QTextDocument::undoCommandAdded")

	if signal := qt.GetSignal(C.GoString(ptrName), "undoCommandAdded"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QTextDocument) UndoCommandAdded() {
	defer qt.Recovering("QTextDocument::undoCommandAdded")

	if ptr.Pointer() != nil {
		C.QTextDocument_UndoCommandAdded(ptr.Pointer())
	}
}

func (ptr *QTextDocument) DestroyQTextDocument() {
	defer qt.Recovering("QTextDocument::~QTextDocument")

	if ptr.Pointer() != nil {
		C.QTextDocument_DestroyQTextDocument(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QTextDocument) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QTextDocument::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTextDocument) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTextDocument::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTextDocumentTimerEvent
func callbackQTextDocumentTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextDocument::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQTextDocumentFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QTextDocument) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextDocument::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextDocument_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextDocument) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextDocument::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextDocument_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextDocument) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QTextDocument::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTextDocument) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTextDocument::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTextDocumentChildEvent
func callbackQTextDocumentChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextDocument::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQTextDocumentFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QTextDocument) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextDocument::childEvent")

	if ptr.Pointer() != nil {
		C.QTextDocument_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextDocument) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextDocument::childEvent")

	if ptr.Pointer() != nil {
		C.QTextDocument_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextDocument) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QTextDocument::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTextDocument) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTextDocument::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTextDocumentCustomEvent
func callbackQTextDocumentCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextDocument::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQTextDocumentFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QTextDocument) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QTextDocument::customEvent")

	if ptr.Pointer() != nil {
		C.QTextDocument_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QTextDocument) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QTextDocument::customEvent")

	if ptr.Pointer() != nil {
		C.QTextDocument_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QTextDocumentFragment struct {
	ptr unsafe.Pointer
}

type QTextDocumentFragment_ITF interface {
	QTextDocumentFragment_PTR() *QTextDocumentFragment
}

func (p *QTextDocumentFragment) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextDocumentFragment) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextDocumentFragment(ptr QTextDocumentFragment_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextDocumentFragment_PTR().Pointer()
	}
	return nil
}

func NewQTextDocumentFragmentFromPointer(ptr unsafe.Pointer) *QTextDocumentFragment {
	var n = new(QTextDocumentFragment)
	n.SetPointer(ptr)
	return n
}

func newQTextDocumentFragmentFromPointer(ptr unsafe.Pointer) *QTextDocumentFragment {
	var n = NewQTextDocumentFragmentFromPointer(ptr)
	return n
}

func (ptr *QTextDocumentFragment) QTextDocumentFragment_PTR() *QTextDocumentFragment {
	return ptr
}

func NewQTextDocumentFragment4(other QTextDocumentFragment_ITF) *QTextDocumentFragment {
	defer qt.Recovering("QTextDocumentFragment::QTextDocumentFragment")

	return newQTextDocumentFragmentFromPointer(C.QTextDocumentFragment_NewQTextDocumentFragment4(PointerFromQTextDocumentFragment(other)))
}

func NewQTextDocumentFragment() *QTextDocumentFragment {
	defer qt.Recovering("QTextDocumentFragment::QTextDocumentFragment")

	return newQTextDocumentFragmentFromPointer(C.QTextDocumentFragment_NewQTextDocumentFragment())
}

func NewQTextDocumentFragment3(cursor QTextCursor_ITF) *QTextDocumentFragment {
	defer qt.Recovering("QTextDocumentFragment::QTextDocumentFragment")

	return newQTextDocumentFragmentFromPointer(C.QTextDocumentFragment_NewQTextDocumentFragment3(PointerFromQTextCursor(cursor)))
}

func NewQTextDocumentFragment2(document QTextDocument_ITF) *QTextDocumentFragment {
	defer qt.Recovering("QTextDocumentFragment::QTextDocumentFragment")

	return newQTextDocumentFragmentFromPointer(C.QTextDocumentFragment_NewQTextDocumentFragment2(PointerFromQTextDocument(document)))
}

func (ptr *QTextDocumentFragment) IsEmpty() bool {
	defer qt.Recovering("QTextDocumentFragment::isEmpty")

	if ptr.Pointer() != nil {
		return C.QTextDocumentFragment_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextDocumentFragment) ToHtml(encoding core.QByteArray_ITF) string {
	defer qt.Recovering("QTextDocumentFragment::toHtml")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextDocumentFragment_ToHtml(ptr.Pointer(), core.PointerFromQByteArray(encoding)))
	}
	return ""
}

func (ptr *QTextDocumentFragment) ToPlainText() string {
	defer qt.Recovering("QTextDocumentFragment::toPlainText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextDocumentFragment_ToPlainText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextDocumentFragment) DestroyQTextDocumentFragment() {
	defer qt.Recovering("QTextDocumentFragment::~QTextDocumentFragment")

	if ptr.Pointer() != nil {
		C.QTextDocumentFragment_DestroyQTextDocumentFragment(ptr.Pointer())
	}
}

type QTextDocumentWriter struct {
	ptr unsafe.Pointer
}

type QTextDocumentWriter_ITF interface {
	QTextDocumentWriter_PTR() *QTextDocumentWriter
}

func (p *QTextDocumentWriter) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextDocumentWriter) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextDocumentWriter(ptr QTextDocumentWriter_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextDocumentWriter_PTR().Pointer()
	}
	return nil
}

func NewQTextDocumentWriterFromPointer(ptr unsafe.Pointer) *QTextDocumentWriter {
	var n = new(QTextDocumentWriter)
	n.SetPointer(ptr)
	return n
}

func newQTextDocumentWriterFromPointer(ptr unsafe.Pointer) *QTextDocumentWriter {
	var n = NewQTextDocumentWriterFromPointer(ptr)
	return n
}

func (ptr *QTextDocumentWriter) QTextDocumentWriter_PTR() *QTextDocumentWriter {
	return ptr
}

func NewQTextDocumentWriter() *QTextDocumentWriter {
	defer qt.Recovering("QTextDocumentWriter::QTextDocumentWriter")

	return newQTextDocumentWriterFromPointer(C.QTextDocumentWriter_NewQTextDocumentWriter())
}

func NewQTextDocumentWriter2(device core.QIODevice_ITF, format core.QByteArray_ITF) *QTextDocumentWriter {
	defer qt.Recovering("QTextDocumentWriter::QTextDocumentWriter")

	return newQTextDocumentWriterFromPointer(C.QTextDocumentWriter_NewQTextDocumentWriter2(core.PointerFromQIODevice(device), core.PointerFromQByteArray(format)))
}

func NewQTextDocumentWriter3(fileName string, format core.QByteArray_ITF) *QTextDocumentWriter {
	defer qt.Recovering("QTextDocumentWriter::QTextDocumentWriter")

	return newQTextDocumentWriterFromPointer(C.QTextDocumentWriter_NewQTextDocumentWriter3(C.CString(fileName), core.PointerFromQByteArray(format)))
}

func (ptr *QTextDocumentWriter) Codec() *core.QTextCodec {
	defer qt.Recovering("QTextDocumentWriter::codec")

	if ptr.Pointer() != nil {
		return core.NewQTextCodecFromPointer(C.QTextDocumentWriter_Codec(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextDocumentWriter) Device() *core.QIODevice {
	defer qt.Recovering("QTextDocumentWriter::device")

	if ptr.Pointer() != nil {
		return core.NewQIODeviceFromPointer(C.QTextDocumentWriter_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextDocumentWriter) FileName() string {
	defer qt.Recovering("QTextDocumentWriter::fileName")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextDocumentWriter_FileName(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextDocumentWriter) Format() *core.QByteArray {
	defer qt.Recovering("QTextDocumentWriter::format")

	if ptr.Pointer() != nil {
		return core.NewQByteArrayFromPointer(C.QTextDocumentWriter_Format(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextDocumentWriter) SetCodec(codec core.QTextCodec_ITF) {
	defer qt.Recovering("QTextDocumentWriter::setCodec")

	if ptr.Pointer() != nil {
		C.QTextDocumentWriter_SetCodec(ptr.Pointer(), core.PointerFromQTextCodec(codec))
	}
}

func (ptr *QTextDocumentWriter) SetDevice(device core.QIODevice_ITF) {
	defer qt.Recovering("QTextDocumentWriter::setDevice")

	if ptr.Pointer() != nil {
		C.QTextDocumentWriter_SetDevice(ptr.Pointer(), core.PointerFromQIODevice(device))
	}
}

func (ptr *QTextDocumentWriter) SetFileName(fileName string) {
	defer qt.Recovering("QTextDocumentWriter::setFileName")

	if ptr.Pointer() != nil {
		C.QTextDocumentWriter_SetFileName(ptr.Pointer(), C.CString(fileName))
	}
}

func (ptr *QTextDocumentWriter) SetFormat(format core.QByteArray_ITF) {
	defer qt.Recovering("QTextDocumentWriter::setFormat")

	if ptr.Pointer() != nil {
		C.QTextDocumentWriter_SetFormat(ptr.Pointer(), core.PointerFromQByteArray(format))
	}
}

func (ptr *QTextDocumentWriter) Write(document QTextDocument_ITF) bool {
	defer qt.Recovering("QTextDocumentWriter::write")

	if ptr.Pointer() != nil {
		return C.QTextDocumentWriter_Write(ptr.Pointer(), PointerFromQTextDocument(document)) != 0
	}
	return false
}

func (ptr *QTextDocumentWriter) Write2(fragment QTextDocumentFragment_ITF) bool {
	defer qt.Recovering("QTextDocumentWriter::write")

	if ptr.Pointer() != nil {
		return C.QTextDocumentWriter_Write2(ptr.Pointer(), PointerFromQTextDocumentFragment(fragment)) != 0
	}
	return false
}

func (ptr *QTextDocumentWriter) DestroyQTextDocumentWriter() {
	defer qt.Recovering("QTextDocumentWriter::~QTextDocumentWriter")

	if ptr.Pointer() != nil {
		C.QTextDocumentWriter_DestroyQTextDocumentWriter(ptr.Pointer())
	}
}

type QTextFormat struct {
	ptr unsafe.Pointer
}

type QTextFormat_ITF interface {
	QTextFormat_PTR() *QTextFormat
}

func (p *QTextFormat) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextFormat) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextFormat(ptr QTextFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextFormat_PTR().Pointer()
	}
	return nil
}

func NewQTextFormatFromPointer(ptr unsafe.Pointer) *QTextFormat {
	var n = new(QTextFormat)
	n.SetPointer(ptr)
	return n
}

func newQTextFormatFromPointer(ptr unsafe.Pointer) *QTextFormat {
	var n = NewQTextFormatFromPointer(ptr)
	return n
}

func (ptr *QTextFormat) QTextFormat_PTR() *QTextFormat {
	return ptr
}

//QTextFormat::FormatType
type QTextFormat__FormatType int64

const (
	QTextFormat__InvalidFormat = QTextFormat__FormatType(-1)
	QTextFormat__BlockFormat   = QTextFormat__FormatType(1)
	QTextFormat__CharFormat    = QTextFormat__FormatType(2)
	QTextFormat__ListFormat    = QTextFormat__FormatType(3)
	QTextFormat__TableFormat   = QTextFormat__FormatType(4)
	QTextFormat__FrameFormat   = QTextFormat__FormatType(5)
	QTextFormat__UserFormat    = QTextFormat__FormatType(100)
)

//QTextFormat::ObjectTypes
type QTextFormat__ObjectTypes int64

const (
	QTextFormat__NoObject        = QTextFormat__ObjectTypes(0)
	QTextFormat__ImageObject     = QTextFormat__ObjectTypes(1)
	QTextFormat__TableObject     = QTextFormat__ObjectTypes(2)
	QTextFormat__TableCellObject = QTextFormat__ObjectTypes(3)
	QTextFormat__UserObject      = QTextFormat__ObjectTypes(0x1000)
)

//QTextFormat::PageBreakFlag
type QTextFormat__PageBreakFlag int64

const (
	QTextFormat__PageBreak_Auto         = QTextFormat__PageBreakFlag(0)
	QTextFormat__PageBreak_AlwaysBefore = QTextFormat__PageBreakFlag(0x001)
	QTextFormat__PageBreak_AlwaysAfter  = QTextFormat__PageBreakFlag(0x010)
)

//QTextFormat::Property
type QTextFormat__Property int64

const (
	QTextFormat__ObjectIndex                       = QTextFormat__Property(0x0)
	QTextFormat__CssFloat                          = QTextFormat__Property(0x0800)
	QTextFormat__LayoutDirection                   = QTextFormat__Property(0x0801)
	QTextFormat__OutlinePen                        = QTextFormat__Property(0x810)
	QTextFormat__BackgroundBrush                   = QTextFormat__Property(0x820)
	QTextFormat__ForegroundBrush                   = QTextFormat__Property(0x821)
	QTextFormat__BackgroundImageUrl                = QTextFormat__Property(0x823)
	QTextFormat__BlockAlignment                    = QTextFormat__Property(0x1010)
	QTextFormat__BlockTopMargin                    = QTextFormat__Property(0x1030)
	QTextFormat__BlockBottomMargin                 = QTextFormat__Property(0x1031)
	QTextFormat__BlockLeftMargin                   = QTextFormat__Property(0x1032)
	QTextFormat__BlockRightMargin                  = QTextFormat__Property(0x1033)
	QTextFormat__TextIndent                        = QTextFormat__Property(0x1034)
	QTextFormat__TabPositions                      = QTextFormat__Property(0x1035)
	QTextFormat__BlockIndent                       = QTextFormat__Property(0x1040)
	QTextFormat__LineHeight                        = QTextFormat__Property(0x1048)
	QTextFormat__LineHeightType                    = QTextFormat__Property(0x1049)
	QTextFormat__BlockNonBreakableLines            = QTextFormat__Property(0x1050)
	QTextFormat__BlockTrailingHorizontalRulerWidth = QTextFormat__Property(0x1060)
	QTextFormat__FirstFontProperty                 = QTextFormat__Property(0x1FE0)
	QTextFormat__FontCapitalization                = QTextFormat__Property(QTextFormat__FirstFontProperty)
	QTextFormat__FontLetterSpacingType             = QTextFormat__Property(0x2033)
	QTextFormat__FontLetterSpacing                 = QTextFormat__Property(0x1FE1)
	QTextFormat__FontWordSpacing                   = QTextFormat__Property(0x1FE2)
	QTextFormat__FontStretch                       = QTextFormat__Property(0x2034)
	QTextFormat__FontStyleHint                     = QTextFormat__Property(0x1FE3)
	QTextFormat__FontStyleStrategy                 = QTextFormat__Property(0x1FE4)
	QTextFormat__FontKerning                       = QTextFormat__Property(0x1FE5)
	QTextFormat__FontHintingPreference             = QTextFormat__Property(0x1FE6)
	QTextFormat__FontFamily                        = QTextFormat__Property(0x2000)
	QTextFormat__FontPointSize                     = QTextFormat__Property(0x2001)
	QTextFormat__FontSizeAdjustment                = QTextFormat__Property(0x2002)
	QTextFormat__FontSizeIncrement                 = QTextFormat__Property(QTextFormat__FontSizeAdjustment)
	QTextFormat__FontWeight                        = QTextFormat__Property(0x2003)
	QTextFormat__FontItalic                        = QTextFormat__Property(0x2004)
	QTextFormat__FontUnderline                     = QTextFormat__Property(0x2005)
	QTextFormat__FontOverline                      = QTextFormat__Property(0x2006)
	QTextFormat__FontStrikeOut                     = QTextFormat__Property(0x2007)
	QTextFormat__FontFixedPitch                    = QTextFormat__Property(0x2008)
	QTextFormat__FontPixelSize                     = QTextFormat__Property(0x2009)
	QTextFormat__LastFontProperty                  = QTextFormat__Property(QTextFormat__FontPixelSize)
	QTextFormat__TextUnderlineColor                = QTextFormat__Property(0x2010)
	QTextFormat__TextVerticalAlignment             = QTextFormat__Property(0x2021)
	QTextFormat__TextOutline                       = QTextFormat__Property(0x2022)
	QTextFormat__TextUnderlineStyle                = QTextFormat__Property(0x2023)
	QTextFormat__TextToolTip                       = QTextFormat__Property(0x2024)
	QTextFormat__IsAnchor                          = QTextFormat__Property(0x2030)
	QTextFormat__AnchorHref                        = QTextFormat__Property(0x2031)
	QTextFormat__AnchorName                        = QTextFormat__Property(0x2032)
	QTextFormat__ObjectType                        = QTextFormat__Property(0x2f00)
	QTextFormat__ListStyle                         = QTextFormat__Property(0x3000)
	QTextFormat__ListIndent                        = QTextFormat__Property(0x3001)
	QTextFormat__ListNumberPrefix                  = QTextFormat__Property(0x3002)
	QTextFormat__ListNumberSuffix                  = QTextFormat__Property(0x3003)
	QTextFormat__FrameBorder                       = QTextFormat__Property(0x4000)
	QTextFormat__FrameMargin                       = QTextFormat__Property(0x4001)
	QTextFormat__FramePadding                      = QTextFormat__Property(0x4002)
	QTextFormat__FrameWidth                        = QTextFormat__Property(0x4003)
	QTextFormat__FrameHeight                       = QTextFormat__Property(0x4004)
	QTextFormat__FrameTopMargin                    = QTextFormat__Property(0x4005)
	QTextFormat__FrameBottomMargin                 = QTextFormat__Property(0x4006)
	QTextFormat__FrameLeftMargin                   = QTextFormat__Property(0x4007)
	QTextFormat__FrameRightMargin                  = QTextFormat__Property(0x4008)
	QTextFormat__FrameBorderBrush                  = QTextFormat__Property(0x4009)
	QTextFormat__FrameBorderStyle                  = QTextFormat__Property(0x4010)
	QTextFormat__TableColumns                      = QTextFormat__Property(0x4100)
	QTextFormat__TableColumnWidthConstraints       = QTextFormat__Property(0x4101)
	QTextFormat__TableCellSpacing                  = QTextFormat__Property(0x4102)
	QTextFormat__TableCellPadding                  = QTextFormat__Property(0x4103)
	QTextFormat__TableHeaderRowCount               = QTextFormat__Property(0x4104)
	QTextFormat__TableCellRowSpan                  = QTextFormat__Property(0x4810)
	QTextFormat__TableCellColumnSpan               = QTextFormat__Property(0x4811)
	QTextFormat__TableCellTopPadding               = QTextFormat__Property(0x4812)
	QTextFormat__TableCellBottomPadding            = QTextFormat__Property(0x4813)
	QTextFormat__TableCellLeftPadding              = QTextFormat__Property(0x4814)
	QTextFormat__TableCellRightPadding             = QTextFormat__Property(0x4815)
	QTextFormat__ImageName                         = QTextFormat__Property(0x5000)
	QTextFormat__ImageWidth                        = QTextFormat__Property(0x5010)
	QTextFormat__ImageHeight                       = QTextFormat__Property(0x5011)
	QTextFormat__FullWidthSelection                = QTextFormat__Property(0x06000)
	QTextFormat__PageBreakPolicy                   = QTextFormat__Property(0x7000)
	QTextFormat__UserProperty                      = QTextFormat__Property(0x100000)
)

func NewQTextFormat3(other QTextFormat_ITF) *QTextFormat {
	defer qt.Recovering("QTextFormat::QTextFormat")

	return newQTextFormatFromPointer(C.QTextFormat_NewQTextFormat3(PointerFromQTextFormat(other)))
}

func (ptr *QTextFormat) SetObjectIndex(index int) {
	defer qt.Recovering("QTextFormat::setObjectIndex")

	if ptr.Pointer() != nil {
		C.QTextFormat_SetObjectIndex(ptr.Pointer(), C.int(index))
	}
}

func NewQTextFormat() *QTextFormat {
	defer qt.Recovering("QTextFormat::QTextFormat")

	return newQTextFormatFromPointer(C.QTextFormat_NewQTextFormat())
}

func NewQTextFormat2(ty int) *QTextFormat {
	defer qt.Recovering("QTextFormat::QTextFormat")

	return newQTextFormatFromPointer(C.QTextFormat_NewQTextFormat2(C.int(ty)))
}

func (ptr *QTextFormat) Background() *QBrush {
	defer qt.Recovering("QTextFormat::background")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QTextFormat_Background(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextFormat) BoolProperty(propertyId int) bool {
	defer qt.Recovering("QTextFormat::boolProperty")

	if ptr.Pointer() != nil {
		return C.QTextFormat_BoolProperty(ptr.Pointer(), C.int(propertyId)) != 0
	}
	return false
}

func (ptr *QTextFormat) BrushProperty(propertyId int) *QBrush {
	defer qt.Recovering("QTextFormat::brushProperty")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QTextFormat_BrushProperty(ptr.Pointer(), C.int(propertyId)))
	}
	return nil
}

func (ptr *QTextFormat) ClearBackground() {
	defer qt.Recovering("QTextFormat::clearBackground")

	if ptr.Pointer() != nil {
		C.QTextFormat_ClearBackground(ptr.Pointer())
	}
}

func (ptr *QTextFormat) ClearForeground() {
	defer qt.Recovering("QTextFormat::clearForeground")

	if ptr.Pointer() != nil {
		C.QTextFormat_ClearForeground(ptr.Pointer())
	}
}

func (ptr *QTextFormat) ClearProperty(propertyId int) {
	defer qt.Recovering("QTextFormat::clearProperty")

	if ptr.Pointer() != nil {
		C.QTextFormat_ClearProperty(ptr.Pointer(), C.int(propertyId))
	}
}

func (ptr *QTextFormat) ColorProperty(propertyId int) *QColor {
	defer qt.Recovering("QTextFormat::colorProperty")

	if ptr.Pointer() != nil {
		return NewQColorFromPointer(C.QTextFormat_ColorProperty(ptr.Pointer(), C.int(propertyId)))
	}
	return nil
}

func (ptr *QTextFormat) DoubleProperty(propertyId int) float64 {
	defer qt.Recovering("QTextFormat::doubleProperty")

	if ptr.Pointer() != nil {
		return float64(C.QTextFormat_DoubleProperty(ptr.Pointer(), C.int(propertyId)))
	}
	return 0
}

func (ptr *QTextFormat) Foreground() *QBrush {
	defer qt.Recovering("QTextFormat::foreground")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QTextFormat_Foreground(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextFormat) HasProperty(propertyId int) bool {
	defer qt.Recovering("QTextFormat::hasProperty")

	if ptr.Pointer() != nil {
		return C.QTextFormat_HasProperty(ptr.Pointer(), C.int(propertyId)) != 0
	}
	return false
}

func (ptr *QTextFormat) IntProperty(propertyId int) int {
	defer qt.Recovering("QTextFormat::intProperty")

	if ptr.Pointer() != nil {
		return int(C.QTextFormat_IntProperty(ptr.Pointer(), C.int(propertyId)))
	}
	return 0
}

func (ptr *QTextFormat) IsBlockFormat() bool {
	defer qt.Recovering("QTextFormat::isBlockFormat")

	if ptr.Pointer() != nil {
		return C.QTextFormat_IsBlockFormat(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFormat) IsCharFormat() bool {
	defer qt.Recovering("QTextFormat::isCharFormat")

	if ptr.Pointer() != nil {
		return C.QTextFormat_IsCharFormat(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFormat) IsEmpty() bool {
	defer qt.Recovering("QTextFormat::isEmpty")

	if ptr.Pointer() != nil {
		return C.QTextFormat_IsEmpty(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFormat) IsFrameFormat() bool {
	defer qt.Recovering("QTextFormat::isFrameFormat")

	if ptr.Pointer() != nil {
		return C.QTextFormat_IsFrameFormat(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFormat) IsImageFormat() bool {
	defer qt.Recovering("QTextFormat::isImageFormat")

	if ptr.Pointer() != nil {
		return C.QTextFormat_IsImageFormat(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFormat) IsListFormat() bool {
	defer qt.Recovering("QTextFormat::isListFormat")

	if ptr.Pointer() != nil {
		return C.QTextFormat_IsListFormat(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFormat) IsTableCellFormat() bool {
	defer qt.Recovering("QTextFormat::isTableCellFormat")

	if ptr.Pointer() != nil {
		return C.QTextFormat_IsTableCellFormat(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFormat) IsTableFormat() bool {
	defer qt.Recovering("QTextFormat::isTableFormat")

	if ptr.Pointer() != nil {
		return C.QTextFormat_IsTableFormat(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFormat) IsValid() bool {
	defer qt.Recovering("QTextFormat::isValid")

	if ptr.Pointer() != nil {
		return C.QTextFormat_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFormat) LayoutDirection() core.Qt__LayoutDirection {
	defer qt.Recovering("QTextFormat::layoutDirection")

	if ptr.Pointer() != nil {
		return core.Qt__LayoutDirection(C.QTextFormat_LayoutDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFormat) Merge(other QTextFormat_ITF) {
	defer qt.Recovering("QTextFormat::merge")

	if ptr.Pointer() != nil {
		C.QTextFormat_Merge(ptr.Pointer(), PointerFromQTextFormat(other))
	}
}

func (ptr *QTextFormat) ObjectIndex() int {
	defer qt.Recovering("QTextFormat::objectIndex")

	if ptr.Pointer() != nil {
		return int(C.QTextFormat_ObjectIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFormat) ObjectType() int {
	defer qt.Recovering("QTextFormat::objectType")

	if ptr.Pointer() != nil {
		return int(C.QTextFormat_ObjectType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFormat) Property(propertyId int) *core.QVariant {
	defer qt.Recovering("QTextFormat::property")

	if ptr.Pointer() != nil {
		return core.NewQVariantFromPointer(C.QTextFormat_Property(ptr.Pointer(), C.int(propertyId)))
	}
	return nil
}

func (ptr *QTextFormat) PropertyCount() int {
	defer qt.Recovering("QTextFormat::propertyCount")

	if ptr.Pointer() != nil {
		return int(C.QTextFormat_PropertyCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFormat) SetBackground(brush QBrush_ITF) {
	defer qt.Recovering("QTextFormat::setBackground")

	if ptr.Pointer() != nil {
		C.QTextFormat_SetBackground(ptr.Pointer(), PointerFromQBrush(brush))
	}
}

func (ptr *QTextFormat) SetForeground(brush QBrush_ITF) {
	defer qt.Recovering("QTextFormat::setForeground")

	if ptr.Pointer() != nil {
		C.QTextFormat_SetForeground(ptr.Pointer(), PointerFromQBrush(brush))
	}
}

func (ptr *QTextFormat) SetLayoutDirection(direction core.Qt__LayoutDirection) {
	defer qt.Recovering("QTextFormat::setLayoutDirection")

	if ptr.Pointer() != nil {
		C.QTextFormat_SetLayoutDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QTextFormat) SetObjectType(ty int) {
	defer qt.Recovering("QTextFormat::setObjectType")

	if ptr.Pointer() != nil {
		C.QTextFormat_SetObjectType(ptr.Pointer(), C.int(ty))
	}
}

func (ptr *QTextFormat) SetProperty(propertyId int, value core.QVariant_ITF) {
	defer qt.Recovering("QTextFormat::setProperty")

	if ptr.Pointer() != nil {
		C.QTextFormat_SetProperty(ptr.Pointer(), C.int(propertyId), core.PointerFromQVariant(value))
	}
}

func (ptr *QTextFormat) StringProperty(propertyId int) string {
	defer qt.Recovering("QTextFormat::stringProperty")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextFormat_StringProperty(ptr.Pointer(), C.int(propertyId)))
	}
	return ""
}

func (ptr *QTextFormat) Swap(other QTextFormat_ITF) {
	defer qt.Recovering("QTextFormat::swap")

	if ptr.Pointer() != nil {
		C.QTextFormat_Swap(ptr.Pointer(), PointerFromQTextFormat(other))
	}
}

func (ptr *QTextFormat) Type() int {
	defer qt.Recovering("QTextFormat::type")

	if ptr.Pointer() != nil {
		return int(C.QTextFormat_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFormat) DestroyQTextFormat() {
	defer qt.Recovering("QTextFormat::~QTextFormat")

	if ptr.Pointer() != nil {
		C.QTextFormat_DestroyQTextFormat(ptr.Pointer())
	}
}

type QTextFragment struct {
	ptr unsafe.Pointer
}

type QTextFragment_ITF interface {
	QTextFragment_PTR() *QTextFragment
}

func (p *QTextFragment) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextFragment) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextFragment(ptr QTextFragment_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextFragment_PTR().Pointer()
	}
	return nil
}

func NewQTextFragmentFromPointer(ptr unsafe.Pointer) *QTextFragment {
	var n = new(QTextFragment)
	n.SetPointer(ptr)
	return n
}

func newQTextFragmentFromPointer(ptr unsafe.Pointer) *QTextFragment {
	var n = NewQTextFragmentFromPointer(ptr)
	return n
}

func (ptr *QTextFragment) QTextFragment_PTR() *QTextFragment {
	return ptr
}

func NewQTextFragment() *QTextFragment {
	defer qt.Recovering("QTextFragment::QTextFragment")

	return newQTextFragmentFromPointer(C.QTextFragment_NewQTextFragment())
}

func NewQTextFragment3(other QTextFragment_ITF) *QTextFragment {
	defer qt.Recovering("QTextFragment::QTextFragment")

	return newQTextFragmentFromPointer(C.QTextFragment_NewQTextFragment3(PointerFromQTextFragment(other)))
}

func (ptr *QTextFragment) CharFormatIndex() int {
	defer qt.Recovering("QTextFragment::charFormatIndex")

	if ptr.Pointer() != nil {
		return int(C.QTextFragment_CharFormatIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFragment) Contains(position int) bool {
	defer qt.Recovering("QTextFragment::contains")

	if ptr.Pointer() != nil {
		return C.QTextFragment_Contains(ptr.Pointer(), C.int(position)) != 0
	}
	return false
}

func (ptr *QTextFragment) IsValid() bool {
	defer qt.Recovering("QTextFragment::isValid")

	if ptr.Pointer() != nil {
		return C.QTextFragment_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFragment) Length() int {
	defer qt.Recovering("QTextFragment::length")

	if ptr.Pointer() != nil {
		return int(C.QTextFragment_Length(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFragment) Position() int {
	defer qt.Recovering("QTextFragment::position")

	if ptr.Pointer() != nil {
		return int(C.QTextFragment_Position(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFragment) Text() string {
	defer qt.Recovering("QTextFragment::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextFragment_Text(ptr.Pointer()))
	}
	return ""
}

type QTextFrame struct {
	QTextObject
}

type QTextFrame_ITF interface {
	QTextObject_ITF
	QTextFrame_PTR() *QTextFrame
}

func PointerFromQTextFrame(ptr QTextFrame_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextFrame_PTR().Pointer()
	}
	return nil
}

func NewQTextFrameFromPointer(ptr unsafe.Pointer) *QTextFrame {
	var n = new(QTextFrame)
	n.SetPointer(ptr)
	return n
}

func newQTextFrameFromPointer(ptr unsafe.Pointer) *QTextFrame {
	var n = NewQTextFrameFromPointer(ptr)
	for len(n.ObjectName()) < len("QTextFrame_") {
		n.SetObjectName("QTextFrame_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextFrame) QTextFrame_PTR() *QTextFrame {
	return ptr
}

func NewQTextFrame(document QTextDocument_ITF) *QTextFrame {
	defer qt.Recovering("QTextFrame::QTextFrame")

	return newQTextFrameFromPointer(C.QTextFrame_NewQTextFrame(PointerFromQTextDocument(document)))
}

func (ptr *QTextFrame) FirstPosition() int {
	defer qt.Recovering("QTextFrame::firstPosition")

	if ptr.Pointer() != nil {
		return int(C.QTextFrame_FirstPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrame) LastPosition() int {
	defer qt.Recovering("QTextFrame::lastPosition")

	if ptr.Pointer() != nil {
		return int(C.QTextFrame_LastPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrame) ParentFrame() *QTextFrame {
	defer qt.Recovering("QTextFrame::parentFrame")

	if ptr.Pointer() != nil {
		return NewQTextFrameFromPointer(C.QTextFrame_ParentFrame(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextFrame) SetFrameFormat(format QTextFrameFormat_ITF) {
	defer qt.Recovering("QTextFrame::setFrameFormat")

	if ptr.Pointer() != nil {
		C.QTextFrame_SetFrameFormat(ptr.Pointer(), PointerFromQTextFrameFormat(format))
	}
}

func (ptr *QTextFrame) DestroyQTextFrame() {
	defer qt.Recovering("QTextFrame::~QTextFrame")

	if ptr.Pointer() != nil {
		C.QTextFrame_DestroyQTextFrame(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QTextFrame) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QTextFrame::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTextFrame) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTextFrame::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTextFrameTimerEvent
func callbackQTextFrameTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextFrame::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQTextFrameFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QTextFrame) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextFrame::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextFrame_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextFrame) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextFrame::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextFrame_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextFrame) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QTextFrame::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTextFrame) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTextFrame::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTextFrameChildEvent
func callbackQTextFrameChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextFrame::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQTextFrameFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QTextFrame) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextFrame::childEvent")

	if ptr.Pointer() != nil {
		C.QTextFrame_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextFrame) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextFrame::childEvent")

	if ptr.Pointer() != nil {
		C.QTextFrame_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextFrame) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QTextFrame::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTextFrame) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTextFrame::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTextFrameCustomEvent
func callbackQTextFrameCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextFrame::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQTextFrameFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QTextFrame) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QTextFrame::customEvent")

	if ptr.Pointer() != nil {
		C.QTextFrame_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QTextFrame) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QTextFrame::customEvent")

	if ptr.Pointer() != nil {
		C.QTextFrame_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QTextFrameFormat struct {
	QTextFormat
}

type QTextFrameFormat_ITF interface {
	QTextFormat_ITF
	QTextFrameFormat_PTR() *QTextFrameFormat
}

func PointerFromQTextFrameFormat(ptr QTextFrameFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextFrameFormat_PTR().Pointer()
	}
	return nil
}

func NewQTextFrameFormatFromPointer(ptr unsafe.Pointer) *QTextFrameFormat {
	var n = new(QTextFrameFormat)
	n.SetPointer(ptr)
	return n
}

func newQTextFrameFormatFromPointer(ptr unsafe.Pointer) *QTextFrameFormat {
	var n = NewQTextFrameFormatFromPointer(ptr)
	return n
}

func (ptr *QTextFrameFormat) QTextFrameFormat_PTR() *QTextFrameFormat {
	return ptr
}

//QTextFrameFormat::BorderStyle
type QTextFrameFormat__BorderStyle int64

var (
	QTextFrameFormat__BorderStyle_None       = QTextFrameFormat__BorderStyle(0)
	QTextFrameFormat__BorderStyle_Dotted     = QTextFrameFormat__BorderStyle(1)
	QTextFrameFormat__BorderStyle_Dashed     = QTextFrameFormat__BorderStyle(2)
	QTextFrameFormat__BorderStyle_Solid      = QTextFrameFormat__BorderStyle(3)
	QTextFrameFormat__BorderStyle_Double     = QTextFrameFormat__BorderStyle(4)
	QTextFrameFormat__BorderStyle_DotDash    = QTextFrameFormat__BorderStyle(5)
	QTextFrameFormat__BorderStyle_DotDotDash = QTextFrameFormat__BorderStyle(6)
	QTextFrameFormat__BorderStyle_Groove     = QTextFrameFormat__BorderStyle(7)
	QTextFrameFormat__BorderStyle_Ridge      = QTextFrameFormat__BorderStyle(8)
	QTextFrameFormat__BorderStyle_Inset      = QTextFrameFormat__BorderStyle(9)
	QTextFrameFormat__BorderStyle_Outset     = QTextFrameFormat__BorderStyle(10)
)

//QTextFrameFormat::Position
type QTextFrameFormat__Position int64

const (
	QTextFrameFormat__InFlow     = QTextFrameFormat__Position(0)
	QTextFrameFormat__FloatLeft  = QTextFrameFormat__Position(1)
	QTextFrameFormat__FloatRight = QTextFrameFormat__Position(2)
)

func NewQTextFrameFormat() *QTextFrameFormat {
	defer qt.Recovering("QTextFrameFormat::QTextFrameFormat")

	return newQTextFrameFormatFromPointer(C.QTextFrameFormat_NewQTextFrameFormat())
}

func (ptr *QTextFrameFormat) BottomMargin() float64 {
	defer qt.Recovering("QTextFrameFormat::bottomMargin")

	if ptr.Pointer() != nil {
		return float64(C.QTextFrameFormat_BottomMargin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) LeftMargin() float64 {
	defer qt.Recovering("QTextFrameFormat::leftMargin")

	if ptr.Pointer() != nil {
		return float64(C.QTextFrameFormat_LeftMargin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) RightMargin() float64 {
	defer qt.Recovering("QTextFrameFormat::rightMargin")

	if ptr.Pointer() != nil {
		return float64(C.QTextFrameFormat_RightMargin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) SetMargin(margin float64) {
	defer qt.Recovering("QTextFrameFormat::setMargin")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextFrameFormat) TopMargin() float64 {
	defer qt.Recovering("QTextFrameFormat::topMargin")

	if ptr.Pointer() != nil {
		return float64(C.QTextFrameFormat_TopMargin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) Border() float64 {
	defer qt.Recovering("QTextFrameFormat::border")

	if ptr.Pointer() != nil {
		return float64(C.QTextFrameFormat_Border(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) BorderBrush() *QBrush {
	defer qt.Recovering("QTextFrameFormat::borderBrush")

	if ptr.Pointer() != nil {
		return NewQBrushFromPointer(C.QTextFrameFormat_BorderBrush(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextFrameFormat) BorderStyle() QTextFrameFormat__BorderStyle {
	defer qt.Recovering("QTextFrameFormat::borderStyle")

	if ptr.Pointer() != nil {
		return QTextFrameFormat__BorderStyle(C.QTextFrameFormat_BorderStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) IsValid() bool {
	defer qt.Recovering("QTextFrameFormat::isValid")

	if ptr.Pointer() != nil {
		return C.QTextFrameFormat_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextFrameFormat) Margin() float64 {
	defer qt.Recovering("QTextFrameFormat::margin")

	if ptr.Pointer() != nil {
		return float64(C.QTextFrameFormat_Margin(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) Padding() float64 {
	defer qt.Recovering("QTextFrameFormat::padding")

	if ptr.Pointer() != nil {
		return float64(C.QTextFrameFormat_Padding(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) PageBreakPolicy() QTextFormat__PageBreakFlag {
	defer qt.Recovering("QTextFrameFormat::pageBreakPolicy")

	if ptr.Pointer() != nil {
		return QTextFormat__PageBreakFlag(C.QTextFrameFormat_PageBreakPolicy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) Position() QTextFrameFormat__Position {
	defer qt.Recovering("QTextFrameFormat::position")

	if ptr.Pointer() != nil {
		return QTextFrameFormat__Position(C.QTextFrameFormat_Position(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextFrameFormat) SetBorder(width float64) {
	defer qt.Recovering("QTextFrameFormat::setBorder")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetBorder(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QTextFrameFormat) SetBorderBrush(brush QBrush_ITF) {
	defer qt.Recovering("QTextFrameFormat::setBorderBrush")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetBorderBrush(ptr.Pointer(), PointerFromQBrush(brush))
	}
}

func (ptr *QTextFrameFormat) SetBorderStyle(style QTextFrameFormat__BorderStyle) {
	defer qt.Recovering("QTextFrameFormat::setBorderStyle")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetBorderStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QTextFrameFormat) SetBottomMargin(margin float64) {
	defer qt.Recovering("QTextFrameFormat::setBottomMargin")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetBottomMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextFrameFormat) SetHeight(height QTextLength_ITF) {
	defer qt.Recovering("QTextFrameFormat::setHeight")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetHeight(ptr.Pointer(), PointerFromQTextLength(height))
	}
}

func (ptr *QTextFrameFormat) SetHeight2(height float64) {
	defer qt.Recovering("QTextFrameFormat::setHeight")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetHeight2(ptr.Pointer(), C.double(height))
	}
}

func (ptr *QTextFrameFormat) SetLeftMargin(margin float64) {
	defer qt.Recovering("QTextFrameFormat::setLeftMargin")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetLeftMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextFrameFormat) SetPadding(width float64) {
	defer qt.Recovering("QTextFrameFormat::setPadding")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetPadding(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QTextFrameFormat) SetPageBreakPolicy(policy QTextFormat__PageBreakFlag) {
	defer qt.Recovering("QTextFrameFormat::setPageBreakPolicy")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetPageBreakPolicy(ptr.Pointer(), C.int(policy))
	}
}

func (ptr *QTextFrameFormat) SetPosition(policy QTextFrameFormat__Position) {
	defer qt.Recovering("QTextFrameFormat::setPosition")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetPosition(ptr.Pointer(), C.int(policy))
	}
}

func (ptr *QTextFrameFormat) SetRightMargin(margin float64) {
	defer qt.Recovering("QTextFrameFormat::setRightMargin")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetRightMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextFrameFormat) SetTopMargin(margin float64) {
	defer qt.Recovering("QTextFrameFormat::setTopMargin")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetTopMargin(ptr.Pointer(), C.double(margin))
	}
}

func (ptr *QTextFrameFormat) SetWidth(width QTextLength_ITF) {
	defer qt.Recovering("QTextFrameFormat::setWidth")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetWidth(ptr.Pointer(), PointerFromQTextLength(width))
	}
}

func (ptr *QTextFrameFormat) SetWidth2(width float64) {
	defer qt.Recovering("QTextFrameFormat::setWidth")

	if ptr.Pointer() != nil {
		C.QTextFrameFormat_SetWidth2(ptr.Pointer(), C.double(width))
	}
}

type QTextImageFormat struct {
	QTextCharFormat
}

type QTextImageFormat_ITF interface {
	QTextCharFormat_ITF
	QTextImageFormat_PTR() *QTextImageFormat
}

func PointerFromQTextImageFormat(ptr QTextImageFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextImageFormat_PTR().Pointer()
	}
	return nil
}

func NewQTextImageFormatFromPointer(ptr unsafe.Pointer) *QTextImageFormat {
	var n = new(QTextImageFormat)
	n.SetPointer(ptr)
	return n
}

func newQTextImageFormatFromPointer(ptr unsafe.Pointer) *QTextImageFormat {
	var n = NewQTextImageFormatFromPointer(ptr)
	return n
}

func (ptr *QTextImageFormat) QTextImageFormat_PTR() *QTextImageFormat {
	return ptr
}

func NewQTextImageFormat() *QTextImageFormat {
	defer qt.Recovering("QTextImageFormat::QTextImageFormat")

	return newQTextImageFormatFromPointer(C.QTextImageFormat_NewQTextImageFormat())
}

func (ptr *QTextImageFormat) Height() float64 {
	defer qt.Recovering("QTextImageFormat::height")

	if ptr.Pointer() != nil {
		return float64(C.QTextImageFormat_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextImageFormat) IsValid() bool {
	defer qt.Recovering("QTextImageFormat::isValid")

	if ptr.Pointer() != nil {
		return C.QTextImageFormat_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextImageFormat) Name() string {
	defer qt.Recovering("QTextImageFormat::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextImageFormat_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextImageFormat) SetHeight(height float64) {
	defer qt.Recovering("QTextImageFormat::setHeight")

	if ptr.Pointer() != nil {
		C.QTextImageFormat_SetHeight(ptr.Pointer(), C.double(height))
	}
}

func (ptr *QTextImageFormat) SetName(name string) {
	defer qt.Recovering("QTextImageFormat::setName")

	if ptr.Pointer() != nil {
		C.QTextImageFormat_SetName(ptr.Pointer(), C.CString(name))
	}
}

func (ptr *QTextImageFormat) SetWidth(width float64) {
	defer qt.Recovering("QTextImageFormat::setWidth")

	if ptr.Pointer() != nil {
		C.QTextImageFormat_SetWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QTextImageFormat) Width() float64 {
	defer qt.Recovering("QTextImageFormat::width")

	if ptr.Pointer() != nil {
		return float64(C.QTextImageFormat_Width(ptr.Pointer()))
	}
	return 0
}

type QTextInlineObject struct {
	ptr unsafe.Pointer
}

type QTextInlineObject_ITF interface {
	QTextInlineObject_PTR() *QTextInlineObject
}

func (p *QTextInlineObject) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextInlineObject) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextInlineObject(ptr QTextInlineObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextInlineObject_PTR().Pointer()
	}
	return nil
}

func NewQTextInlineObjectFromPointer(ptr unsafe.Pointer) *QTextInlineObject {
	var n = new(QTextInlineObject)
	n.SetPointer(ptr)
	return n
}

func newQTextInlineObjectFromPointer(ptr unsafe.Pointer) *QTextInlineObject {
	var n = NewQTextInlineObjectFromPointer(ptr)
	return n
}

func (ptr *QTextInlineObject) QTextInlineObject_PTR() *QTextInlineObject {
	return ptr
}

func (ptr *QTextInlineObject) Ascent() float64 {
	defer qt.Recovering("QTextInlineObject::ascent")

	if ptr.Pointer() != nil {
		return float64(C.QTextInlineObject_Ascent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextInlineObject) Descent() float64 {
	defer qt.Recovering("QTextInlineObject::descent")

	if ptr.Pointer() != nil {
		return float64(C.QTextInlineObject_Descent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextInlineObject) FormatIndex() int {
	defer qt.Recovering("QTextInlineObject::formatIndex")

	if ptr.Pointer() != nil {
		return int(C.QTextInlineObject_FormatIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextInlineObject) Height() float64 {
	defer qt.Recovering("QTextInlineObject::height")

	if ptr.Pointer() != nil {
		return float64(C.QTextInlineObject_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextInlineObject) IsValid() bool {
	defer qt.Recovering("QTextInlineObject::isValid")

	if ptr.Pointer() != nil {
		return C.QTextInlineObject_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextInlineObject) SetAscent(a float64) {
	defer qt.Recovering("QTextInlineObject::setAscent")

	if ptr.Pointer() != nil {
		C.QTextInlineObject_SetAscent(ptr.Pointer(), C.double(a))
	}
}

func (ptr *QTextInlineObject) SetDescent(d float64) {
	defer qt.Recovering("QTextInlineObject::setDescent")

	if ptr.Pointer() != nil {
		C.QTextInlineObject_SetDescent(ptr.Pointer(), C.double(d))
	}
}

func (ptr *QTextInlineObject) SetWidth(w float64) {
	defer qt.Recovering("QTextInlineObject::setWidth")

	if ptr.Pointer() != nil {
		C.QTextInlineObject_SetWidth(ptr.Pointer(), C.double(w))
	}
}

func (ptr *QTextInlineObject) TextDirection() core.Qt__LayoutDirection {
	defer qt.Recovering("QTextInlineObject::textDirection")

	if ptr.Pointer() != nil {
		return core.Qt__LayoutDirection(C.QTextInlineObject_TextDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextInlineObject) TextPosition() int {
	defer qt.Recovering("QTextInlineObject::textPosition")

	if ptr.Pointer() != nil {
		return int(C.QTextInlineObject_TextPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextInlineObject) Width() float64 {
	defer qt.Recovering("QTextInlineObject::width")

	if ptr.Pointer() != nil {
		return float64(C.QTextInlineObject_Width(ptr.Pointer()))
	}
	return 0
}

type QTextItem struct {
	ptr unsafe.Pointer
}

type QTextItem_ITF interface {
	QTextItem_PTR() *QTextItem
}

func (p *QTextItem) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextItem) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextItem(ptr QTextItem_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextItem_PTR().Pointer()
	}
	return nil
}

func NewQTextItemFromPointer(ptr unsafe.Pointer) *QTextItem {
	var n = new(QTextItem)
	n.SetPointer(ptr)
	return n
}

func newQTextItemFromPointer(ptr unsafe.Pointer) *QTextItem {
	var n = NewQTextItemFromPointer(ptr)
	return n
}

func (ptr *QTextItem) QTextItem_PTR() *QTextItem {
	return ptr
}

//QTextItem::RenderFlag
type QTextItem__RenderFlag int64

const (
	QTextItem__RightToLeft = QTextItem__RenderFlag(0x1)
	QTextItem__Overline    = QTextItem__RenderFlag(0x10)
	QTextItem__Underline   = QTextItem__RenderFlag(0x20)
	QTextItem__StrikeOut   = QTextItem__RenderFlag(0x40)
	QTextItem__Dummy       = QTextItem__RenderFlag(0xffffffff)
)

func (ptr *QTextItem) Ascent() float64 {
	defer qt.Recovering("QTextItem::ascent")

	if ptr.Pointer() != nil {
		return float64(C.QTextItem_Ascent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextItem) Descent() float64 {
	defer qt.Recovering("QTextItem::descent")

	if ptr.Pointer() != nil {
		return float64(C.QTextItem_Descent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextItem) RenderFlags() QTextItem__RenderFlag {
	defer qt.Recovering("QTextItem::renderFlags")

	if ptr.Pointer() != nil {
		return QTextItem__RenderFlag(C.QTextItem_RenderFlags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextItem) Text() string {
	defer qt.Recovering("QTextItem::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextItem_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextItem) Width() float64 {
	defer qt.Recovering("QTextItem::width")

	if ptr.Pointer() != nil {
		return float64(C.QTextItem_Width(ptr.Pointer()))
	}
	return 0
}

type QTextLayout struct {
	ptr unsafe.Pointer
}

type QTextLayout_ITF interface {
	QTextLayout_PTR() *QTextLayout
}

func (p *QTextLayout) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextLayout) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextLayout(ptr QTextLayout_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextLayout_PTR().Pointer()
	}
	return nil
}

func NewQTextLayoutFromPointer(ptr unsafe.Pointer) *QTextLayout {
	var n = new(QTextLayout)
	n.SetPointer(ptr)
	return n
}

func newQTextLayoutFromPointer(ptr unsafe.Pointer) *QTextLayout {
	var n = NewQTextLayoutFromPointer(ptr)
	return n
}

func (ptr *QTextLayout) QTextLayout_PTR() *QTextLayout {
	return ptr
}

//QTextLayout::CursorMode
type QTextLayout__CursorMode int64

const (
	QTextLayout__SkipCharacters = QTextLayout__CursorMode(0)
	QTextLayout__SkipWords      = QTextLayout__CursorMode(1)
)

func (ptr *QTextLayout) DrawCursor2(painter QPainter_ITF, position core.QPointF_ITF, cursorPosition int) {
	defer qt.Recovering("QTextLayout::drawCursor")

	if ptr.Pointer() != nil {
		C.QTextLayout_DrawCursor2(ptr.Pointer(), PointerFromQPainter(painter), core.PointerFromQPointF(position), C.int(cursorPosition))
	}
}

func (ptr *QTextLayout) DrawCursor(painter QPainter_ITF, position core.QPointF_ITF, cursorPosition int, width int) {
	defer qt.Recovering("QTextLayout::drawCursor")

	if ptr.Pointer() != nil {
		C.QTextLayout_DrawCursor(ptr.Pointer(), PointerFromQPainter(painter), core.PointerFromQPointF(position), C.int(cursorPosition), C.int(width))
	}
}

func NewQTextLayout() *QTextLayout {
	defer qt.Recovering("QTextLayout::QTextLayout")

	return newQTextLayoutFromPointer(C.QTextLayout_NewQTextLayout())
}

func NewQTextLayout2(text string) *QTextLayout {
	defer qt.Recovering("QTextLayout::QTextLayout")

	return newQTextLayoutFromPointer(C.QTextLayout_NewQTextLayout2(C.CString(text)))
}

func NewQTextLayout3(text string, font QFont_ITF, paintdevice QPaintDevice_ITF) *QTextLayout {
	defer qt.Recovering("QTextLayout::QTextLayout")

	return newQTextLayoutFromPointer(C.QTextLayout_NewQTextLayout3(C.CString(text), PointerFromQFont(font), PointerFromQPaintDevice(paintdevice)))
}

func (ptr *QTextLayout) BeginLayout() {
	defer qt.Recovering("QTextLayout::beginLayout")

	if ptr.Pointer() != nil {
		C.QTextLayout_BeginLayout(ptr.Pointer())
	}
}

func (ptr *QTextLayout) CacheEnabled() bool {
	defer qt.Recovering("QTextLayout::cacheEnabled")

	if ptr.Pointer() != nil {
		return C.QTextLayout_CacheEnabled(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextLayout) ClearAdditionalFormats() {
	defer qt.Recovering("QTextLayout::clearAdditionalFormats")

	if ptr.Pointer() != nil {
		C.QTextLayout_ClearAdditionalFormats(ptr.Pointer())
	}
}

func (ptr *QTextLayout) ClearLayout() {
	defer qt.Recovering("QTextLayout::clearLayout")

	if ptr.Pointer() != nil {
		C.QTextLayout_ClearLayout(ptr.Pointer())
	}
}

func (ptr *QTextLayout) CursorMoveStyle() core.Qt__CursorMoveStyle {
	defer qt.Recovering("QTextLayout::cursorMoveStyle")

	if ptr.Pointer() != nil {
		return core.Qt__CursorMoveStyle(C.QTextLayout_CursorMoveStyle(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLayout) EndLayout() {
	defer qt.Recovering("QTextLayout::endLayout")

	if ptr.Pointer() != nil {
		C.QTextLayout_EndLayout(ptr.Pointer())
	}
}

func (ptr *QTextLayout) IsValidCursorPosition(pos int) bool {
	defer qt.Recovering("QTextLayout::isValidCursorPosition")

	if ptr.Pointer() != nil {
		return C.QTextLayout_IsValidCursorPosition(ptr.Pointer(), C.int(pos)) != 0
	}
	return false
}

func (ptr *QTextLayout) LeftCursorPosition(oldPos int) int {
	defer qt.Recovering("QTextLayout::leftCursorPosition")

	if ptr.Pointer() != nil {
		return int(C.QTextLayout_LeftCursorPosition(ptr.Pointer(), C.int(oldPos)))
	}
	return 0
}

func (ptr *QTextLayout) LineCount() int {
	defer qt.Recovering("QTextLayout::lineCount")

	if ptr.Pointer() != nil {
		return int(C.QTextLayout_LineCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLayout) MaximumWidth() float64 {
	defer qt.Recovering("QTextLayout::maximumWidth")

	if ptr.Pointer() != nil {
		return float64(C.QTextLayout_MaximumWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLayout) MinimumWidth() float64 {
	defer qt.Recovering("QTextLayout::minimumWidth")

	if ptr.Pointer() != nil {
		return float64(C.QTextLayout_MinimumWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLayout) NextCursorPosition(oldPos int, mode QTextLayout__CursorMode) int {
	defer qt.Recovering("QTextLayout::nextCursorPosition")

	if ptr.Pointer() != nil {
		return int(C.QTextLayout_NextCursorPosition(ptr.Pointer(), C.int(oldPos), C.int(mode)))
	}
	return 0
}

func (ptr *QTextLayout) PreeditAreaPosition() int {
	defer qt.Recovering("QTextLayout::preeditAreaPosition")

	if ptr.Pointer() != nil {
		return int(C.QTextLayout_PreeditAreaPosition(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLayout) PreeditAreaText() string {
	defer qt.Recovering("QTextLayout::preeditAreaText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextLayout_PreeditAreaText(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextLayout) PreviousCursorPosition(oldPos int, mode QTextLayout__CursorMode) int {
	defer qt.Recovering("QTextLayout::previousCursorPosition")

	if ptr.Pointer() != nil {
		return int(C.QTextLayout_PreviousCursorPosition(ptr.Pointer(), C.int(oldPos), C.int(mode)))
	}
	return 0
}

func (ptr *QTextLayout) RightCursorPosition(oldPos int) int {
	defer qt.Recovering("QTextLayout::rightCursorPosition")

	if ptr.Pointer() != nil {
		return int(C.QTextLayout_RightCursorPosition(ptr.Pointer(), C.int(oldPos)))
	}
	return 0
}

func (ptr *QTextLayout) SetCacheEnabled(enable bool) {
	defer qt.Recovering("QTextLayout::setCacheEnabled")

	if ptr.Pointer() != nil {
		C.QTextLayout_SetCacheEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QTextLayout) SetCursorMoveStyle(style core.Qt__CursorMoveStyle) {
	defer qt.Recovering("QTextLayout::setCursorMoveStyle")

	if ptr.Pointer() != nil {
		C.QTextLayout_SetCursorMoveStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QTextLayout) SetFont(font QFont_ITF) {
	defer qt.Recovering("QTextLayout::setFont")

	if ptr.Pointer() != nil {
		C.QTextLayout_SetFont(ptr.Pointer(), PointerFromQFont(font))
	}
}

func (ptr *QTextLayout) SetPosition(p core.QPointF_ITF) {
	defer qt.Recovering("QTextLayout::setPosition")

	if ptr.Pointer() != nil {
		C.QTextLayout_SetPosition(ptr.Pointer(), core.PointerFromQPointF(p))
	}
}

func (ptr *QTextLayout) SetPreeditArea(position int, text string) {
	defer qt.Recovering("QTextLayout::setPreeditArea")

	if ptr.Pointer() != nil {
		C.QTextLayout_SetPreeditArea(ptr.Pointer(), C.int(position), C.CString(text))
	}
}

func (ptr *QTextLayout) SetText(stri string) {
	defer qt.Recovering("QTextLayout::setText")

	if ptr.Pointer() != nil {
		C.QTextLayout_SetText(ptr.Pointer(), C.CString(stri))
	}
}

func (ptr *QTextLayout) SetTextOption(option QTextOption_ITF) {
	defer qt.Recovering("QTextLayout::setTextOption")

	if ptr.Pointer() != nil {
		C.QTextLayout_SetTextOption(ptr.Pointer(), PointerFromQTextOption(option))
	}
}

func (ptr *QTextLayout) Text() string {
	defer qt.Recovering("QTextLayout::text")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextLayout_Text(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextLayout) DestroyQTextLayout() {
	defer qt.Recovering("QTextLayout::~QTextLayout")

	if ptr.Pointer() != nil {
		C.QTextLayout_DestroyQTextLayout(ptr.Pointer())
	}
}

type QTextLength struct {
	ptr unsafe.Pointer
}

type QTextLength_ITF interface {
	QTextLength_PTR() *QTextLength
}

func (p *QTextLength) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextLength) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextLength(ptr QTextLength_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextLength_PTR().Pointer()
	}
	return nil
}

func NewQTextLengthFromPointer(ptr unsafe.Pointer) *QTextLength {
	var n = new(QTextLength)
	n.SetPointer(ptr)
	return n
}

func newQTextLengthFromPointer(ptr unsafe.Pointer) *QTextLength {
	var n = NewQTextLengthFromPointer(ptr)
	return n
}

func (ptr *QTextLength) QTextLength_PTR() *QTextLength {
	return ptr
}

//QTextLength::Type
type QTextLength__Type int64

const (
	QTextLength__VariableLength   = QTextLength__Type(0)
	QTextLength__FixedLength      = QTextLength__Type(1)
	QTextLength__PercentageLength = QTextLength__Type(2)
)

func NewQTextLength() *QTextLength {
	defer qt.Recovering("QTextLength::QTextLength")

	return newQTextLengthFromPointer(C.QTextLength_NewQTextLength())
}

func NewQTextLength2(ty QTextLength__Type, value float64) *QTextLength {
	defer qt.Recovering("QTextLength::QTextLength")

	return newQTextLengthFromPointer(C.QTextLength_NewQTextLength2(C.int(ty), C.double(value)))
}

func (ptr *QTextLength) RawValue() float64 {
	defer qt.Recovering("QTextLength::rawValue")

	if ptr.Pointer() != nil {
		return float64(C.QTextLength_RawValue(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLength) Type() QTextLength__Type {
	defer qt.Recovering("QTextLength::type")

	if ptr.Pointer() != nil {
		return QTextLength__Type(C.QTextLength_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLength) Value(maximumLength float64) float64 {
	defer qt.Recovering("QTextLength::value")

	if ptr.Pointer() != nil {
		return float64(C.QTextLength_Value(ptr.Pointer(), C.double(maximumLength)))
	}
	return 0
}

type QTextLine struct {
	ptr unsafe.Pointer
}

type QTextLine_ITF interface {
	QTextLine_PTR() *QTextLine
}

func (p *QTextLine) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextLine) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextLine(ptr QTextLine_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextLine_PTR().Pointer()
	}
	return nil
}

func NewQTextLineFromPointer(ptr unsafe.Pointer) *QTextLine {
	var n = new(QTextLine)
	n.SetPointer(ptr)
	return n
}

func newQTextLineFromPointer(ptr unsafe.Pointer) *QTextLine {
	var n = NewQTextLineFromPointer(ptr)
	return n
}

func (ptr *QTextLine) QTextLine_PTR() *QTextLine {
	return ptr
}

//QTextLine::CursorPosition
type QTextLine__CursorPosition int64

const (
	QTextLine__CursorBetweenCharacters = QTextLine__CursorPosition(0)
	QTextLine__CursorOnCharacter       = QTextLine__CursorPosition(1)
)

//QTextLine::Edge
type QTextLine__Edge int64

const (
	QTextLine__Leading  = QTextLine__Edge(0)
	QTextLine__Trailing = QTextLine__Edge(1)
)

func (ptr *QTextLine) XToCursor(x float64, cpos QTextLine__CursorPosition) int {
	defer qt.Recovering("QTextLine::xToCursor")

	if ptr.Pointer() != nil {
		return int(C.QTextLine_XToCursor(ptr.Pointer(), C.double(x), C.int(cpos)))
	}
	return 0
}

func NewQTextLine() *QTextLine {
	defer qt.Recovering("QTextLine::QTextLine")

	return newQTextLineFromPointer(C.QTextLine_NewQTextLine())
}

func (ptr *QTextLine) Ascent() float64 {
	defer qt.Recovering("QTextLine::ascent")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_Ascent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) CursorToX(cursorPos int, edge QTextLine__Edge) float64 {
	defer qt.Recovering("QTextLine::cursorToX")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_CursorToX(ptr.Pointer(), C.int(cursorPos), C.int(edge)))
	}
	return 0
}

func (ptr *QTextLine) CursorToX2(cursorPos int, edge QTextLine__Edge) float64 {
	defer qt.Recovering("QTextLine::cursorToX")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_CursorToX2(ptr.Pointer(), C.int(cursorPos), C.int(edge)))
	}
	return 0
}

func (ptr *QTextLine) Descent() float64 {
	defer qt.Recovering("QTextLine::descent")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_Descent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) Height() float64 {
	defer qt.Recovering("QTextLine::height")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) HorizontalAdvance() float64 {
	defer qt.Recovering("QTextLine::horizontalAdvance")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_HorizontalAdvance(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) IsValid() bool {
	defer qt.Recovering("QTextLine::isValid")

	if ptr.Pointer() != nil {
		return C.QTextLine_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextLine) Leading() float64 {
	defer qt.Recovering("QTextLine::leading")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_Leading(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) LeadingIncluded() bool {
	defer qt.Recovering("QTextLine::leadingIncluded")

	if ptr.Pointer() != nil {
		return C.QTextLine_LeadingIncluded(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextLine) LineNumber() int {
	defer qt.Recovering("QTextLine::lineNumber")

	if ptr.Pointer() != nil {
		return int(C.QTextLine_LineNumber(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) NaturalTextWidth() float64 {
	defer qt.Recovering("QTextLine::naturalTextWidth")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_NaturalTextWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) SetLeadingIncluded(included bool) {
	defer qt.Recovering("QTextLine::setLeadingIncluded")

	if ptr.Pointer() != nil {
		C.QTextLine_SetLeadingIncluded(ptr.Pointer(), C.int(qt.GoBoolToInt(included)))
	}
}

func (ptr *QTextLine) SetLineWidth(width float64) {
	defer qt.Recovering("QTextLine::setLineWidth")

	if ptr.Pointer() != nil {
		C.QTextLine_SetLineWidth(ptr.Pointer(), C.double(width))
	}
}

func (ptr *QTextLine) SetNumColumns(numColumns int) {
	defer qt.Recovering("QTextLine::setNumColumns")

	if ptr.Pointer() != nil {
		C.QTextLine_SetNumColumns(ptr.Pointer(), C.int(numColumns))
	}
}

func (ptr *QTextLine) SetNumColumns2(numColumns int, alignmentWidth float64) {
	defer qt.Recovering("QTextLine::setNumColumns")

	if ptr.Pointer() != nil {
		C.QTextLine_SetNumColumns2(ptr.Pointer(), C.int(numColumns), C.double(alignmentWidth))
	}
}

func (ptr *QTextLine) SetPosition(pos core.QPointF_ITF) {
	defer qt.Recovering("QTextLine::setPosition")

	if ptr.Pointer() != nil {
		C.QTextLine_SetPosition(ptr.Pointer(), core.PointerFromQPointF(pos))
	}
}

func (ptr *QTextLine) TextLength() int {
	defer qt.Recovering("QTextLine::textLength")

	if ptr.Pointer() != nil {
		return int(C.QTextLine_TextLength(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) TextStart() int {
	defer qt.Recovering("QTextLine::textStart")

	if ptr.Pointer() != nil {
		return int(C.QTextLine_TextStart(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) Width() float64 {
	defer qt.Recovering("QTextLine::width")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_Width(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) X() float64 {
	defer qt.Recovering("QTextLine::x")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextLine) Y() float64 {
	defer qt.Recovering("QTextLine::y")

	if ptr.Pointer() != nil {
		return float64(C.QTextLine_Y(ptr.Pointer()))
	}
	return 0
}

type QTextList struct {
	QTextBlockGroup
}

type QTextList_ITF interface {
	QTextBlockGroup_ITF
	QTextList_PTR() *QTextList
}

func PointerFromQTextList(ptr QTextList_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextList_PTR().Pointer()
	}
	return nil
}

func NewQTextListFromPointer(ptr unsafe.Pointer) *QTextList {
	var n = new(QTextList)
	n.SetPointer(ptr)
	return n
}

func newQTextListFromPointer(ptr unsafe.Pointer) *QTextList {
	var n = NewQTextListFromPointer(ptr)
	for len(n.ObjectName()) < len("QTextList_") {
		n.SetObjectName("QTextList_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextList) QTextList_PTR() *QTextList {
	return ptr
}

func (ptr *QTextList) ItemNumber(block QTextBlock_ITF) int {
	defer qt.Recovering("QTextList::itemNumber")

	if ptr.Pointer() != nil {
		return int(C.QTextList_ItemNumber(ptr.Pointer(), PointerFromQTextBlock(block)))
	}
	return 0
}

func (ptr *QTextList) ItemText(block QTextBlock_ITF) string {
	defer qt.Recovering("QTextList::itemText")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextList_ItemText(ptr.Pointer(), PointerFromQTextBlock(block)))
	}
	return ""
}

func (ptr *QTextList) Add(block QTextBlock_ITF) {
	defer qt.Recovering("QTextList::add")

	if ptr.Pointer() != nil {
		C.QTextList_Add(ptr.Pointer(), PointerFromQTextBlock(block))
	}
}

func (ptr *QTextList) Count() int {
	defer qt.Recovering("QTextList::count")

	if ptr.Pointer() != nil {
		return int(C.QTextList_Count(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextList) RemoveItem(i int) {
	defer qt.Recovering("QTextList::removeItem")

	if ptr.Pointer() != nil {
		C.QTextList_RemoveItem(ptr.Pointer(), C.int(i))
	}
}

func (ptr *QTextList) SetFormat(format QTextListFormat_ITF) {
	defer qt.Recovering("QTextList::setFormat")

	if ptr.Pointer() != nil {
		C.QTextList_SetFormat(ptr.Pointer(), PointerFromQTextListFormat(format))
	}
}

func (ptr *QTextList) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QTextList::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTextList) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTextList::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTextListTimerEvent
func callbackQTextListTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextList::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQTextListFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QTextList) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextList::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextList_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextList) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextList::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextList_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextList) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QTextList::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTextList) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTextList::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTextListChildEvent
func callbackQTextListChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextList::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQTextListFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QTextList) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextList::childEvent")

	if ptr.Pointer() != nil {
		C.QTextList_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextList) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextList::childEvent")

	if ptr.Pointer() != nil {
		C.QTextList_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextList) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QTextList::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTextList) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTextList::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTextListCustomEvent
func callbackQTextListCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextList::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQTextListFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QTextList) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QTextList::customEvent")

	if ptr.Pointer() != nil {
		C.QTextList_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QTextList) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QTextList::customEvent")

	if ptr.Pointer() != nil {
		C.QTextList_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QTextListFormat struct {
	QTextFormat
}

type QTextListFormat_ITF interface {
	QTextFormat_ITF
	QTextListFormat_PTR() *QTextListFormat
}

func PointerFromQTextListFormat(ptr QTextListFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextListFormat_PTR().Pointer()
	}
	return nil
}

func NewQTextListFormatFromPointer(ptr unsafe.Pointer) *QTextListFormat {
	var n = new(QTextListFormat)
	n.SetPointer(ptr)
	return n
}

func newQTextListFormatFromPointer(ptr unsafe.Pointer) *QTextListFormat {
	var n = NewQTextListFormatFromPointer(ptr)
	return n
}

func (ptr *QTextListFormat) QTextListFormat_PTR() *QTextListFormat {
	return ptr
}

//QTextListFormat::Style
type QTextListFormat__Style int64

var (
	QTextListFormat__ListDisc           = QTextListFormat__Style(-1)
	QTextListFormat__ListCircle         = QTextListFormat__Style(-2)
	QTextListFormat__ListSquare         = QTextListFormat__Style(-3)
	QTextListFormat__ListDecimal        = QTextListFormat__Style(-4)
	QTextListFormat__ListLowerAlpha     = QTextListFormat__Style(-5)
	QTextListFormat__ListUpperAlpha     = QTextListFormat__Style(-6)
	QTextListFormat__ListLowerRoman     = QTextListFormat__Style(-7)
	QTextListFormat__ListUpperRoman     = QTextListFormat__Style(-8)
	QTextListFormat__ListStyleUndefined = QTextListFormat__Style(0)
)

func NewQTextListFormat() *QTextListFormat {
	defer qt.Recovering("QTextListFormat::QTextListFormat")

	return newQTextListFormatFromPointer(C.QTextListFormat_NewQTextListFormat())
}

func (ptr *QTextListFormat) Indent() int {
	defer qt.Recovering("QTextListFormat::indent")

	if ptr.Pointer() != nil {
		return int(C.QTextListFormat_Indent(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextListFormat) IsValid() bool {
	defer qt.Recovering("QTextListFormat::isValid")

	if ptr.Pointer() != nil {
		return C.QTextListFormat_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextListFormat) NumberPrefix() string {
	defer qt.Recovering("QTextListFormat::numberPrefix")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextListFormat_NumberPrefix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextListFormat) NumberSuffix() string {
	defer qt.Recovering("QTextListFormat::numberSuffix")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextListFormat_NumberSuffix(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextListFormat) SetIndent(indentation int) {
	defer qt.Recovering("QTextListFormat::setIndent")

	if ptr.Pointer() != nil {
		C.QTextListFormat_SetIndent(ptr.Pointer(), C.int(indentation))
	}
}

func (ptr *QTextListFormat) SetNumberPrefix(numberPrefix string) {
	defer qt.Recovering("QTextListFormat::setNumberPrefix")

	if ptr.Pointer() != nil {
		C.QTextListFormat_SetNumberPrefix(ptr.Pointer(), C.CString(numberPrefix))
	}
}

func (ptr *QTextListFormat) SetNumberSuffix(numberSuffix string) {
	defer qt.Recovering("QTextListFormat::setNumberSuffix")

	if ptr.Pointer() != nil {
		C.QTextListFormat_SetNumberSuffix(ptr.Pointer(), C.CString(numberSuffix))
	}
}

func (ptr *QTextListFormat) SetStyle(style QTextListFormat__Style) {
	defer qt.Recovering("QTextListFormat::setStyle")

	if ptr.Pointer() != nil {
		C.QTextListFormat_SetStyle(ptr.Pointer(), C.int(style))
	}
}

func (ptr *QTextListFormat) Style() QTextListFormat__Style {
	defer qt.Recovering("QTextListFormat::style")

	if ptr.Pointer() != nil {
		return QTextListFormat__Style(C.QTextListFormat_Style(ptr.Pointer()))
	}
	return 0
}

type QTextObject struct {
	core.QObject
}

type QTextObject_ITF interface {
	core.QObject_ITF
	QTextObject_PTR() *QTextObject
}

func PointerFromQTextObject(ptr QTextObject_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextObject_PTR().Pointer()
	}
	return nil
}

func NewQTextObjectFromPointer(ptr unsafe.Pointer) *QTextObject {
	var n = new(QTextObject)
	n.SetPointer(ptr)
	return n
}

func newQTextObjectFromPointer(ptr unsafe.Pointer) *QTextObject {
	var n = NewQTextObjectFromPointer(ptr)
	for len(n.ObjectName()) < len("QTextObject_") {
		n.SetObjectName("QTextObject_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextObject) QTextObject_PTR() *QTextObject {
	return ptr
}

func (ptr *QTextObject) Document() *QTextDocument {
	defer qt.Recovering("QTextObject::document")

	if ptr.Pointer() != nil {
		return NewQTextDocumentFromPointer(C.QTextObject_Document(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTextObject) FormatIndex() int {
	defer qt.Recovering("QTextObject::formatIndex")

	if ptr.Pointer() != nil {
		return int(C.QTextObject_FormatIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextObject) ObjectIndex() int {
	defer qt.Recovering("QTextObject::objectIndex")

	if ptr.Pointer() != nil {
		return int(C.QTextObject_ObjectIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextObject) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QTextObject::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTextObject) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTextObject::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTextObjectTimerEvent
func callbackQTextObjectTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextObject::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQTextObjectFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QTextObject) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextObject::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextObject_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextObject) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextObject::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextObject_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextObject) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QTextObject::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTextObject) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTextObject::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTextObjectChildEvent
func callbackQTextObjectChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextObject::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQTextObjectFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QTextObject) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextObject::childEvent")

	if ptr.Pointer() != nil {
		C.QTextObject_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextObject) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextObject::childEvent")

	if ptr.Pointer() != nil {
		C.QTextObject_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextObject) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QTextObject::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTextObject) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTextObject::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTextObjectCustomEvent
func callbackQTextObjectCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextObject::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQTextObjectFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QTextObject) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QTextObject::customEvent")

	if ptr.Pointer() != nil {
		C.QTextObject_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QTextObject) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QTextObject::customEvent")

	if ptr.Pointer() != nil {
		C.QTextObject_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QTextObjectInterface struct {
	ptr unsafe.Pointer
}

type QTextObjectInterface_ITF interface {
	QTextObjectInterface_PTR() *QTextObjectInterface
}

func (p *QTextObjectInterface) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextObjectInterface) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextObjectInterface(ptr QTextObjectInterface_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextObjectInterface_PTR().Pointer()
	}
	return nil
}

func NewQTextObjectInterfaceFromPointer(ptr unsafe.Pointer) *QTextObjectInterface {
	var n = new(QTextObjectInterface)
	n.SetPointer(ptr)
	return n
}

func newQTextObjectInterfaceFromPointer(ptr unsafe.Pointer) *QTextObjectInterface {
	var n = NewQTextObjectInterfaceFromPointer(ptr)
	for len(n.ObjectNameAbs()) < len("QTextObjectInterface_") {
		n.SetObjectNameAbs("QTextObjectInterface_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextObjectInterface) QTextObjectInterface_PTR() *QTextObjectInterface {
	return ptr
}

func (ptr *QTextObjectInterface) DrawObject(painter QPainter_ITF, rect core.QRectF_ITF, doc QTextDocument_ITF, posInDocument int, format QTextFormat_ITF) {
	defer qt.Recovering("QTextObjectInterface::drawObject")

	if ptr.Pointer() != nil {
		C.QTextObjectInterface_DrawObject(ptr.Pointer(), PointerFromQPainter(painter), core.PointerFromQRectF(rect), PointerFromQTextDocument(doc), C.int(posInDocument), PointerFromQTextFormat(format))
	}
}

func (ptr *QTextObjectInterface) DestroyQTextObjectInterface() {
	defer qt.Recovering("QTextObjectInterface::~QTextObjectInterface")

	if ptr.Pointer() != nil {
		C.QTextObjectInterface_DestroyQTextObjectInterface(ptr.Pointer())
	}
}

func (ptr *QTextObjectInterface) ObjectNameAbs() string {
	defer qt.Recovering("QTextObjectInterface::objectNameAbs")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTextObjectInterface_ObjectNameAbs(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTextObjectInterface) SetObjectNameAbs(name string) {
	defer qt.Recovering("QTextObjectInterface::setObjectNameAbs")

	if ptr.Pointer() != nil {
		C.QTextObjectInterface_SetObjectNameAbs(ptr.Pointer(), C.CString(name))
	}
}

type QTextOption struct {
	ptr unsafe.Pointer
}

type QTextOption_ITF interface {
	QTextOption_PTR() *QTextOption
}

func (p *QTextOption) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextOption) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextOption(ptr QTextOption_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextOption_PTR().Pointer()
	}
	return nil
}

func NewQTextOptionFromPointer(ptr unsafe.Pointer) *QTextOption {
	var n = new(QTextOption)
	n.SetPointer(ptr)
	return n
}

func newQTextOptionFromPointer(ptr unsafe.Pointer) *QTextOption {
	var n = NewQTextOptionFromPointer(ptr)
	return n
}

func (ptr *QTextOption) QTextOption_PTR() *QTextOption {
	return ptr
}

//QTextOption::Flag
type QTextOption__Flag int64

const (
	QTextOption__ShowTabsAndSpaces                     = QTextOption__Flag(0x1)
	QTextOption__ShowLineAndParagraphSeparators        = QTextOption__Flag(0x2)
	QTextOption__AddSpaceForLineAndParagraphSeparators = QTextOption__Flag(0x4)
	QTextOption__SuppressColors                        = QTextOption__Flag(0x8)
	QTextOption__IncludeTrailingSpaces                 = QTextOption__Flag(0x80000000)
)

//QTextOption::TabType
type QTextOption__TabType int64

const (
	QTextOption__LeftTab      = QTextOption__TabType(0)
	QTextOption__RightTab     = QTextOption__TabType(1)
	QTextOption__CenterTab    = QTextOption__TabType(2)
	QTextOption__DelimiterTab = QTextOption__TabType(3)
)

//QTextOption::WrapMode
type QTextOption__WrapMode int64

const (
	QTextOption__NoWrap                       = QTextOption__WrapMode(0)
	QTextOption__WordWrap                     = QTextOption__WrapMode(1)
	QTextOption__ManualWrap                   = QTextOption__WrapMode(2)
	QTextOption__WrapAnywhere                 = QTextOption__WrapMode(3)
	QTextOption__WrapAtWordBoundaryOrAnywhere = QTextOption__WrapMode(4)
)

func NewQTextOption3(other QTextOption_ITF) *QTextOption {
	defer qt.Recovering("QTextOption::QTextOption")

	return newQTextOptionFromPointer(C.QTextOption_NewQTextOption3(PointerFromQTextOption(other)))
}

func NewQTextOption() *QTextOption {
	defer qt.Recovering("QTextOption::QTextOption")

	return newQTextOptionFromPointer(C.QTextOption_NewQTextOption())
}

func NewQTextOption2(alignment core.Qt__AlignmentFlag) *QTextOption {
	defer qt.Recovering("QTextOption::QTextOption")

	return newQTextOptionFromPointer(C.QTextOption_NewQTextOption2(C.int(alignment)))
}

func (ptr *QTextOption) Alignment() core.Qt__AlignmentFlag {
	defer qt.Recovering("QTextOption::alignment")

	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QTextOption_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextOption) Flags() QTextOption__Flag {
	defer qt.Recovering("QTextOption::flags")

	if ptr.Pointer() != nil {
		return QTextOption__Flag(C.QTextOption_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextOption) SetAlignment(alignment core.Qt__AlignmentFlag) {
	defer qt.Recovering("QTextOption::setAlignment")

	if ptr.Pointer() != nil {
		C.QTextOption_SetAlignment(ptr.Pointer(), C.int(alignment))
	}
}

func (ptr *QTextOption) SetFlags(flags QTextOption__Flag) {
	defer qt.Recovering("QTextOption::setFlags")

	if ptr.Pointer() != nil {
		C.QTextOption_SetFlags(ptr.Pointer(), C.int(flags))
	}
}

func (ptr *QTextOption) SetTabStop(tabStop float64) {
	defer qt.Recovering("QTextOption::setTabStop")

	if ptr.Pointer() != nil {
		C.QTextOption_SetTabStop(ptr.Pointer(), C.double(tabStop))
	}
}

func (ptr *QTextOption) SetTextDirection(direction core.Qt__LayoutDirection) {
	defer qt.Recovering("QTextOption::setTextDirection")

	if ptr.Pointer() != nil {
		C.QTextOption_SetTextDirection(ptr.Pointer(), C.int(direction))
	}
}

func (ptr *QTextOption) SetUseDesignMetrics(enable bool) {
	defer qt.Recovering("QTextOption::setUseDesignMetrics")

	if ptr.Pointer() != nil {
		C.QTextOption_SetUseDesignMetrics(ptr.Pointer(), C.int(qt.GoBoolToInt(enable)))
	}
}

func (ptr *QTextOption) SetWrapMode(mode QTextOption__WrapMode) {
	defer qt.Recovering("QTextOption::setWrapMode")

	if ptr.Pointer() != nil {
		C.QTextOption_SetWrapMode(ptr.Pointer(), C.int(mode))
	}
}

func (ptr *QTextOption) TabStop() float64 {
	defer qt.Recovering("QTextOption::tabStop")

	if ptr.Pointer() != nil {
		return float64(C.QTextOption_TabStop(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextOption) TextDirection() core.Qt__LayoutDirection {
	defer qt.Recovering("QTextOption::textDirection")

	if ptr.Pointer() != nil {
		return core.Qt__LayoutDirection(C.QTextOption_TextDirection(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextOption) UseDesignMetrics() bool {
	defer qt.Recovering("QTextOption::useDesignMetrics")

	if ptr.Pointer() != nil {
		return C.QTextOption_UseDesignMetrics(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextOption) WrapMode() QTextOption__WrapMode {
	defer qt.Recovering("QTextOption::wrapMode")

	if ptr.Pointer() != nil {
		return QTextOption__WrapMode(C.QTextOption_WrapMode(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextOption) DestroyQTextOption() {
	defer qt.Recovering("QTextOption::~QTextOption")

	if ptr.Pointer() != nil {
		C.QTextOption_DestroyQTextOption(ptr.Pointer())
	}
}

type QTextTable struct {
	QTextFrame
}

type QTextTable_ITF interface {
	QTextFrame_ITF
	QTextTable_PTR() *QTextTable
}

func PointerFromQTextTable(ptr QTextTable_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextTable_PTR().Pointer()
	}
	return nil
}

func NewQTextTableFromPointer(ptr unsafe.Pointer) *QTextTable {
	var n = new(QTextTable)
	n.SetPointer(ptr)
	return n
}

func newQTextTableFromPointer(ptr unsafe.Pointer) *QTextTable {
	var n = NewQTextTableFromPointer(ptr)
	for len(n.ObjectName()) < len("QTextTable_") {
		n.SetObjectName("QTextTable_" + qt.Identifier())
	}
	return n
}

func (ptr *QTextTable) QTextTable_PTR() *QTextTable {
	return ptr
}

func (ptr *QTextTable) InsertColumns(index int, columns int) {
	defer qt.Recovering("QTextTable::insertColumns")

	if ptr.Pointer() != nil {
		C.QTextTable_InsertColumns(ptr.Pointer(), C.int(index), C.int(columns))
	}
}

func (ptr *QTextTable) InsertRows(index int, rows int) {
	defer qt.Recovering("QTextTable::insertRows")

	if ptr.Pointer() != nil {
		C.QTextTable_InsertRows(ptr.Pointer(), C.int(index), C.int(rows))
	}
}

func (ptr *QTextTable) RemoveColumns(index int, columns int) {
	defer qt.Recovering("QTextTable::removeColumns")

	if ptr.Pointer() != nil {
		C.QTextTable_RemoveColumns(ptr.Pointer(), C.int(index), C.int(columns))
	}
}

func (ptr *QTextTable) RemoveRows(index int, rows int) {
	defer qt.Recovering("QTextTable::removeRows")

	if ptr.Pointer() != nil {
		C.QTextTable_RemoveRows(ptr.Pointer(), C.int(index), C.int(rows))
	}
}

func (ptr *QTextTable) Resize(rows int, columns int) {
	defer qt.Recovering("QTextTable::resize")

	if ptr.Pointer() != nil {
		C.QTextTable_Resize(ptr.Pointer(), C.int(rows), C.int(columns))
	}
}

func (ptr *QTextTable) SetFormat(format QTextTableFormat_ITF) {
	defer qt.Recovering("QTextTable::setFormat")

	if ptr.Pointer() != nil {
		C.QTextTable_SetFormat(ptr.Pointer(), PointerFromQTextTableFormat(format))
	}
}

func (ptr *QTextTable) AppendColumns(count int) {
	defer qt.Recovering("QTextTable::appendColumns")

	if ptr.Pointer() != nil {
		C.QTextTable_AppendColumns(ptr.Pointer(), C.int(count))
	}
}

func (ptr *QTextTable) AppendRows(count int) {
	defer qt.Recovering("QTextTable::appendRows")

	if ptr.Pointer() != nil {
		C.QTextTable_AppendRows(ptr.Pointer(), C.int(count))
	}
}

func (ptr *QTextTable) Columns() int {
	defer qt.Recovering("QTextTable::columns")

	if ptr.Pointer() != nil {
		return int(C.QTextTable_Columns(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTable) MergeCells2(cursor QTextCursor_ITF) {
	defer qt.Recovering("QTextTable::mergeCells")

	if ptr.Pointer() != nil {
		C.QTextTable_MergeCells2(ptr.Pointer(), PointerFromQTextCursor(cursor))
	}
}

func (ptr *QTextTable) MergeCells(row int, column int, numRows int, numCols int) {
	defer qt.Recovering("QTextTable::mergeCells")

	if ptr.Pointer() != nil {
		C.QTextTable_MergeCells(ptr.Pointer(), C.int(row), C.int(column), C.int(numRows), C.int(numCols))
	}
}

func (ptr *QTextTable) Rows() int {
	defer qt.Recovering("QTextTable::rows")

	if ptr.Pointer() != nil {
		return int(C.QTextTable_Rows(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTable) SplitCell(row int, column int, numRows int, numCols int) {
	defer qt.Recovering("QTextTable::splitCell")

	if ptr.Pointer() != nil {
		C.QTextTable_SplitCell(ptr.Pointer(), C.int(row), C.int(column), C.int(numRows), C.int(numCols))
	}
}

func (ptr *QTextTable) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QTextTable::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QTextTable) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QTextTable::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQTextTableTimerEvent
func callbackQTextTableTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextTable::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQTextTableFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QTextTable) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextTable::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextTable_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextTable) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QTextTable::timerEvent")

	if ptr.Pointer() != nil {
		C.QTextTable_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QTextTable) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QTextTable::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QTextTable) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QTextTable::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQTextTableChildEvent
func callbackQTextTableChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextTable::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQTextTableFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QTextTable) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextTable::childEvent")

	if ptr.Pointer() != nil {
		C.QTextTable_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextTable) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QTextTable::childEvent")

	if ptr.Pointer() != nil {
		C.QTextTable_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QTextTable) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QTextTable::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QTextTable) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QTextTable::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQTextTableCustomEvent
func callbackQTextTableCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QTextTable::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQTextTableFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QTextTable) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QTextTable::customEvent")

	if ptr.Pointer() != nil {
		C.QTextTable_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QTextTable) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QTextTable::customEvent")

	if ptr.Pointer() != nil {
		C.QTextTable_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QTextTableCell struct {
	ptr unsafe.Pointer
}

type QTextTableCell_ITF interface {
	QTextTableCell_PTR() *QTextTableCell
}

func (p *QTextTableCell) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTextTableCell) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTextTableCell(ptr QTextTableCell_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextTableCell_PTR().Pointer()
	}
	return nil
}

func NewQTextTableCellFromPointer(ptr unsafe.Pointer) *QTextTableCell {
	var n = new(QTextTableCell)
	n.SetPointer(ptr)
	return n
}

func newQTextTableCellFromPointer(ptr unsafe.Pointer) *QTextTableCell {
	var n = NewQTextTableCellFromPointer(ptr)
	return n
}

func (ptr *QTextTableCell) QTextTableCell_PTR() *QTextTableCell {
	return ptr
}

func NewQTextTableCell() *QTextTableCell {
	defer qt.Recovering("QTextTableCell::QTextTableCell")

	return newQTextTableCellFromPointer(C.QTextTableCell_NewQTextTableCell())
}

func NewQTextTableCell2(other QTextTableCell_ITF) *QTextTableCell {
	defer qt.Recovering("QTextTableCell::QTextTableCell")

	return newQTextTableCellFromPointer(C.QTextTableCell_NewQTextTableCell2(PointerFromQTextTableCell(other)))
}

func (ptr *QTextTableCell) Column() int {
	defer qt.Recovering("QTextTableCell::column")

	if ptr.Pointer() != nil {
		return int(C.QTextTableCell_Column(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableCell) ColumnSpan() int {
	defer qt.Recovering("QTextTableCell::columnSpan")

	if ptr.Pointer() != nil {
		return int(C.QTextTableCell_ColumnSpan(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableCell) IsValid() bool {
	defer qt.Recovering("QTextTableCell::isValid")

	if ptr.Pointer() != nil {
		return C.QTextTableCell_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextTableCell) Row() int {
	defer qt.Recovering("QTextTableCell::row")

	if ptr.Pointer() != nil {
		return int(C.QTextTableCell_Row(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableCell) RowSpan() int {
	defer qt.Recovering("QTextTableCell::rowSpan")

	if ptr.Pointer() != nil {
		return int(C.QTextTableCell_RowSpan(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableCell) SetFormat(format QTextCharFormat_ITF) {
	defer qt.Recovering("QTextTableCell::setFormat")

	if ptr.Pointer() != nil {
		C.QTextTableCell_SetFormat(ptr.Pointer(), PointerFromQTextCharFormat(format))
	}
}

func (ptr *QTextTableCell) TableCellFormatIndex() int {
	defer qt.Recovering("QTextTableCell::tableCellFormatIndex")

	if ptr.Pointer() != nil {
		return int(C.QTextTableCell_TableCellFormatIndex(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableCell) DestroyQTextTableCell() {
	defer qt.Recovering("QTextTableCell::~QTextTableCell")

	if ptr.Pointer() != nil {
		C.QTextTableCell_DestroyQTextTableCell(ptr.Pointer())
	}
}

type QTextTableCellFormat struct {
	QTextCharFormat
}

type QTextTableCellFormat_ITF interface {
	QTextCharFormat_ITF
	QTextTableCellFormat_PTR() *QTextTableCellFormat
}

func PointerFromQTextTableCellFormat(ptr QTextTableCellFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextTableCellFormat_PTR().Pointer()
	}
	return nil
}

func NewQTextTableCellFormatFromPointer(ptr unsafe.Pointer) *QTextTableCellFormat {
	var n = new(QTextTableCellFormat)
	n.SetPointer(ptr)
	return n
}

func newQTextTableCellFormatFromPointer(ptr unsafe.Pointer) *QTextTableCellFormat {
	var n = NewQTextTableCellFormatFromPointer(ptr)
	return n
}

func (ptr *QTextTableCellFormat) QTextTableCellFormat_PTR() *QTextTableCellFormat {
	return ptr
}

func NewQTextTableCellFormat() *QTextTableCellFormat {
	defer qt.Recovering("QTextTableCellFormat::QTextTableCellFormat")

	return newQTextTableCellFormatFromPointer(C.QTextTableCellFormat_NewQTextTableCellFormat())
}

func (ptr *QTextTableCellFormat) BottomPadding() float64 {
	defer qt.Recovering("QTextTableCellFormat::bottomPadding")

	if ptr.Pointer() != nil {
		return float64(C.QTextTableCellFormat_BottomPadding(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableCellFormat) IsValid() bool {
	defer qt.Recovering("QTextTableCellFormat::isValid")

	if ptr.Pointer() != nil {
		return C.QTextTableCellFormat_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextTableCellFormat) LeftPadding() float64 {
	defer qt.Recovering("QTextTableCellFormat::leftPadding")

	if ptr.Pointer() != nil {
		return float64(C.QTextTableCellFormat_LeftPadding(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableCellFormat) RightPadding() float64 {
	defer qt.Recovering("QTextTableCellFormat::rightPadding")

	if ptr.Pointer() != nil {
		return float64(C.QTextTableCellFormat_RightPadding(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableCellFormat) SetBottomPadding(padding float64) {
	defer qt.Recovering("QTextTableCellFormat::setBottomPadding")

	if ptr.Pointer() != nil {
		C.QTextTableCellFormat_SetBottomPadding(ptr.Pointer(), C.double(padding))
	}
}

func (ptr *QTextTableCellFormat) SetLeftPadding(padding float64) {
	defer qt.Recovering("QTextTableCellFormat::setLeftPadding")

	if ptr.Pointer() != nil {
		C.QTextTableCellFormat_SetLeftPadding(ptr.Pointer(), C.double(padding))
	}
}

func (ptr *QTextTableCellFormat) SetPadding(padding float64) {
	defer qt.Recovering("QTextTableCellFormat::setPadding")

	if ptr.Pointer() != nil {
		C.QTextTableCellFormat_SetPadding(ptr.Pointer(), C.double(padding))
	}
}

func (ptr *QTextTableCellFormat) SetRightPadding(padding float64) {
	defer qt.Recovering("QTextTableCellFormat::setRightPadding")

	if ptr.Pointer() != nil {
		C.QTextTableCellFormat_SetRightPadding(ptr.Pointer(), C.double(padding))
	}
}

func (ptr *QTextTableCellFormat) SetTopPadding(padding float64) {
	defer qt.Recovering("QTextTableCellFormat::setTopPadding")

	if ptr.Pointer() != nil {
		C.QTextTableCellFormat_SetTopPadding(ptr.Pointer(), C.double(padding))
	}
}

func (ptr *QTextTableCellFormat) TopPadding() float64 {
	defer qt.Recovering("QTextTableCellFormat::topPadding")

	if ptr.Pointer() != nil {
		return float64(C.QTextTableCellFormat_TopPadding(ptr.Pointer()))
	}
	return 0
}

type QTextTableFormat struct {
	QTextFrameFormat
}

type QTextTableFormat_ITF interface {
	QTextFrameFormat_ITF
	QTextTableFormat_PTR() *QTextTableFormat
}

func PointerFromQTextTableFormat(ptr QTextTableFormat_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTextTableFormat_PTR().Pointer()
	}
	return nil
}

func NewQTextTableFormatFromPointer(ptr unsafe.Pointer) *QTextTableFormat {
	var n = new(QTextTableFormat)
	n.SetPointer(ptr)
	return n
}

func newQTextTableFormatFromPointer(ptr unsafe.Pointer) *QTextTableFormat {
	var n = NewQTextTableFormatFromPointer(ptr)
	return n
}

func (ptr *QTextTableFormat) QTextTableFormat_PTR() *QTextTableFormat {
	return ptr
}

func NewQTextTableFormat() *QTextTableFormat {
	defer qt.Recovering("QTextTableFormat::QTextTableFormat")

	return newQTextTableFormatFromPointer(C.QTextTableFormat_NewQTextTableFormat())
}

func (ptr *QTextTableFormat) Alignment() core.Qt__AlignmentFlag {
	defer qt.Recovering("QTextTableFormat::alignment")

	if ptr.Pointer() != nil {
		return core.Qt__AlignmentFlag(C.QTextTableFormat_Alignment(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableFormat) CellPadding() float64 {
	defer qt.Recovering("QTextTableFormat::cellPadding")

	if ptr.Pointer() != nil {
		return float64(C.QTextTableFormat_CellPadding(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableFormat) CellSpacing() float64 {
	defer qt.Recovering("QTextTableFormat::cellSpacing")

	if ptr.Pointer() != nil {
		return float64(C.QTextTableFormat_CellSpacing(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableFormat) ClearColumnWidthConstraints() {
	defer qt.Recovering("QTextTableFormat::clearColumnWidthConstraints")

	if ptr.Pointer() != nil {
		C.QTextTableFormat_ClearColumnWidthConstraints(ptr.Pointer())
	}
}

func (ptr *QTextTableFormat) Columns() int {
	defer qt.Recovering("QTextTableFormat::columns")

	if ptr.Pointer() != nil {
		return int(C.QTextTableFormat_Columns(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableFormat) HeaderRowCount() int {
	defer qt.Recovering("QTextTableFormat::headerRowCount")

	if ptr.Pointer() != nil {
		return int(C.QTextTableFormat_HeaderRowCount(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTextTableFormat) IsValid() bool {
	defer qt.Recovering("QTextTableFormat::isValid")

	if ptr.Pointer() != nil {
		return C.QTextTableFormat_IsValid(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTextTableFormat) SetAlignment(alignment core.Qt__AlignmentFlag) {
	defer qt.Recovering("QTextTableFormat::setAlignment")

	if ptr.Pointer() != nil {
		C.QTextTableFormat_SetAlignment(ptr.Pointer(), C.int(alignment))
	}
}

func (ptr *QTextTableFormat) SetCellPadding(padding float64) {
	defer qt.Recovering("QTextTableFormat::setCellPadding")

	if ptr.Pointer() != nil {
		C.QTextTableFormat_SetCellPadding(ptr.Pointer(), C.double(padding))
	}
}

func (ptr *QTextTableFormat) SetCellSpacing(spacing float64) {
	defer qt.Recovering("QTextTableFormat::setCellSpacing")

	if ptr.Pointer() != nil {
		C.QTextTableFormat_SetCellSpacing(ptr.Pointer(), C.double(spacing))
	}
}

func (ptr *QTextTableFormat) SetHeaderRowCount(count int) {
	defer qt.Recovering("QTextTableFormat::setHeaderRowCount")

	if ptr.Pointer() != nil {
		C.QTextTableFormat_SetHeaderRowCount(ptr.Pointer(), C.int(count))
	}
}

type QTouchDevice struct {
	ptr unsafe.Pointer
}

type QTouchDevice_ITF interface {
	QTouchDevice_PTR() *QTouchDevice
}

func (p *QTouchDevice) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTouchDevice) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTouchDevice(ptr QTouchDevice_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTouchDevice_PTR().Pointer()
	}
	return nil
}

func NewQTouchDeviceFromPointer(ptr unsafe.Pointer) *QTouchDevice {
	var n = new(QTouchDevice)
	n.SetPointer(ptr)
	return n
}

func newQTouchDeviceFromPointer(ptr unsafe.Pointer) *QTouchDevice {
	var n = NewQTouchDeviceFromPointer(ptr)
	return n
}

func (ptr *QTouchDevice) QTouchDevice_PTR() *QTouchDevice {
	return ptr
}

//QTouchDevice::CapabilityFlag
type QTouchDevice__CapabilityFlag int64

const (
	QTouchDevice__Position           = QTouchDevice__CapabilityFlag(0x0001)
	QTouchDevice__Area               = QTouchDevice__CapabilityFlag(0x0002)
	QTouchDevice__Pressure           = QTouchDevice__CapabilityFlag(0x0004)
	QTouchDevice__Velocity           = QTouchDevice__CapabilityFlag(0x0008)
	QTouchDevice__RawPositions       = QTouchDevice__CapabilityFlag(0x0010)
	QTouchDevice__NormalizedPosition = QTouchDevice__CapabilityFlag(0x0020)
	QTouchDevice__MouseEmulation     = QTouchDevice__CapabilityFlag(0x0040)
)

//QTouchDevice::DeviceType
type QTouchDevice__DeviceType int64

const (
	QTouchDevice__TouchScreen = QTouchDevice__DeviceType(0)
	QTouchDevice__TouchPad    = QTouchDevice__DeviceType(1)
)

func NewQTouchDevice() *QTouchDevice {
	defer qt.Recovering("QTouchDevice::QTouchDevice")

	return newQTouchDeviceFromPointer(C.QTouchDevice_NewQTouchDevice())
}

func (ptr *QTouchDevice) Capabilities() QTouchDevice__CapabilityFlag {
	defer qt.Recovering("QTouchDevice::capabilities")

	if ptr.Pointer() != nil {
		return QTouchDevice__CapabilityFlag(C.QTouchDevice_Capabilities(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTouchDevice) MaximumTouchPoints() int {
	defer qt.Recovering("QTouchDevice::maximumTouchPoints")

	if ptr.Pointer() != nil {
		return int(C.QTouchDevice_MaximumTouchPoints(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTouchDevice) Name() string {
	defer qt.Recovering("QTouchDevice::name")

	if ptr.Pointer() != nil {
		return C.GoString(C.QTouchDevice_Name(ptr.Pointer()))
	}
	return ""
}

func (ptr *QTouchDevice) SetCapabilities(caps QTouchDevice__CapabilityFlag) {
	defer qt.Recovering("QTouchDevice::setCapabilities")

	if ptr.Pointer() != nil {
		C.QTouchDevice_SetCapabilities(ptr.Pointer(), C.int(caps))
	}
}

func (ptr *QTouchDevice) SetMaximumTouchPoints(max int) {
	defer qt.Recovering("QTouchDevice::setMaximumTouchPoints")

	if ptr.Pointer() != nil {
		C.QTouchDevice_SetMaximumTouchPoints(ptr.Pointer(), C.int(max))
	}
}

func (ptr *QTouchDevice) SetName(name string) {
	defer qt.Recovering("QTouchDevice::setName")

	if ptr.Pointer() != nil {
		C.QTouchDevice_SetName(ptr.Pointer(), C.CString(name))
	}
}

func (ptr *QTouchDevice) SetType(devType QTouchDevice__DeviceType) {
	defer qt.Recovering("QTouchDevice::setType")

	if ptr.Pointer() != nil {
		C.QTouchDevice_SetType(ptr.Pointer(), C.int(devType))
	}
}

func (ptr *QTouchDevice) Type() QTouchDevice__DeviceType {
	defer qt.Recovering("QTouchDevice::type")

	if ptr.Pointer() != nil {
		return QTouchDevice__DeviceType(C.QTouchDevice_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTouchDevice) DestroyQTouchDevice() {
	defer qt.Recovering("QTouchDevice::~QTouchDevice")

	if ptr.Pointer() != nil {
		C.QTouchDevice_DestroyQTouchDevice(ptr.Pointer())
	}
}

type QTouchEvent struct {
	QInputEvent
}

type QTouchEvent_ITF interface {
	QInputEvent_ITF
	QTouchEvent_PTR() *QTouchEvent
}

func PointerFromQTouchEvent(ptr QTouchEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTouchEvent_PTR().Pointer()
	}
	return nil
}

func NewQTouchEventFromPointer(ptr unsafe.Pointer) *QTouchEvent {
	var n = new(QTouchEvent)
	n.SetPointer(ptr)
	return n
}

func newQTouchEventFromPointer(ptr unsafe.Pointer) *QTouchEvent {
	var n = NewQTouchEventFromPointer(ptr)
	return n
}

func (ptr *QTouchEvent) QTouchEvent_PTR() *QTouchEvent {
	return ptr
}

func (ptr *QTouchEvent) Device() *QTouchDevice {
	defer qt.Recovering("QTouchEvent::device")

	if ptr.Pointer() != nil {
		return NewQTouchDeviceFromPointer(C.QTouchEvent_Device(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTouchEvent) Target() *core.QObject {
	defer qt.Recovering("QTouchEvent::target")

	if ptr.Pointer() != nil {
		return core.NewQObjectFromPointer(C.QTouchEvent_Target(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTouchEvent) TouchPointStates() core.Qt__TouchPointState {
	defer qt.Recovering("QTouchEvent::touchPointStates")

	if ptr.Pointer() != nil {
		return core.Qt__TouchPointState(C.QTouchEvent_TouchPointStates(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTouchEvent) Window() *QWindow {
	defer qt.Recovering("QTouchEvent::window")

	if ptr.Pointer() != nil {
		return NewQWindowFromPointer(C.QTouchEvent_Window(ptr.Pointer()))
	}
	return nil
}

func (ptr *QTouchEvent) DestroyQTouchEvent() {
	defer qt.Recovering("QTouchEvent::~QTouchEvent")

	if ptr.Pointer() != nil {
		C.QTouchEvent_DestroyQTouchEvent(ptr.Pointer())
	}
}

type QTransform struct {
	ptr unsafe.Pointer
}

type QTransform_ITF interface {
	QTransform_PTR() *QTransform
}

func (p *QTransform) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QTransform) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQTransform(ptr QTransform_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QTransform_PTR().Pointer()
	}
	return nil
}

func NewQTransformFromPointer(ptr unsafe.Pointer) *QTransform {
	var n = new(QTransform)
	n.SetPointer(ptr)
	return n
}

func newQTransformFromPointer(ptr unsafe.Pointer) *QTransform {
	var n = NewQTransformFromPointer(ptr)
	return n
}

func (ptr *QTransform) QTransform_PTR() *QTransform {
	return ptr
}

//QTransform::TransformationType
type QTransform__TransformationType int64

const (
	QTransform__TxNone      = QTransform__TransformationType(0x00)
	QTransform__TxTranslate = QTransform__TransformationType(0x01)
	QTransform__TxScale     = QTransform__TransformationType(0x02)
	QTransform__TxRotate    = QTransform__TransformationType(0x04)
	QTransform__TxShear     = QTransform__TransformationType(0x08)
	QTransform__TxProject   = QTransform__TransformationType(0x10)
)

func NewQTransform3(m11 float64, m12 float64, m13 float64, m21 float64, m22 float64, m23 float64, m31 float64, m32 float64, m33 float64) *QTransform {
	defer qt.Recovering("QTransform::QTransform")

	return newQTransformFromPointer(C.QTransform_NewQTransform3(C.double(m11), C.double(m12), C.double(m13), C.double(m21), C.double(m22), C.double(m23), C.double(m31), C.double(m32), C.double(m33)))
}

func NewQTransform4(m11 float64, m12 float64, m21 float64, m22 float64, dx float64, dy float64) *QTransform {
	defer qt.Recovering("QTransform::QTransform")

	return newQTransformFromPointer(C.QTransform_NewQTransform4(C.double(m11), C.double(m12), C.double(m21), C.double(m22), C.double(dx), C.double(dy)))
}

func (ptr *QTransform) Map3(point core.QPoint_ITF) *core.QPoint {
	defer qt.Recovering("QTransform::map")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QTransform_Map3(ptr.Pointer(), core.PointerFromQPoint(point)))
	}
	return nil
}

func (ptr *QTransform) Map8(region QRegion_ITF) *QRegion {
	defer qt.Recovering("QTransform::map")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QTransform_Map8(ptr.Pointer(), PointerFromQRegion(region)))
	}
	return nil
}

func (ptr *QTransform) MapRect2(rectangle core.QRect_ITF) *core.QRect {
	defer qt.Recovering("QTransform::mapRect")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QTransform_MapRect2(ptr.Pointer(), core.PointerFromQRect(rectangle)))
	}
	return nil
}

func QTransform_QuadToSquare(quad QPolygonF_ITF, trans QTransform_ITF) bool {
	defer qt.Recovering("QTransform::quadToSquare")

	return C.QTransform_QTransform_QuadToSquare(PointerFromQPolygonF(quad), PointerFromQTransform(trans)) != 0
}

func NewQTransform() *QTransform {
	defer qt.Recovering("QTransform::QTransform")

	return newQTransformFromPointer(C.QTransform_NewQTransform())
}

func (ptr *QTransform) Determinant() float64 {
	defer qt.Recovering("QTransform::determinant")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_Determinant(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) Dx() float64 {
	defer qt.Recovering("QTransform::dx")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_Dx(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) Dy() float64 {
	defer qt.Recovering("QTransform::dy")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_Dy(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) IsAffine() bool {
	defer qt.Recovering("QTransform::isAffine")

	if ptr.Pointer() != nil {
		return C.QTransform_IsAffine(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTransform) IsIdentity() bool {
	defer qt.Recovering("QTransform::isIdentity")

	if ptr.Pointer() != nil {
		return C.QTransform_IsIdentity(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTransform) IsInvertible() bool {
	defer qt.Recovering("QTransform::isInvertible")

	if ptr.Pointer() != nil {
		return C.QTransform_IsInvertible(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTransform) IsRotating() bool {
	defer qt.Recovering("QTransform::isRotating")

	if ptr.Pointer() != nil {
		return C.QTransform_IsRotating(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTransform) IsScaling() bool {
	defer qt.Recovering("QTransform::isScaling")

	if ptr.Pointer() != nil {
		return C.QTransform_IsScaling(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTransform) IsTranslating() bool {
	defer qt.Recovering("QTransform::isTranslating")

	if ptr.Pointer() != nil {
		return C.QTransform_IsTranslating(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QTransform) M11() float64 {
	defer qt.Recovering("QTransform::m11")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_M11(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) M12() float64 {
	defer qt.Recovering("QTransform::m12")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_M12(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) M13() float64 {
	defer qt.Recovering("QTransform::m13")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_M13(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) M21() float64 {
	defer qt.Recovering("QTransform::m21")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_M21(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) M22() float64 {
	defer qt.Recovering("QTransform::m22")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_M22(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) M23() float64 {
	defer qt.Recovering("QTransform::m23")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_M23(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) M31() float64 {
	defer qt.Recovering("QTransform::m31")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_M31(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) M32() float64 {
	defer qt.Recovering("QTransform::m32")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_M32(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) M33() float64 {
	defer qt.Recovering("QTransform::m33")

	if ptr.Pointer() != nil {
		return float64(C.QTransform_M33(ptr.Pointer()))
	}
	return 0
}

func (ptr *QTransform) Map10(x int, y int, tx int, ty int) {
	defer qt.Recovering("QTransform::map")

	if ptr.Pointer() != nil {
		C.QTransform_Map10(ptr.Pointer(), C.int(x), C.int(y), C.int(tx), C.int(ty))
	}
}

func QTransform_QuadToQuad(one QPolygonF_ITF, two QPolygonF_ITF, trans QTransform_ITF) bool {
	defer qt.Recovering("QTransform::quadToQuad")

	return C.QTransform_QTransform_QuadToQuad(PointerFromQPolygonF(one), PointerFromQPolygonF(two), PointerFromQTransform(trans)) != 0
}

func (ptr *QTransform) Reset() {
	defer qt.Recovering("QTransform::reset")

	if ptr.Pointer() != nil {
		C.QTransform_Reset(ptr.Pointer())
	}
}

func (ptr *QTransform) SetMatrix(m11 float64, m12 float64, m13 float64, m21 float64, m22 float64, m23 float64, m31 float64, m32 float64, m33 float64) {
	defer qt.Recovering("QTransform::setMatrix")

	if ptr.Pointer() != nil {
		C.QTransform_SetMatrix(ptr.Pointer(), C.double(m11), C.double(m12), C.double(m13), C.double(m21), C.double(m22), C.double(m23), C.double(m31), C.double(m32), C.double(m33))
	}
}

func QTransform_SquareToQuad(quad QPolygonF_ITF, trans QTransform_ITF) bool {
	defer qt.Recovering("QTransform::squareToQuad")

	return C.QTransform_QTransform_SquareToQuad(PointerFromQPolygonF(quad), PointerFromQTransform(trans)) != 0
}

func (ptr *QTransform) Type() QTransform__TransformationType {
	defer qt.Recovering("QTransform::type")

	if ptr.Pointer() != nil {
		return QTransform__TransformationType(C.QTransform_Type(ptr.Pointer()))
	}
	return 0
}

type QValidator struct {
	core.QObject
}

type QValidator_ITF interface {
	core.QObject_ITF
	QValidator_PTR() *QValidator
}

func PointerFromQValidator(ptr QValidator_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QValidator_PTR().Pointer()
	}
	return nil
}

func NewQValidatorFromPointer(ptr unsafe.Pointer) *QValidator {
	var n = new(QValidator)
	n.SetPointer(ptr)
	return n
}

func newQValidatorFromPointer(ptr unsafe.Pointer) *QValidator {
	var n = NewQValidatorFromPointer(ptr)
	for len(n.ObjectName()) < len("QValidator_") {
		n.SetObjectName("QValidator_" + qt.Identifier())
	}
	return n
}

func (ptr *QValidator) QValidator_PTR() *QValidator {
	return ptr
}

//QValidator::State
type QValidator__State int64

const (
	QValidator__Invalid      = QValidator__State(0)
	QValidator__Intermediate = QValidator__State(1)
	QValidator__Acceptable   = QValidator__State(2)
)

func (ptr *QValidator) ConnectChanged(f func()) {
	defer qt.Recovering("connect QValidator::changed")

	if ptr.Pointer() != nil {
		C.QValidator_ConnectChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "changed", f)
	}
}

func (ptr *QValidator) DisconnectChanged() {
	defer qt.Recovering("disconnect QValidator::changed")

	if ptr.Pointer() != nil {
		C.QValidator_DisconnectChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "changed")
	}
}

//export callbackQValidatorChanged
func callbackQValidatorChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QValidator::changed")

	if signal := qt.GetSignal(C.GoString(ptrName), "changed"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QValidator) Changed() {
	defer qt.Recovering("QValidator::changed")

	if ptr.Pointer() != nil {
		C.QValidator_Changed(ptr.Pointer())
	}
}

func (ptr *QValidator) SetLocale(locale core.QLocale_ITF) {
	defer qt.Recovering("QValidator::setLocale")

	if ptr.Pointer() != nil {
		C.QValidator_SetLocale(ptr.Pointer(), core.PointerFromQLocale(locale))
	}
}

func (ptr *QValidator) DestroyQValidator() {
	defer qt.Recovering("QValidator::~QValidator")

	if ptr.Pointer() != nil {
		C.QValidator_DestroyQValidator(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QValidator) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QValidator::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QValidator) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QValidator::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQValidatorTimerEvent
func callbackQValidatorTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QValidator::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQValidatorFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QValidator) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QValidator::timerEvent")

	if ptr.Pointer() != nil {
		C.QValidator_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QValidator) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QValidator::timerEvent")

	if ptr.Pointer() != nil {
		C.QValidator_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QValidator) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QValidator::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QValidator) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QValidator::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQValidatorChildEvent
func callbackQValidatorChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QValidator::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQValidatorFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QValidator) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QValidator::childEvent")

	if ptr.Pointer() != nil {
		C.QValidator_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QValidator) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QValidator::childEvent")

	if ptr.Pointer() != nil {
		C.QValidator_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QValidator) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QValidator::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QValidator) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QValidator::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQValidatorCustomEvent
func callbackQValidatorCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QValidator::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQValidatorFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QValidator) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QValidator::customEvent")

	if ptr.Pointer() != nil {
		C.QValidator_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QValidator) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QValidator::customEvent")

	if ptr.Pointer() != nil {
		C.QValidator_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QVector2D struct {
	ptr unsafe.Pointer
}

type QVector2D_ITF interface {
	QVector2D_PTR() *QVector2D
}

func (p *QVector2D) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QVector2D) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQVector2D(ptr QVector2D_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVector2D_PTR().Pointer()
	}
	return nil
}

func NewQVector2DFromPointer(ptr unsafe.Pointer) *QVector2D {
	var n = new(QVector2D)
	n.SetPointer(ptr)
	return n
}

func newQVector2DFromPointer(ptr unsafe.Pointer) *QVector2D {
	var n = NewQVector2DFromPointer(ptr)
	return n
}

func (ptr *QVector2D) QVector2D_PTR() *QVector2D {
	return ptr
}

func NewQVector2D() *QVector2D {
	defer qt.Recovering("QVector2D::QVector2D")

	return newQVector2DFromPointer(C.QVector2D_NewQVector2D())
}

func NewQVector2D4(point core.QPoint_ITF) *QVector2D {
	defer qt.Recovering("QVector2D::QVector2D")

	return newQVector2DFromPointer(C.QVector2D_NewQVector2D4(core.PointerFromQPoint(point)))
}

func NewQVector2D5(point core.QPointF_ITF) *QVector2D {
	defer qt.Recovering("QVector2D::QVector2D")

	return newQVector2DFromPointer(C.QVector2D_NewQVector2D5(core.PointerFromQPointF(point)))
}

func NewQVector2D6(vector QVector3D_ITF) *QVector2D {
	defer qt.Recovering("QVector2D::QVector2D")

	return newQVector2DFromPointer(C.QVector2D_NewQVector2D6(PointerFromQVector3D(vector)))
}

func NewQVector2D7(vector QVector4D_ITF) *QVector2D {
	defer qt.Recovering("QVector2D::QVector2D")

	return newQVector2DFromPointer(C.QVector2D_NewQVector2D7(PointerFromQVector4D(vector)))
}

func (ptr *QVector2D) IsNull() bool {
	defer qt.Recovering("QVector2D::isNull")

	if ptr.Pointer() != nil {
		return C.QVector2D_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QVector2D) Normalize() {
	defer qt.Recovering("QVector2D::normalize")

	if ptr.Pointer() != nil {
		C.QVector2D_Normalize(ptr.Pointer())
	}
}

func (ptr *QVector2D) ToPoint() *core.QPoint {
	defer qt.Recovering("QVector2D::toPoint")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QVector2D_ToPoint(ptr.Pointer()))
	}
	return nil
}

type QVector3D struct {
	ptr unsafe.Pointer
}

type QVector3D_ITF interface {
	QVector3D_PTR() *QVector3D
}

func (p *QVector3D) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QVector3D) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQVector3D(ptr QVector3D_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVector3D_PTR().Pointer()
	}
	return nil
}

func NewQVector3DFromPointer(ptr unsafe.Pointer) *QVector3D {
	var n = new(QVector3D)
	n.SetPointer(ptr)
	return n
}

func newQVector3DFromPointer(ptr unsafe.Pointer) *QVector3D {
	var n = NewQVector3DFromPointer(ptr)
	return n
}

func (ptr *QVector3D) QVector3D_PTR() *QVector3D {
	return ptr
}

func NewQVector3D() *QVector3D {
	defer qt.Recovering("QVector3D::QVector3D")

	return newQVector3DFromPointer(C.QVector3D_NewQVector3D())
}

func NewQVector3D4(point core.QPoint_ITF) *QVector3D {
	defer qt.Recovering("QVector3D::QVector3D")

	return newQVector3DFromPointer(C.QVector3D_NewQVector3D4(core.PointerFromQPoint(point)))
}

func NewQVector3D5(point core.QPointF_ITF) *QVector3D {
	defer qt.Recovering("QVector3D::QVector3D")

	return newQVector3DFromPointer(C.QVector3D_NewQVector3D5(core.PointerFromQPointF(point)))
}

func NewQVector3D6(vector QVector2D_ITF) *QVector3D {
	defer qt.Recovering("QVector3D::QVector3D")

	return newQVector3DFromPointer(C.QVector3D_NewQVector3D6(PointerFromQVector2D(vector)))
}

func NewQVector3D8(vector QVector4D_ITF) *QVector3D {
	defer qt.Recovering("QVector3D::QVector3D")

	return newQVector3DFromPointer(C.QVector3D_NewQVector3D8(PointerFromQVector4D(vector)))
}

func (ptr *QVector3D) IsNull() bool {
	defer qt.Recovering("QVector3D::isNull")

	if ptr.Pointer() != nil {
		return C.QVector3D_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QVector3D) Normalize() {
	defer qt.Recovering("QVector3D::normalize")

	if ptr.Pointer() != nil {
		C.QVector3D_Normalize(ptr.Pointer())
	}
}

func (ptr *QVector3D) ToPoint() *core.QPoint {
	defer qt.Recovering("QVector3D::toPoint")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QVector3D_ToPoint(ptr.Pointer()))
	}
	return nil
}

type QVector4D struct {
	ptr unsafe.Pointer
}

type QVector4D_ITF interface {
	QVector4D_PTR() *QVector4D
}

func (p *QVector4D) Pointer() unsafe.Pointer {
	return p.ptr
}

func (p *QVector4D) SetPointer(ptr unsafe.Pointer) {
	p.ptr = ptr
}

func PointerFromQVector4D(ptr QVector4D_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QVector4D_PTR().Pointer()
	}
	return nil
}

func NewQVector4DFromPointer(ptr unsafe.Pointer) *QVector4D {
	var n = new(QVector4D)
	n.SetPointer(ptr)
	return n
}

func newQVector4DFromPointer(ptr unsafe.Pointer) *QVector4D {
	var n = NewQVector4DFromPointer(ptr)
	return n
}

func (ptr *QVector4D) QVector4D_PTR() *QVector4D {
	return ptr
}

func NewQVector4D() *QVector4D {
	defer qt.Recovering("QVector4D::QVector4D")

	return newQVector4DFromPointer(C.QVector4D_NewQVector4D())
}

func NewQVector4D4(point core.QPoint_ITF) *QVector4D {
	defer qt.Recovering("QVector4D::QVector4D")

	return newQVector4DFromPointer(C.QVector4D_NewQVector4D4(core.PointerFromQPoint(point)))
}

func NewQVector4D5(point core.QPointF_ITF) *QVector4D {
	defer qt.Recovering("QVector4D::QVector4D")

	return newQVector4DFromPointer(C.QVector4D_NewQVector4D5(core.PointerFromQPointF(point)))
}

func NewQVector4D6(vector QVector2D_ITF) *QVector4D {
	defer qt.Recovering("QVector4D::QVector4D")

	return newQVector4DFromPointer(C.QVector4D_NewQVector4D6(PointerFromQVector2D(vector)))
}

func NewQVector4D8(vector QVector3D_ITF) *QVector4D {
	defer qt.Recovering("QVector4D::QVector4D")

	return newQVector4DFromPointer(C.QVector4D_NewQVector4D8(PointerFromQVector3D(vector)))
}

func (ptr *QVector4D) IsNull() bool {
	defer qt.Recovering("QVector4D::isNull")

	if ptr.Pointer() != nil {
		return C.QVector4D_IsNull(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QVector4D) Normalize() {
	defer qt.Recovering("QVector4D::normalize")

	if ptr.Pointer() != nil {
		C.QVector4D_Normalize(ptr.Pointer())
	}
}

func (ptr *QVector4D) ToPoint() *core.QPoint {
	defer qt.Recovering("QVector4D::toPoint")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QVector4D_ToPoint(ptr.Pointer()))
	}
	return nil
}

type QWhatsThisClickedEvent struct {
	core.QEvent
}

type QWhatsThisClickedEvent_ITF interface {
	core.QEvent_ITF
	QWhatsThisClickedEvent_PTR() *QWhatsThisClickedEvent
}

func PointerFromQWhatsThisClickedEvent(ptr QWhatsThisClickedEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWhatsThisClickedEvent_PTR().Pointer()
	}
	return nil
}

func NewQWhatsThisClickedEventFromPointer(ptr unsafe.Pointer) *QWhatsThisClickedEvent {
	var n = new(QWhatsThisClickedEvent)
	n.SetPointer(ptr)
	return n
}

func newQWhatsThisClickedEventFromPointer(ptr unsafe.Pointer) *QWhatsThisClickedEvent {
	var n = NewQWhatsThisClickedEventFromPointer(ptr)
	return n
}

func (ptr *QWhatsThisClickedEvent) QWhatsThisClickedEvent_PTR() *QWhatsThisClickedEvent {
	return ptr
}

func NewQWhatsThisClickedEvent(href string) *QWhatsThisClickedEvent {
	defer qt.Recovering("QWhatsThisClickedEvent::QWhatsThisClickedEvent")

	return newQWhatsThisClickedEventFromPointer(C.QWhatsThisClickedEvent_NewQWhatsThisClickedEvent(C.CString(href)))
}

func (ptr *QWhatsThisClickedEvent) Href() string {
	defer qt.Recovering("QWhatsThisClickedEvent::href")

	if ptr.Pointer() != nil {
		return C.GoString(C.QWhatsThisClickedEvent_Href(ptr.Pointer()))
	}
	return ""
}

type QWheelEvent struct {
	QInputEvent
}

type QWheelEvent_ITF interface {
	QInputEvent_ITF
	QWheelEvent_PTR() *QWheelEvent
}

func PointerFromQWheelEvent(ptr QWheelEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWheelEvent_PTR().Pointer()
	}
	return nil
}

func NewQWheelEventFromPointer(ptr unsafe.Pointer) *QWheelEvent {
	var n = new(QWheelEvent)
	n.SetPointer(ptr)
	return n
}

func newQWheelEventFromPointer(ptr unsafe.Pointer) *QWheelEvent {
	var n = NewQWheelEventFromPointer(ptr)
	return n
}

func (ptr *QWheelEvent) QWheelEvent_PTR() *QWheelEvent {
	return ptr
}

func NewQWheelEvent(pos core.QPointF_ITF, globalPos core.QPointF_ITF, pixelDelta core.QPoint_ITF, angleDelta core.QPoint_ITF, qt4Delta int, qt4Orientation core.Qt__Orientation, buttons core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier) *QWheelEvent {
	defer qt.Recovering("QWheelEvent::QWheelEvent")

	return newQWheelEventFromPointer(C.QWheelEvent_NewQWheelEvent(core.PointerFromQPointF(pos), core.PointerFromQPointF(globalPos), core.PointerFromQPoint(pixelDelta), core.PointerFromQPoint(angleDelta), C.int(qt4Delta), C.int(qt4Orientation), C.int(buttons), C.int(modifiers)))
}

func NewQWheelEvent4(pos core.QPointF_ITF, globalPos core.QPointF_ITF, pixelDelta core.QPoint_ITF, angleDelta core.QPoint_ITF, qt4Delta int, qt4Orientation core.Qt__Orientation, buttons core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier, phase core.Qt__ScrollPhase) *QWheelEvent {
	defer qt.Recovering("QWheelEvent::QWheelEvent")

	return newQWheelEventFromPointer(C.QWheelEvent_NewQWheelEvent4(core.PointerFromQPointF(pos), core.PointerFromQPointF(globalPos), core.PointerFromQPoint(pixelDelta), core.PointerFromQPoint(angleDelta), C.int(qt4Delta), C.int(qt4Orientation), C.int(buttons), C.int(modifiers), C.int(phase)))
}

func NewQWheelEvent5(pos core.QPointF_ITF, globalPos core.QPointF_ITF, pixelDelta core.QPoint_ITF, angleDelta core.QPoint_ITF, qt4Delta int, qt4Orientation core.Qt__Orientation, buttons core.Qt__MouseButton, modifiers core.Qt__KeyboardModifier, phase core.Qt__ScrollPhase, source core.Qt__MouseEventSource) *QWheelEvent {
	defer qt.Recovering("QWheelEvent::QWheelEvent")

	return newQWheelEventFromPointer(C.QWheelEvent_NewQWheelEvent5(core.PointerFromQPointF(pos), core.PointerFromQPointF(globalPos), core.PointerFromQPoint(pixelDelta), core.PointerFromQPoint(angleDelta), C.int(qt4Delta), C.int(qt4Orientation), C.int(buttons), C.int(modifiers), C.int(phase), C.int(source)))
}

func (ptr *QWheelEvent) AngleDelta() *core.QPoint {
	defer qt.Recovering("QWheelEvent::angleDelta")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QWheelEvent_AngleDelta(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWheelEvent) Buttons() core.Qt__MouseButton {
	defer qt.Recovering("QWheelEvent::buttons")

	if ptr.Pointer() != nil {
		return core.Qt__MouseButton(C.QWheelEvent_Buttons(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWheelEvent) GlobalPos() *core.QPoint {
	defer qt.Recovering("QWheelEvent::globalPos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QWheelEvent_GlobalPos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWheelEvent) GlobalX() int {
	defer qt.Recovering("QWheelEvent::globalX")

	if ptr.Pointer() != nil {
		return int(C.QWheelEvent_GlobalX(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWheelEvent) GlobalY() int {
	defer qt.Recovering("QWheelEvent::globalY")

	if ptr.Pointer() != nil {
		return int(C.QWheelEvent_GlobalY(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWheelEvent) Phase() core.Qt__ScrollPhase {
	defer qt.Recovering("QWheelEvent::phase")

	if ptr.Pointer() != nil {
		return core.Qt__ScrollPhase(C.QWheelEvent_Phase(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWheelEvent) PixelDelta() *core.QPoint {
	defer qt.Recovering("QWheelEvent::pixelDelta")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QWheelEvent_PixelDelta(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWheelEvent) Pos() *core.QPoint {
	defer qt.Recovering("QWheelEvent::pos")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QWheelEvent_Pos(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWheelEvent) Source() core.Qt__MouseEventSource {
	defer qt.Recovering("QWheelEvent::source")

	if ptr.Pointer() != nil {
		return core.Qt__MouseEventSource(C.QWheelEvent_Source(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWheelEvent) X() int {
	defer qt.Recovering("QWheelEvent::x")

	if ptr.Pointer() != nil {
		return int(C.QWheelEvent_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWheelEvent) Y() int {
	defer qt.Recovering("QWheelEvent::y")

	if ptr.Pointer() != nil {
		return int(C.QWheelEvent_Y(ptr.Pointer()))
	}
	return 0
}

type QWindow struct {
	core.QObject
	QSurface
}

type QWindow_ITF interface {
	core.QObject_ITF
	QSurface_ITF
	QWindow_PTR() *QWindow
}

func (p *QWindow) Pointer() unsafe.Pointer {
	return p.QObject_PTR().Pointer()
}

func (p *QWindow) SetPointer(ptr unsafe.Pointer) {
	p.QObject_PTR().SetPointer(ptr)
	p.QSurface_PTR().SetPointer(ptr)
}

func PointerFromQWindow(ptr QWindow_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWindow_PTR().Pointer()
	}
	return nil
}

func NewQWindowFromPointer(ptr unsafe.Pointer) *QWindow {
	var n = new(QWindow)
	n.SetPointer(ptr)
	return n
}

func newQWindowFromPointer(ptr unsafe.Pointer) *QWindow {
	var n = NewQWindowFromPointer(ptr)
	for len(n.ObjectName()) < len("QWindow_") {
		n.SetObjectName("QWindow_" + qt.Identifier())
	}
	return n
}

func (ptr *QWindow) QWindow_PTR() *QWindow {
	return ptr
}

//QWindow::AncestorMode
type QWindow__AncestorMode int64

const (
	QWindow__ExcludeTransients = QWindow__AncestorMode(0)
	QWindow__IncludeTransients = QWindow__AncestorMode(1)
)

//QWindow::Visibility
type QWindow__Visibility int64

const (
	QWindow__Hidden              = QWindow__Visibility(0)
	QWindow__AutomaticVisibility = QWindow__Visibility(1)
	QWindow__Windowed            = QWindow__Visibility(2)
	QWindow__Minimized           = QWindow__Visibility(3)
	QWindow__Maximized           = QWindow__Visibility(4)
	QWindow__FullScreen          = QWindow__Visibility(5)
)

func (ptr *QWindow) ContentOrientation() core.Qt__ScreenOrientation {
	defer qt.Recovering("QWindow::contentOrientation")

	if ptr.Pointer() != nil {
		return core.Qt__ScreenOrientation(C.QWindow_ContentOrientation(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) Flags() core.Qt__WindowType {
	defer qt.Recovering("QWindow::flags")

	if ptr.Pointer() != nil {
		return core.Qt__WindowType(C.QWindow_Flags(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) IsVisible() bool {
	defer qt.Recovering("QWindow::isVisible")

	if ptr.Pointer() != nil {
		return C.QWindow_IsVisible(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QWindow) MapFromGlobal(pos core.QPoint_ITF) *core.QPoint {
	defer qt.Recovering("QWindow::mapFromGlobal")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QWindow_MapFromGlobal(ptr.Pointer(), core.PointerFromQPoint(pos)))
	}
	return nil
}

func (ptr *QWindow) MapToGlobal(pos core.QPoint_ITF) *core.QPoint {
	defer qt.Recovering("QWindow::mapToGlobal")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QWindow_MapToGlobal(ptr.Pointer(), core.PointerFromQPoint(pos)))
	}
	return nil
}

func (ptr *QWindow) Modality() core.Qt__WindowModality {
	defer qt.Recovering("QWindow::modality")

	if ptr.Pointer() != nil {
		return core.Qt__WindowModality(C.QWindow_Modality(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) Opacity() float64 {
	defer qt.Recovering("QWindow::opacity")

	if ptr.Pointer() != nil {
		return float64(C.QWindow_Opacity(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ReportContentOrientationChange(orientation core.Qt__ScreenOrientation) {
	defer qt.Recovering("QWindow::reportContentOrientationChange")

	if ptr.Pointer() != nil {
		C.QWindow_ReportContentOrientationChange(ptr.Pointer(), C.int(orientation))
	}
}

func (ptr *QWindow) SetFlags(flags core.Qt__WindowType) {
	defer qt.Recovering("QWindow::setFlags")

	if ptr.Pointer() != nil {
		C.QWindow_SetFlags(ptr.Pointer(), C.int(flags))
	}
}

func (ptr *QWindow) SetHeight(arg int) {
	defer qt.Recovering("QWindow::setHeight")

	if ptr.Pointer() != nil {
		C.QWindow_SetHeight(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) SetMaximumHeight(h int) {
	defer qt.Recovering("QWindow::setMaximumHeight")

	if ptr.Pointer() != nil {
		C.QWindow_SetMaximumHeight(ptr.Pointer(), C.int(h))
	}
}

func (ptr *QWindow) SetMaximumWidth(w int) {
	defer qt.Recovering("QWindow::setMaximumWidth")

	if ptr.Pointer() != nil {
		C.QWindow_SetMaximumWidth(ptr.Pointer(), C.int(w))
	}
}

func (ptr *QWindow) SetMinimumHeight(h int) {
	defer qt.Recovering("QWindow::setMinimumHeight")

	if ptr.Pointer() != nil {
		C.QWindow_SetMinimumHeight(ptr.Pointer(), C.int(h))
	}
}

func (ptr *QWindow) SetMinimumWidth(w int) {
	defer qt.Recovering("QWindow::setMinimumWidth")

	if ptr.Pointer() != nil {
		C.QWindow_SetMinimumWidth(ptr.Pointer(), C.int(w))
	}
}

func (ptr *QWindow) SetModality(modality core.Qt__WindowModality) {
	defer qt.Recovering("QWindow::setModality")

	if ptr.Pointer() != nil {
		C.QWindow_SetModality(ptr.Pointer(), C.int(modality))
	}
}

func (ptr *QWindow) SetOpacity(level float64) {
	defer qt.Recovering("QWindow::setOpacity")

	if ptr.Pointer() != nil {
		C.QWindow_SetOpacity(ptr.Pointer(), C.double(level))
	}
}

func (ptr *QWindow) SetTitle(v string) {
	defer qt.Recovering("QWindow::setTitle")

	if ptr.Pointer() != nil {
		C.QWindow_SetTitle(ptr.Pointer(), C.CString(v))
	}
}

func (ptr *QWindow) SetVisibility(v QWindow__Visibility) {
	defer qt.Recovering("QWindow::setVisibility")

	if ptr.Pointer() != nil {
		C.QWindow_SetVisibility(ptr.Pointer(), C.int(v))
	}
}

func (ptr *QWindow) SetVisible(visible bool) {
	defer qt.Recovering("QWindow::setVisible")

	if ptr.Pointer() != nil {
		C.QWindow_SetVisible(ptr.Pointer(), C.int(qt.GoBoolToInt(visible)))
	}
}

func (ptr *QWindow) SetWidth(arg int) {
	defer qt.Recovering("QWindow::setWidth")

	if ptr.Pointer() != nil {
		C.QWindow_SetWidth(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) SetX(arg int) {
	defer qt.Recovering("QWindow::setX")

	if ptr.Pointer() != nil {
		C.QWindow_SetX(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) SetY(arg int) {
	defer qt.Recovering("QWindow::setY")

	if ptr.Pointer() != nil {
		C.QWindow_SetY(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) Title() string {
	defer qt.Recovering("QWindow::title")

	if ptr.Pointer() != nil {
		return C.GoString(C.QWindow_Title(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWindow) Visibility() QWindow__Visibility {
	defer qt.Recovering("QWindow::visibility")

	if ptr.Pointer() != nil {
		return QWindow__Visibility(C.QWindow_Visibility(ptr.Pointer()))
	}
	return 0
}

func NewQWindow(targetScreen QScreen_ITF) *QWindow {
	defer qt.Recovering("QWindow::QWindow")

	return newQWindowFromPointer(C.QWindow_NewQWindow(PointerFromQScreen(targetScreen)))
}

func NewQWindow2(parent QWindow_ITF) *QWindow {
	defer qt.Recovering("QWindow::QWindow")

	return newQWindowFromPointer(C.QWindow_NewQWindow2(PointerFromQWindow(parent)))
}

func (ptr *QWindow) ConnectActiveChanged(f func()) {
	defer qt.Recovering("connect QWindow::activeChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectActiveChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "activeChanged", f)
	}
}

func (ptr *QWindow) DisconnectActiveChanged() {
	defer qt.Recovering("disconnect QWindow::activeChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectActiveChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "activeChanged")
	}
}

//export callbackQWindowActiveChanged
func callbackQWindowActiveChanged(ptr unsafe.Pointer, ptrName *C.char) {
	defer qt.Recovering("callback QWindow::activeChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "activeChanged"); signal != nil {
		signal.(func())()
	}

}

func (ptr *QWindow) ActiveChanged() {
	defer qt.Recovering("QWindow::activeChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ActiveChanged(ptr.Pointer())
	}
}

func (ptr *QWindow) Alert(msec int) {
	defer qt.Recovering("QWindow::alert")

	if ptr.Pointer() != nil {
		C.QWindow_Alert(ptr.Pointer(), C.int(msec))
	}
}

func (ptr *QWindow) BaseSize() *core.QSize {
	defer qt.Recovering("QWindow::baseSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QWindow_BaseSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) Close() bool {
	defer qt.Recovering("QWindow::close")

	if ptr.Pointer() != nil {
		return C.QWindow_Close(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QWindow) ConnectContentOrientationChanged(f func(orientation core.Qt__ScreenOrientation)) {
	defer qt.Recovering("connect QWindow::contentOrientationChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectContentOrientationChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "contentOrientationChanged", f)
	}
}

func (ptr *QWindow) DisconnectContentOrientationChanged() {
	defer qt.Recovering("disconnect QWindow::contentOrientationChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectContentOrientationChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "contentOrientationChanged")
	}
}

//export callbackQWindowContentOrientationChanged
func callbackQWindowContentOrientationChanged(ptr unsafe.Pointer, ptrName *C.char, orientation C.int) {
	defer qt.Recovering("callback QWindow::contentOrientationChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "contentOrientationChanged"); signal != nil {
		signal.(func(core.Qt__ScreenOrientation))(core.Qt__ScreenOrientation(orientation))
	}

}

func (ptr *QWindow) ContentOrientationChanged(orientation core.Qt__ScreenOrientation) {
	defer qt.Recovering("QWindow::contentOrientationChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ContentOrientationChanged(ptr.Pointer(), C.int(orientation))
	}
}

func (ptr *QWindow) Create() {
	defer qt.Recovering("QWindow::create")

	if ptr.Pointer() != nil {
		C.QWindow_Create(ptr.Pointer())
	}
}

func (ptr *QWindow) Destroy() {
	defer qt.Recovering("QWindow::destroy")

	if ptr.Pointer() != nil {
		C.QWindow_Destroy(ptr.Pointer())
	}
}

func (ptr *QWindow) DevicePixelRatio() float64 {
	defer qt.Recovering("QWindow::devicePixelRatio")

	if ptr.Pointer() != nil {
		return float64(C.QWindow_DevicePixelRatio(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) Event(ev core.QEvent_ITF) bool {
	defer qt.Recovering("QWindow::event")

	if ptr.Pointer() != nil {
		return C.QWindow_Event(ptr.Pointer(), core.PointerFromQEvent(ev)) != 0
	}
	return false
}

func (ptr *QWindow) ConnectExposeEvent(f func(ev *QExposeEvent)) {
	defer qt.Recovering("connect QWindow::exposeEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "exposeEvent", f)
	}
}

func (ptr *QWindow) DisconnectExposeEvent() {
	defer qt.Recovering("disconnect QWindow::exposeEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "exposeEvent")
	}
}

//export callbackQWindowExposeEvent
func callbackQWindowExposeEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::exposeEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "exposeEvent"); signal != nil {
		signal.(func(*QExposeEvent))(NewQExposeEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).ExposeEventDefault(NewQExposeEventFromPointer(ev))
	}
}

func (ptr *QWindow) ExposeEvent(ev QExposeEvent_ITF) {
	defer qt.Recovering("QWindow::exposeEvent")

	if ptr.Pointer() != nil {
		C.QWindow_ExposeEvent(ptr.Pointer(), PointerFromQExposeEvent(ev))
	}
}

func (ptr *QWindow) ExposeEventDefault(ev QExposeEvent_ITF) {
	defer qt.Recovering("QWindow::exposeEvent")

	if ptr.Pointer() != nil {
		C.QWindow_ExposeEventDefault(ptr.Pointer(), PointerFromQExposeEvent(ev))
	}
}

func (ptr *QWindow) FilePath() string {
	defer qt.Recovering("QWindow::filePath")

	if ptr.Pointer() != nil {
		return C.GoString(C.QWindow_FilePath(ptr.Pointer()))
	}
	return ""
}

func (ptr *QWindow) ConnectFocusInEvent(f func(ev *QFocusEvent)) {
	defer qt.Recovering("connect QWindow::focusInEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "focusInEvent", f)
	}
}

func (ptr *QWindow) DisconnectFocusInEvent() {
	defer qt.Recovering("disconnect QWindow::focusInEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "focusInEvent")
	}
}

//export callbackQWindowFocusInEvent
func callbackQWindowFocusInEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::focusInEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "focusInEvent"); signal != nil {
		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).FocusInEventDefault(NewQFocusEventFromPointer(ev))
	}
}

func (ptr *QWindow) FocusInEvent(ev QFocusEvent_ITF) {
	defer qt.Recovering("QWindow::focusInEvent")

	if ptr.Pointer() != nil {
		C.QWindow_FocusInEvent(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QWindow) FocusInEventDefault(ev QFocusEvent_ITF) {
	defer qt.Recovering("QWindow::focusInEvent")

	if ptr.Pointer() != nil {
		C.QWindow_FocusInEventDefault(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QWindow) FocusObject() *core.QObject {
	defer qt.Recovering("QWindow::focusObject")

	if ptr.Pointer() != nil {
		return core.NewQObjectFromPointer(C.QWindow_FocusObject(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) ConnectFocusObjectChanged(f func(object *core.QObject)) {
	defer qt.Recovering("connect QWindow::focusObjectChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectFocusObjectChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "focusObjectChanged", f)
	}
}

func (ptr *QWindow) DisconnectFocusObjectChanged() {
	defer qt.Recovering("disconnect QWindow::focusObjectChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectFocusObjectChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "focusObjectChanged")
	}
}

//export callbackQWindowFocusObjectChanged
func callbackQWindowFocusObjectChanged(ptr unsafe.Pointer, ptrName *C.char, object unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::focusObjectChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "focusObjectChanged"); signal != nil {
		signal.(func(*core.QObject))(core.NewQObjectFromPointer(object))
	}

}

func (ptr *QWindow) FocusObjectChanged(object core.QObject_ITF) {
	defer qt.Recovering("QWindow::focusObjectChanged")

	if ptr.Pointer() != nil {
		C.QWindow_FocusObjectChanged(ptr.Pointer(), core.PointerFromQObject(object))
	}
}

func (ptr *QWindow) ConnectFocusOutEvent(f func(ev *QFocusEvent)) {
	defer qt.Recovering("connect QWindow::focusOutEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "focusOutEvent", f)
	}
}

func (ptr *QWindow) DisconnectFocusOutEvent() {
	defer qt.Recovering("disconnect QWindow::focusOutEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "focusOutEvent")
	}
}

//export callbackQWindowFocusOutEvent
func callbackQWindowFocusOutEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::focusOutEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "focusOutEvent"); signal != nil {
		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).FocusOutEventDefault(NewQFocusEventFromPointer(ev))
	}
}

func (ptr *QWindow) FocusOutEvent(ev QFocusEvent_ITF) {
	defer qt.Recovering("QWindow::focusOutEvent")

	if ptr.Pointer() != nil {
		C.QWindow_FocusOutEvent(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QWindow) FocusOutEventDefault(ev QFocusEvent_ITF) {
	defer qt.Recovering("QWindow::focusOutEvent")

	if ptr.Pointer() != nil {
		C.QWindow_FocusOutEventDefault(ptr.Pointer(), PointerFromQFocusEvent(ev))
	}
}

func (ptr *QWindow) FrameGeometry() *core.QRect {
	defer qt.Recovering("QWindow::frameGeometry")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QWindow_FrameGeometry(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) FramePosition() *core.QPoint {
	defer qt.Recovering("QWindow::framePosition")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QWindow_FramePosition(ptr.Pointer()))
	}
	return nil
}

func QWindow_FromWinId(id uintptr) *QWindow {
	defer qt.Recovering("QWindow::fromWinId")

	return NewQWindowFromPointer(C.QWindow_QWindow_FromWinId(C.ulonglong(id)))
}

func (ptr *QWindow) Geometry() *core.QRect {
	defer qt.Recovering("QWindow::geometry")

	if ptr.Pointer() != nil {
		return core.NewQRectFromPointer(C.QWindow_Geometry(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) Height() int {
	defer qt.Recovering("QWindow::height")

	if ptr.Pointer() != nil {
		return int(C.QWindow_Height(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectHeightChanged(f func(arg int)) {
	defer qt.Recovering("connect QWindow::heightChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectHeightChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "heightChanged", f)
	}
}

func (ptr *QWindow) DisconnectHeightChanged() {
	defer qt.Recovering("disconnect QWindow::heightChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectHeightChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "heightChanged")
	}
}

//export callbackQWindowHeightChanged
func callbackQWindowHeightChanged(ptr unsafe.Pointer, ptrName *C.char, arg C.int) {
	defer qt.Recovering("callback QWindow::heightChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "heightChanged"); signal != nil {
		signal.(func(int))(int(arg))
	}

}

func (ptr *QWindow) HeightChanged(arg int) {
	defer qt.Recovering("QWindow::heightChanged")

	if ptr.Pointer() != nil {
		C.QWindow_HeightChanged(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) Hide() {
	defer qt.Recovering("QWindow::hide")

	if ptr.Pointer() != nil {
		C.QWindow_Hide(ptr.Pointer())
	}
}

func (ptr *QWindow) ConnectHideEvent(f func(ev *QHideEvent)) {
	defer qt.Recovering("connect QWindow::hideEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "hideEvent", f)
	}
}

func (ptr *QWindow) DisconnectHideEvent() {
	defer qt.Recovering("disconnect QWindow::hideEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "hideEvent")
	}
}

//export callbackQWindowHideEvent
func callbackQWindowHideEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::hideEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "hideEvent"); signal != nil {
		signal.(func(*QHideEvent))(NewQHideEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).HideEventDefault(NewQHideEventFromPointer(ev))
	}
}

func (ptr *QWindow) HideEvent(ev QHideEvent_ITF) {
	defer qt.Recovering("QWindow::hideEvent")

	if ptr.Pointer() != nil {
		C.QWindow_HideEvent(ptr.Pointer(), PointerFromQHideEvent(ev))
	}
}

func (ptr *QWindow) HideEventDefault(ev QHideEvent_ITF) {
	defer qt.Recovering("QWindow::hideEvent")

	if ptr.Pointer() != nil {
		C.QWindow_HideEventDefault(ptr.Pointer(), PointerFromQHideEvent(ev))
	}
}

func (ptr *QWindow) Icon() *QIcon {
	defer qt.Recovering("QWindow::icon")

	if ptr.Pointer() != nil {
		return NewQIconFromPointer(C.QWindow_Icon(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) IsActive() bool {
	defer qt.Recovering("QWindow::isActive")

	if ptr.Pointer() != nil {
		return C.QWindow_IsActive(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QWindow) IsAncestorOf(child QWindow_ITF, mode QWindow__AncestorMode) bool {
	defer qt.Recovering("QWindow::isAncestorOf")

	if ptr.Pointer() != nil {
		return C.QWindow_IsAncestorOf(ptr.Pointer(), PointerFromQWindow(child), C.int(mode)) != 0
	}
	return false
}

func (ptr *QWindow) IsExposed() bool {
	defer qt.Recovering("QWindow::isExposed")

	if ptr.Pointer() != nil {
		return C.QWindow_IsExposed(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QWindow) IsModal() bool {
	defer qt.Recovering("QWindow::isModal")

	if ptr.Pointer() != nil {
		return C.QWindow_IsModal(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QWindow) IsTopLevel() bool {
	defer qt.Recovering("QWindow::isTopLevel")

	if ptr.Pointer() != nil {
		return C.QWindow_IsTopLevel(ptr.Pointer()) != 0
	}
	return false
}

func (ptr *QWindow) ConnectKeyPressEvent(f func(ev *QKeyEvent)) {
	defer qt.Recovering("connect QWindow::keyPressEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "keyPressEvent", f)
	}
}

func (ptr *QWindow) DisconnectKeyPressEvent() {
	defer qt.Recovering("disconnect QWindow::keyPressEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "keyPressEvent")
	}
}

//export callbackQWindowKeyPressEvent
func callbackQWindowKeyPressEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::keyPressEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "keyPressEvent"); signal != nil {
		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).KeyPressEventDefault(NewQKeyEventFromPointer(ev))
	}
}

func (ptr *QWindow) KeyPressEvent(ev QKeyEvent_ITF) {
	defer qt.Recovering("QWindow::keyPressEvent")

	if ptr.Pointer() != nil {
		C.QWindow_KeyPressEvent(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QWindow) KeyPressEventDefault(ev QKeyEvent_ITF) {
	defer qt.Recovering("QWindow::keyPressEvent")

	if ptr.Pointer() != nil {
		C.QWindow_KeyPressEventDefault(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QWindow) ConnectKeyReleaseEvent(f func(ev *QKeyEvent)) {
	defer qt.Recovering("connect QWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "keyReleaseEvent", f)
	}
}

func (ptr *QWindow) DisconnectKeyReleaseEvent() {
	defer qt.Recovering("disconnect QWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "keyReleaseEvent")
	}
}

//export callbackQWindowKeyReleaseEvent
func callbackQWindowKeyReleaseEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::keyReleaseEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "keyReleaseEvent"); signal != nil {
		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).KeyReleaseEventDefault(NewQKeyEventFromPointer(ev))
	}
}

func (ptr *QWindow) KeyReleaseEvent(ev QKeyEvent_ITF) {
	defer qt.Recovering("QWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {
		C.QWindow_KeyReleaseEvent(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QWindow) KeyReleaseEventDefault(ev QKeyEvent_ITF) {
	defer qt.Recovering("QWindow::keyReleaseEvent")

	if ptr.Pointer() != nil {
		C.QWindow_KeyReleaseEventDefault(ptr.Pointer(), PointerFromQKeyEvent(ev))
	}
}

func (ptr *QWindow) Lower() {
	defer qt.Recovering("QWindow::lower")

	if ptr.Pointer() != nil {
		C.QWindow_Lower(ptr.Pointer())
	}
}

func (ptr *QWindow) Mask() *QRegion {
	defer qt.Recovering("QWindow::mask")

	if ptr.Pointer() != nil {
		return NewQRegionFromPointer(C.QWindow_Mask(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) MaximumHeight() int {
	defer qt.Recovering("QWindow::maximumHeight")

	if ptr.Pointer() != nil {
		return int(C.QWindow_MaximumHeight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectMaximumHeightChanged(f func(arg int)) {
	defer qt.Recovering("connect QWindow::maximumHeightChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectMaximumHeightChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "maximumHeightChanged", f)
	}
}

func (ptr *QWindow) DisconnectMaximumHeightChanged() {
	defer qt.Recovering("disconnect QWindow::maximumHeightChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectMaximumHeightChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "maximumHeightChanged")
	}
}

//export callbackQWindowMaximumHeightChanged
func callbackQWindowMaximumHeightChanged(ptr unsafe.Pointer, ptrName *C.char, arg C.int) {
	defer qt.Recovering("callback QWindow::maximumHeightChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "maximumHeightChanged"); signal != nil {
		signal.(func(int))(int(arg))
	}

}

func (ptr *QWindow) MaximumHeightChanged(arg int) {
	defer qt.Recovering("QWindow::maximumHeightChanged")

	if ptr.Pointer() != nil {
		C.QWindow_MaximumHeightChanged(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) MaximumSize() *core.QSize {
	defer qt.Recovering("QWindow::maximumSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QWindow_MaximumSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) MaximumWidth() int {
	defer qt.Recovering("QWindow::maximumWidth")

	if ptr.Pointer() != nil {
		return int(C.QWindow_MaximumWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectMaximumWidthChanged(f func(arg int)) {
	defer qt.Recovering("connect QWindow::maximumWidthChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectMaximumWidthChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "maximumWidthChanged", f)
	}
}

func (ptr *QWindow) DisconnectMaximumWidthChanged() {
	defer qt.Recovering("disconnect QWindow::maximumWidthChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectMaximumWidthChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "maximumWidthChanged")
	}
}

//export callbackQWindowMaximumWidthChanged
func callbackQWindowMaximumWidthChanged(ptr unsafe.Pointer, ptrName *C.char, arg C.int) {
	defer qt.Recovering("callback QWindow::maximumWidthChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "maximumWidthChanged"); signal != nil {
		signal.(func(int))(int(arg))
	}

}

func (ptr *QWindow) MaximumWidthChanged(arg int) {
	defer qt.Recovering("QWindow::maximumWidthChanged")

	if ptr.Pointer() != nil {
		C.QWindow_MaximumWidthChanged(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) MinimumHeight() int {
	defer qt.Recovering("QWindow::minimumHeight")

	if ptr.Pointer() != nil {
		return int(C.QWindow_MinimumHeight(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectMinimumHeightChanged(f func(arg int)) {
	defer qt.Recovering("connect QWindow::minimumHeightChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectMinimumHeightChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "minimumHeightChanged", f)
	}
}

func (ptr *QWindow) DisconnectMinimumHeightChanged() {
	defer qt.Recovering("disconnect QWindow::minimumHeightChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectMinimumHeightChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "minimumHeightChanged")
	}
}

//export callbackQWindowMinimumHeightChanged
func callbackQWindowMinimumHeightChanged(ptr unsafe.Pointer, ptrName *C.char, arg C.int) {
	defer qt.Recovering("callback QWindow::minimumHeightChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "minimumHeightChanged"); signal != nil {
		signal.(func(int))(int(arg))
	}

}

func (ptr *QWindow) MinimumHeightChanged(arg int) {
	defer qt.Recovering("QWindow::minimumHeightChanged")

	if ptr.Pointer() != nil {
		C.QWindow_MinimumHeightChanged(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) MinimumSize() *core.QSize {
	defer qt.Recovering("QWindow::minimumSize")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QWindow_MinimumSize(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) MinimumWidth() int {
	defer qt.Recovering("QWindow::minimumWidth")

	if ptr.Pointer() != nil {
		return int(C.QWindow_MinimumWidth(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectMinimumWidthChanged(f func(arg int)) {
	defer qt.Recovering("connect QWindow::minimumWidthChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectMinimumWidthChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "minimumWidthChanged", f)
	}
}

func (ptr *QWindow) DisconnectMinimumWidthChanged() {
	defer qt.Recovering("disconnect QWindow::minimumWidthChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectMinimumWidthChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "minimumWidthChanged")
	}
}

//export callbackQWindowMinimumWidthChanged
func callbackQWindowMinimumWidthChanged(ptr unsafe.Pointer, ptrName *C.char, arg C.int) {
	defer qt.Recovering("callback QWindow::minimumWidthChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "minimumWidthChanged"); signal != nil {
		signal.(func(int))(int(arg))
	}

}

func (ptr *QWindow) MinimumWidthChanged(arg int) {
	defer qt.Recovering("QWindow::minimumWidthChanged")

	if ptr.Pointer() != nil {
		C.QWindow_MinimumWidthChanged(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) ConnectModalityChanged(f func(modality core.Qt__WindowModality)) {
	defer qt.Recovering("connect QWindow::modalityChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectModalityChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "modalityChanged", f)
	}
}

func (ptr *QWindow) DisconnectModalityChanged() {
	defer qt.Recovering("disconnect QWindow::modalityChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectModalityChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "modalityChanged")
	}
}

//export callbackQWindowModalityChanged
func callbackQWindowModalityChanged(ptr unsafe.Pointer, ptrName *C.char, modality C.int) {
	defer qt.Recovering("callback QWindow::modalityChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "modalityChanged"); signal != nil {
		signal.(func(core.Qt__WindowModality))(core.Qt__WindowModality(modality))
	}

}

func (ptr *QWindow) ModalityChanged(modality core.Qt__WindowModality) {
	defer qt.Recovering("QWindow::modalityChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ModalityChanged(ptr.Pointer(), C.int(modality))
	}
}

func (ptr *QWindow) ConnectMouseDoubleClickEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent", f)
	}
}

func (ptr *QWindow) DisconnectMouseDoubleClickEvent() {
	defer qt.Recovering("disconnect QWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent")
	}
}

//export callbackQWindowMouseDoubleClickEvent
func callbackQWindowMouseDoubleClickEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::mouseDoubleClickEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseDoubleClickEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).MouseDoubleClickEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QWindow) MouseDoubleClickEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MouseDoubleClickEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QWindow) MouseDoubleClickEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QWindow::mouseDoubleClickEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MouseDoubleClickEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QWindow) ConnectMouseMoveEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mouseMoveEvent", f)
	}
}

func (ptr *QWindow) DisconnectMouseMoveEvent() {
	defer qt.Recovering("disconnect QWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mouseMoveEvent")
	}
}

//export callbackQWindowMouseMoveEvent
func callbackQWindowMouseMoveEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::mouseMoveEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseMoveEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).MouseMoveEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QWindow) MouseMoveEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MouseMoveEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QWindow) MouseMoveEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QWindow::mouseMoveEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MouseMoveEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QWindow) ConnectMousePressEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QWindow::mousePressEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mousePressEvent", f)
	}
}

func (ptr *QWindow) DisconnectMousePressEvent() {
	defer qt.Recovering("disconnect QWindow::mousePressEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mousePressEvent")
	}
}

//export callbackQWindowMousePressEvent
func callbackQWindowMousePressEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::mousePressEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mousePressEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).MousePressEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QWindow) MousePressEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QWindow::mousePressEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MousePressEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QWindow) MousePressEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QWindow::mousePressEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MousePressEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QWindow) ConnectMouseReleaseEvent(f func(ev *QMouseEvent)) {
	defer qt.Recovering("connect QWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "mouseReleaseEvent", f)
	}
}

func (ptr *QWindow) DisconnectMouseReleaseEvent() {
	defer qt.Recovering("disconnect QWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "mouseReleaseEvent")
	}
}

//export callbackQWindowMouseReleaseEvent
func callbackQWindowMouseReleaseEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::mouseReleaseEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "mouseReleaseEvent"); signal != nil {
		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).MouseReleaseEventDefault(NewQMouseEventFromPointer(ev))
	}
}

func (ptr *QWindow) MouseReleaseEvent(ev QMouseEvent_ITF) {
	defer qt.Recovering("QWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MouseReleaseEvent(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QWindow) MouseReleaseEventDefault(ev QMouseEvent_ITF) {
	defer qt.Recovering("QWindow::mouseReleaseEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MouseReleaseEventDefault(ptr.Pointer(), PointerFromQMouseEvent(ev))
	}
}

func (ptr *QWindow) ConnectMoveEvent(f func(ev *QMoveEvent)) {
	defer qt.Recovering("connect QWindow::moveEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "moveEvent", f)
	}
}

func (ptr *QWindow) DisconnectMoveEvent() {
	defer qt.Recovering("disconnect QWindow::moveEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "moveEvent")
	}
}

//export callbackQWindowMoveEvent
func callbackQWindowMoveEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::moveEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "moveEvent"); signal != nil {
		signal.(func(*QMoveEvent))(NewQMoveEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).MoveEventDefault(NewQMoveEventFromPointer(ev))
	}
}

func (ptr *QWindow) MoveEvent(ev QMoveEvent_ITF) {
	defer qt.Recovering("QWindow::moveEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MoveEvent(ptr.Pointer(), PointerFromQMoveEvent(ev))
	}
}

func (ptr *QWindow) MoveEventDefault(ev QMoveEvent_ITF) {
	defer qt.Recovering("QWindow::moveEvent")

	if ptr.Pointer() != nil {
		C.QWindow_MoveEventDefault(ptr.Pointer(), PointerFromQMoveEvent(ev))
	}
}

func (ptr *QWindow) ConnectOpacityChanged(f func(opacity float64)) {
	defer qt.Recovering("connect QWindow::opacityChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectOpacityChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "opacityChanged", f)
	}
}

func (ptr *QWindow) DisconnectOpacityChanged() {
	defer qt.Recovering("disconnect QWindow::opacityChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectOpacityChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "opacityChanged")
	}
}

//export callbackQWindowOpacityChanged
func callbackQWindowOpacityChanged(ptr unsafe.Pointer, ptrName *C.char, opacity C.double) {
	defer qt.Recovering("callback QWindow::opacityChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "opacityChanged"); signal != nil {
		signal.(func(float64))(float64(opacity))
	}

}

func (ptr *QWindow) OpacityChanged(opacity float64) {
	defer qt.Recovering("QWindow::opacityChanged")

	if ptr.Pointer() != nil {
		C.QWindow_OpacityChanged(ptr.Pointer(), C.double(opacity))
	}
}

func (ptr *QWindow) Parent() *QWindow {
	defer qt.Recovering("QWindow::parent")

	if ptr.Pointer() != nil {
		return NewQWindowFromPointer(C.QWindow_Parent(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) Position() *core.QPoint {
	defer qt.Recovering("QWindow::position")

	if ptr.Pointer() != nil {
		return core.NewQPointFromPointer(C.QWindow_Position(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) Raise() {
	defer qt.Recovering("QWindow::raise")

	if ptr.Pointer() != nil {
		C.QWindow_Raise(ptr.Pointer())
	}
}

func (ptr *QWindow) RequestActivate() {
	defer qt.Recovering("QWindow::requestActivate")

	if ptr.Pointer() != nil {
		C.QWindow_RequestActivate(ptr.Pointer())
	}
}

func (ptr *QWindow) RequestUpdate() {
	defer qt.Recovering("QWindow::requestUpdate")

	if ptr.Pointer() != nil {
		C.QWindow_RequestUpdate(ptr.Pointer())
	}
}

func (ptr *QWindow) Resize(newSize core.QSize_ITF) {
	defer qt.Recovering("QWindow::resize")

	if ptr.Pointer() != nil {
		C.QWindow_Resize(ptr.Pointer(), core.PointerFromQSize(newSize))
	}
}

func (ptr *QWindow) Resize2(w int, h int) {
	defer qt.Recovering("QWindow::resize")

	if ptr.Pointer() != nil {
		C.QWindow_Resize2(ptr.Pointer(), C.int(w), C.int(h))
	}
}

func (ptr *QWindow) ConnectResizeEvent(f func(ev *QResizeEvent)) {
	defer qt.Recovering("connect QWindow::resizeEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "resizeEvent", f)
	}
}

func (ptr *QWindow) DisconnectResizeEvent() {
	defer qt.Recovering("disconnect QWindow::resizeEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "resizeEvent")
	}
}

//export callbackQWindowResizeEvent
func callbackQWindowResizeEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::resizeEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "resizeEvent"); signal != nil {
		signal.(func(*QResizeEvent))(NewQResizeEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).ResizeEventDefault(NewQResizeEventFromPointer(ev))
	}
}

func (ptr *QWindow) ResizeEvent(ev QResizeEvent_ITF) {
	defer qt.Recovering("QWindow::resizeEvent")

	if ptr.Pointer() != nil {
		C.QWindow_ResizeEvent(ptr.Pointer(), PointerFromQResizeEvent(ev))
	}
}

func (ptr *QWindow) ResizeEventDefault(ev QResizeEvent_ITF) {
	defer qt.Recovering("QWindow::resizeEvent")

	if ptr.Pointer() != nil {
		C.QWindow_ResizeEventDefault(ptr.Pointer(), PointerFromQResizeEvent(ev))
	}
}

func (ptr *QWindow) Screen() *QScreen {
	defer qt.Recovering("QWindow::screen")

	if ptr.Pointer() != nil {
		return NewQScreenFromPointer(C.QWindow_Screen(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) ConnectScreenChanged(f func(screen *QScreen)) {
	defer qt.Recovering("connect QWindow::screenChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectScreenChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "screenChanged", f)
	}
}

func (ptr *QWindow) DisconnectScreenChanged() {
	defer qt.Recovering("disconnect QWindow::screenChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectScreenChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "screenChanged")
	}
}

//export callbackQWindowScreenChanged
func callbackQWindowScreenChanged(ptr unsafe.Pointer, ptrName *C.char, screen unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::screenChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "screenChanged"); signal != nil {
		signal.(func(*QScreen))(NewQScreenFromPointer(screen))
	}

}

func (ptr *QWindow) ScreenChanged(screen QScreen_ITF) {
	defer qt.Recovering("QWindow::screenChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ScreenChanged(ptr.Pointer(), PointerFromQScreen(screen))
	}
}

func (ptr *QWindow) SetBaseSize(size core.QSize_ITF) {
	defer qt.Recovering("QWindow::setBaseSize")

	if ptr.Pointer() != nil {
		C.QWindow_SetBaseSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QWindow) SetCursor(cursor QCursor_ITF) {
	defer qt.Recovering("QWindow::setCursor")

	if ptr.Pointer() != nil {
		C.QWindow_SetCursor(ptr.Pointer(), PointerFromQCursor(cursor))
	}
}

func (ptr *QWindow) SetFilePath(filePath string) {
	defer qt.Recovering("QWindow::setFilePath")

	if ptr.Pointer() != nil {
		C.QWindow_SetFilePath(ptr.Pointer(), C.CString(filePath))
	}
}

func (ptr *QWindow) SetFormat(format QSurfaceFormat_ITF) {
	defer qt.Recovering("QWindow::setFormat")

	if ptr.Pointer() != nil {
		C.QWindow_SetFormat(ptr.Pointer(), PointerFromQSurfaceFormat(format))
	}
}

func (ptr *QWindow) SetFramePosition(point core.QPoint_ITF) {
	defer qt.Recovering("QWindow::setFramePosition")

	if ptr.Pointer() != nil {
		C.QWindow_SetFramePosition(ptr.Pointer(), core.PointerFromQPoint(point))
	}
}

func (ptr *QWindow) SetGeometry2(rect core.QRect_ITF) {
	defer qt.Recovering("QWindow::setGeometry")

	if ptr.Pointer() != nil {
		C.QWindow_SetGeometry2(ptr.Pointer(), core.PointerFromQRect(rect))
	}
}

func (ptr *QWindow) SetGeometry(posx int, posy int, w int, h int) {
	defer qt.Recovering("QWindow::setGeometry")

	if ptr.Pointer() != nil {
		C.QWindow_SetGeometry(ptr.Pointer(), C.int(posx), C.int(posy), C.int(w), C.int(h))
	}
}

func (ptr *QWindow) SetIcon(icon QIcon_ITF) {
	defer qt.Recovering("QWindow::setIcon")

	if ptr.Pointer() != nil {
		C.QWindow_SetIcon(ptr.Pointer(), PointerFromQIcon(icon))
	}
}

func (ptr *QWindow) SetKeyboardGrabEnabled(grab bool) bool {
	defer qt.Recovering("QWindow::setKeyboardGrabEnabled")

	if ptr.Pointer() != nil {
		return C.QWindow_SetKeyboardGrabEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(grab))) != 0
	}
	return false
}

func (ptr *QWindow) SetMask(region QRegion_ITF) {
	defer qt.Recovering("QWindow::setMask")

	if ptr.Pointer() != nil {
		C.QWindow_SetMask(ptr.Pointer(), PointerFromQRegion(region))
	}
}

func (ptr *QWindow) SetMaximumSize(size core.QSize_ITF) {
	defer qt.Recovering("QWindow::setMaximumSize")

	if ptr.Pointer() != nil {
		C.QWindow_SetMaximumSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QWindow) SetMinimumSize(size core.QSize_ITF) {
	defer qt.Recovering("QWindow::setMinimumSize")

	if ptr.Pointer() != nil {
		C.QWindow_SetMinimumSize(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QWindow) SetMouseGrabEnabled(grab bool) bool {
	defer qt.Recovering("QWindow::setMouseGrabEnabled")

	if ptr.Pointer() != nil {
		return C.QWindow_SetMouseGrabEnabled(ptr.Pointer(), C.int(qt.GoBoolToInt(grab))) != 0
	}
	return false
}

func (ptr *QWindow) SetParent(parent QWindow_ITF) {
	defer qt.Recovering("QWindow::setParent")

	if ptr.Pointer() != nil {
		C.QWindow_SetParent(ptr.Pointer(), PointerFromQWindow(parent))
	}
}

func (ptr *QWindow) SetPosition(pt core.QPoint_ITF) {
	defer qt.Recovering("QWindow::setPosition")

	if ptr.Pointer() != nil {
		C.QWindow_SetPosition(ptr.Pointer(), core.PointerFromQPoint(pt))
	}
}

func (ptr *QWindow) SetPosition2(posx int, posy int) {
	defer qt.Recovering("QWindow::setPosition")

	if ptr.Pointer() != nil {
		C.QWindow_SetPosition2(ptr.Pointer(), C.int(posx), C.int(posy))
	}
}

func (ptr *QWindow) SetScreen(newScreen QScreen_ITF) {
	defer qt.Recovering("QWindow::setScreen")

	if ptr.Pointer() != nil {
		C.QWindow_SetScreen(ptr.Pointer(), PointerFromQScreen(newScreen))
	}
}

func (ptr *QWindow) SetSizeIncrement(size core.QSize_ITF) {
	defer qt.Recovering("QWindow::setSizeIncrement")

	if ptr.Pointer() != nil {
		C.QWindow_SetSizeIncrement(ptr.Pointer(), core.PointerFromQSize(size))
	}
}

func (ptr *QWindow) SetSurfaceType(surfaceType QSurface__SurfaceType) {
	defer qt.Recovering("QWindow::setSurfaceType")

	if ptr.Pointer() != nil {
		C.QWindow_SetSurfaceType(ptr.Pointer(), C.int(surfaceType))
	}
}

func (ptr *QWindow) SetTransientParent(parent QWindow_ITF) {
	defer qt.Recovering("QWindow::setTransientParent")

	if ptr.Pointer() != nil {
		C.QWindow_SetTransientParent(ptr.Pointer(), PointerFromQWindow(parent))
	}
}

func (ptr *QWindow) SetWindowState(state core.Qt__WindowState) {
	defer qt.Recovering("QWindow::setWindowState")

	if ptr.Pointer() != nil {
		C.QWindow_SetWindowState(ptr.Pointer(), C.int(state))
	}
}

func (ptr *QWindow) Show() {
	defer qt.Recovering("QWindow::show")

	if ptr.Pointer() != nil {
		C.QWindow_Show(ptr.Pointer())
	}
}

func (ptr *QWindow) ConnectShowEvent(f func(ev *QShowEvent)) {
	defer qt.Recovering("connect QWindow::showEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "showEvent", f)
	}
}

func (ptr *QWindow) DisconnectShowEvent() {
	defer qt.Recovering("disconnect QWindow::showEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "showEvent")
	}
}

//export callbackQWindowShowEvent
func callbackQWindowShowEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::showEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "showEvent"); signal != nil {
		signal.(func(*QShowEvent))(NewQShowEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).ShowEventDefault(NewQShowEventFromPointer(ev))
	}
}

func (ptr *QWindow) ShowEvent(ev QShowEvent_ITF) {
	defer qt.Recovering("QWindow::showEvent")

	if ptr.Pointer() != nil {
		C.QWindow_ShowEvent(ptr.Pointer(), PointerFromQShowEvent(ev))
	}
}

func (ptr *QWindow) ShowEventDefault(ev QShowEvent_ITF) {
	defer qt.Recovering("QWindow::showEvent")

	if ptr.Pointer() != nil {
		C.QWindow_ShowEventDefault(ptr.Pointer(), PointerFromQShowEvent(ev))
	}
}

func (ptr *QWindow) ShowFullScreen() {
	defer qt.Recovering("QWindow::showFullScreen")

	if ptr.Pointer() != nil {
		C.QWindow_ShowFullScreen(ptr.Pointer())
	}
}

func (ptr *QWindow) ShowMaximized() {
	defer qt.Recovering("QWindow::showMaximized")

	if ptr.Pointer() != nil {
		C.QWindow_ShowMaximized(ptr.Pointer())
	}
}

func (ptr *QWindow) ShowMinimized() {
	defer qt.Recovering("QWindow::showMinimized")

	if ptr.Pointer() != nil {
		C.QWindow_ShowMinimized(ptr.Pointer())
	}
}

func (ptr *QWindow) ShowNormal() {
	defer qt.Recovering("QWindow::showNormal")

	if ptr.Pointer() != nil {
		C.QWindow_ShowNormal(ptr.Pointer())
	}
}

func (ptr *QWindow) Size() *core.QSize {
	defer qt.Recovering("QWindow::size")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QWindow_Size(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) SizeIncrement() *core.QSize {
	defer qt.Recovering("QWindow::sizeIncrement")

	if ptr.Pointer() != nil {
		return core.NewQSizeFromPointer(C.QWindow_SizeIncrement(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) SurfaceType() QSurface__SurfaceType {
	defer qt.Recovering("QWindow::surfaceType")

	if ptr.Pointer() != nil {
		return QSurface__SurfaceType(C.QWindow_SurfaceType(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectTabletEvent(f func(ev *QTabletEvent)) {
	defer qt.Recovering("connect QWindow::tabletEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "tabletEvent", f)
	}
}

func (ptr *QWindow) DisconnectTabletEvent() {
	defer qt.Recovering("disconnect QWindow::tabletEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "tabletEvent")
	}
}

//export callbackQWindowTabletEvent
func callbackQWindowTabletEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::tabletEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "tabletEvent"); signal != nil {
		signal.(func(*QTabletEvent))(NewQTabletEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).TabletEventDefault(NewQTabletEventFromPointer(ev))
	}
}

func (ptr *QWindow) TabletEvent(ev QTabletEvent_ITF) {
	defer qt.Recovering("QWindow::tabletEvent")

	if ptr.Pointer() != nil {
		C.QWindow_TabletEvent(ptr.Pointer(), PointerFromQTabletEvent(ev))
	}
}

func (ptr *QWindow) TabletEventDefault(ev QTabletEvent_ITF) {
	defer qt.Recovering("QWindow::tabletEvent")

	if ptr.Pointer() != nil {
		C.QWindow_TabletEventDefault(ptr.Pointer(), PointerFromQTabletEvent(ev))
	}
}

func (ptr *QWindow) ConnectTouchEvent(f func(ev *QTouchEvent)) {
	defer qt.Recovering("connect QWindow::touchEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "touchEvent", f)
	}
}

func (ptr *QWindow) DisconnectTouchEvent() {
	defer qt.Recovering("disconnect QWindow::touchEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "touchEvent")
	}
}

//export callbackQWindowTouchEvent
func callbackQWindowTouchEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::touchEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "touchEvent"); signal != nil {
		signal.(func(*QTouchEvent))(NewQTouchEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).TouchEventDefault(NewQTouchEventFromPointer(ev))
	}
}

func (ptr *QWindow) TouchEvent(ev QTouchEvent_ITF) {
	defer qt.Recovering("QWindow::touchEvent")

	if ptr.Pointer() != nil {
		C.QWindow_TouchEvent(ptr.Pointer(), PointerFromQTouchEvent(ev))
	}
}

func (ptr *QWindow) TouchEventDefault(ev QTouchEvent_ITF) {
	defer qt.Recovering("QWindow::touchEvent")

	if ptr.Pointer() != nil {
		C.QWindow_TouchEventDefault(ptr.Pointer(), PointerFromQTouchEvent(ev))
	}
}

func (ptr *QWindow) TransientParent() *QWindow {
	defer qt.Recovering("QWindow::transientParent")

	if ptr.Pointer() != nil {
		return NewQWindowFromPointer(C.QWindow_TransientParent(ptr.Pointer()))
	}
	return nil
}

func (ptr *QWindow) Type() core.Qt__WindowType {
	defer qt.Recovering("QWindow::type")

	if ptr.Pointer() != nil {
		return core.Qt__WindowType(C.QWindow_Type(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) UnsetCursor() {
	defer qt.Recovering("QWindow::unsetCursor")

	if ptr.Pointer() != nil {
		C.QWindow_UnsetCursor(ptr.Pointer())
	}
}

func (ptr *QWindow) ConnectVisibilityChanged(f func(visibility QWindow__Visibility)) {
	defer qt.Recovering("connect QWindow::visibilityChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectVisibilityChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "visibilityChanged", f)
	}
}

func (ptr *QWindow) DisconnectVisibilityChanged() {
	defer qt.Recovering("disconnect QWindow::visibilityChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectVisibilityChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "visibilityChanged")
	}
}

//export callbackQWindowVisibilityChanged
func callbackQWindowVisibilityChanged(ptr unsafe.Pointer, ptrName *C.char, visibility C.int) {
	defer qt.Recovering("callback QWindow::visibilityChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "visibilityChanged"); signal != nil {
		signal.(func(QWindow__Visibility))(QWindow__Visibility(visibility))
	}

}

func (ptr *QWindow) VisibilityChanged(visibility QWindow__Visibility) {
	defer qt.Recovering("QWindow::visibilityChanged")

	if ptr.Pointer() != nil {
		C.QWindow_VisibilityChanged(ptr.Pointer(), C.int(visibility))
	}
}

func (ptr *QWindow) ConnectVisibleChanged(f func(arg bool)) {
	defer qt.Recovering("connect QWindow::visibleChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectVisibleChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "visibleChanged", f)
	}
}

func (ptr *QWindow) DisconnectVisibleChanged() {
	defer qt.Recovering("disconnect QWindow::visibleChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectVisibleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "visibleChanged")
	}
}

//export callbackQWindowVisibleChanged
func callbackQWindowVisibleChanged(ptr unsafe.Pointer, ptrName *C.char, arg C.int) {
	defer qt.Recovering("callback QWindow::visibleChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "visibleChanged"); signal != nil {
		signal.(func(bool))(int(arg) != 0)
	}

}

func (ptr *QWindow) VisibleChanged(arg bool) {
	defer qt.Recovering("QWindow::visibleChanged")

	if ptr.Pointer() != nil {
		C.QWindow_VisibleChanged(ptr.Pointer(), C.int(qt.GoBoolToInt(arg)))
	}
}

func (ptr *QWindow) ConnectWheelEvent(f func(ev *QWheelEvent)) {
	defer qt.Recovering("connect QWindow::wheelEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "wheelEvent", f)
	}
}

func (ptr *QWindow) DisconnectWheelEvent() {
	defer qt.Recovering("disconnect QWindow::wheelEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "wheelEvent")
	}
}

//export callbackQWindowWheelEvent
func callbackQWindowWheelEvent(ptr unsafe.Pointer, ptrName *C.char, ev unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::wheelEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "wheelEvent"); signal != nil {
		signal.(func(*QWheelEvent))(NewQWheelEventFromPointer(ev))
	} else {
		NewQWindowFromPointer(ptr).WheelEventDefault(NewQWheelEventFromPointer(ev))
	}
}

func (ptr *QWindow) WheelEvent(ev QWheelEvent_ITF) {
	defer qt.Recovering("QWindow::wheelEvent")

	if ptr.Pointer() != nil {
		C.QWindow_WheelEvent(ptr.Pointer(), PointerFromQWheelEvent(ev))
	}
}

func (ptr *QWindow) WheelEventDefault(ev QWheelEvent_ITF) {
	defer qt.Recovering("QWindow::wheelEvent")

	if ptr.Pointer() != nil {
		C.QWindow_WheelEventDefault(ptr.Pointer(), PointerFromQWheelEvent(ev))
	}
}

func (ptr *QWindow) Width() int {
	defer qt.Recovering("QWindow::width")

	if ptr.Pointer() != nil {
		return int(C.QWindow_Width(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectWidthChanged(f func(arg int)) {
	defer qt.Recovering("connect QWindow::widthChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectWidthChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "widthChanged", f)
	}
}

func (ptr *QWindow) DisconnectWidthChanged() {
	defer qt.Recovering("disconnect QWindow::widthChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectWidthChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "widthChanged")
	}
}

//export callbackQWindowWidthChanged
func callbackQWindowWidthChanged(ptr unsafe.Pointer, ptrName *C.char, arg C.int) {
	defer qt.Recovering("callback QWindow::widthChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "widthChanged"); signal != nil {
		signal.(func(int))(int(arg))
	}

}

func (ptr *QWindow) WidthChanged(arg int) {
	defer qt.Recovering("QWindow::widthChanged")

	if ptr.Pointer() != nil {
		C.QWindow_WidthChanged(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) WinId() uintptr {
	defer qt.Recovering("QWindow::winId")

	if ptr.Pointer() != nil {
		return uintptr(C.QWindow_WinId(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) WindowState() core.Qt__WindowState {
	defer qt.Recovering("QWindow::windowState")

	if ptr.Pointer() != nil {
		return core.Qt__WindowState(C.QWindow_WindowState(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectWindowStateChanged(f func(windowState core.Qt__WindowState)) {
	defer qt.Recovering("connect QWindow::windowStateChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectWindowStateChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "windowStateChanged", f)
	}
}

func (ptr *QWindow) DisconnectWindowStateChanged() {
	defer qt.Recovering("disconnect QWindow::windowStateChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectWindowStateChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "windowStateChanged")
	}
}

//export callbackQWindowWindowStateChanged
func callbackQWindowWindowStateChanged(ptr unsafe.Pointer, ptrName *C.char, windowState C.int) {
	defer qt.Recovering("callback QWindow::windowStateChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "windowStateChanged"); signal != nil {
		signal.(func(core.Qt__WindowState))(core.Qt__WindowState(windowState))
	}

}

func (ptr *QWindow) WindowStateChanged(windowState core.Qt__WindowState) {
	defer qt.Recovering("QWindow::windowStateChanged")

	if ptr.Pointer() != nil {
		C.QWindow_WindowStateChanged(ptr.Pointer(), C.int(windowState))
	}
}

func (ptr *QWindow) ConnectWindowTitleChanged(f func(title string)) {
	defer qt.Recovering("connect QWindow::windowTitleChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectWindowTitleChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "windowTitleChanged", f)
	}
}

func (ptr *QWindow) DisconnectWindowTitleChanged() {
	defer qt.Recovering("disconnect QWindow::windowTitleChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectWindowTitleChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "windowTitleChanged")
	}
}

//export callbackQWindowWindowTitleChanged
func callbackQWindowWindowTitleChanged(ptr unsafe.Pointer, ptrName *C.char, title *C.char) {
	defer qt.Recovering("callback QWindow::windowTitleChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "windowTitleChanged"); signal != nil {
		signal.(func(string))(C.GoString(title))
	}

}

func (ptr *QWindow) WindowTitleChanged(title string) {
	defer qt.Recovering("QWindow::windowTitleChanged")

	if ptr.Pointer() != nil {
		C.QWindow_WindowTitleChanged(ptr.Pointer(), C.CString(title))
	}
}

func (ptr *QWindow) X() int {
	defer qt.Recovering("QWindow::x")

	if ptr.Pointer() != nil {
		return int(C.QWindow_X(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectXChanged(f func(arg int)) {
	defer qt.Recovering("connect QWindow::xChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectXChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "xChanged", f)
	}
}

func (ptr *QWindow) DisconnectXChanged() {
	defer qt.Recovering("disconnect QWindow::xChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectXChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "xChanged")
	}
}

//export callbackQWindowXChanged
func callbackQWindowXChanged(ptr unsafe.Pointer, ptrName *C.char, arg C.int) {
	defer qt.Recovering("callback QWindow::xChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "xChanged"); signal != nil {
		signal.(func(int))(int(arg))
	}

}

func (ptr *QWindow) XChanged(arg int) {
	defer qt.Recovering("QWindow::xChanged")

	if ptr.Pointer() != nil {
		C.QWindow_XChanged(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) Y() int {
	defer qt.Recovering("QWindow::y")

	if ptr.Pointer() != nil {
		return int(C.QWindow_Y(ptr.Pointer()))
	}
	return 0
}

func (ptr *QWindow) ConnectYChanged(f func(arg int)) {
	defer qt.Recovering("connect QWindow::yChanged")

	if ptr.Pointer() != nil {
		C.QWindow_ConnectYChanged(ptr.Pointer())
		qt.ConnectSignal(ptr.ObjectName(), "yChanged", f)
	}
}

func (ptr *QWindow) DisconnectYChanged() {
	defer qt.Recovering("disconnect QWindow::yChanged")

	if ptr.Pointer() != nil {
		C.QWindow_DisconnectYChanged(ptr.Pointer())
		qt.DisconnectSignal(ptr.ObjectName(), "yChanged")
	}
}

//export callbackQWindowYChanged
func callbackQWindowYChanged(ptr unsafe.Pointer, ptrName *C.char, arg C.int) {
	defer qt.Recovering("callback QWindow::yChanged")

	if signal := qt.GetSignal(C.GoString(ptrName), "yChanged"); signal != nil {
		signal.(func(int))(int(arg))
	}

}

func (ptr *QWindow) YChanged(arg int) {
	defer qt.Recovering("QWindow::yChanged")

	if ptr.Pointer() != nil {
		C.QWindow_YChanged(ptr.Pointer(), C.int(arg))
	}
}

func (ptr *QWindow) DestroyQWindow() {
	defer qt.Recovering("QWindow::~QWindow")

	if ptr.Pointer() != nil {
		C.QWindow_DestroyQWindow(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QWindow) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
	defer qt.Recovering("connect QWindow::timerEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
	}
}

func (ptr *QWindow) DisconnectTimerEvent() {
	defer qt.Recovering("disconnect QWindow::timerEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
	}
}

//export callbackQWindowTimerEvent
func callbackQWindowTimerEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::timerEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
	} else {
		NewQWindowFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *QWindow) TimerEvent(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QWindow::timerEvent")

	if ptr.Pointer() != nil {
		C.QWindow_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QWindow) TimerEventDefault(event core.QTimerEvent_ITF) {
	defer qt.Recovering("QWindow::timerEvent")

	if ptr.Pointer() != nil {
		C.QWindow_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
	}
}

func (ptr *QWindow) ConnectChildEvent(f func(event *core.QChildEvent)) {
	defer qt.Recovering("connect QWindow::childEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
	}
}

func (ptr *QWindow) DisconnectChildEvent() {
	defer qt.Recovering("disconnect QWindow::childEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
	}
}

//export callbackQWindowChildEvent
func callbackQWindowChildEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::childEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
	} else {
		NewQWindowFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
	}
}

func (ptr *QWindow) ChildEvent(event core.QChildEvent_ITF) {
	defer qt.Recovering("QWindow::childEvent")

	if ptr.Pointer() != nil {
		C.QWindow_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QWindow) ChildEventDefault(event core.QChildEvent_ITF) {
	defer qt.Recovering("QWindow::childEvent")

	if ptr.Pointer() != nil {
		C.QWindow_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
	}
}

func (ptr *QWindow) ConnectCustomEvent(f func(event *core.QEvent)) {
	defer qt.Recovering("connect QWindow::customEvent")

	if ptr.Pointer() != nil {

		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
	}
}

func (ptr *QWindow) DisconnectCustomEvent() {
	defer qt.Recovering("disconnect QWindow::customEvent")

	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
	}
}

//export callbackQWindowCustomEvent
func callbackQWindowCustomEvent(ptr unsafe.Pointer, ptrName *C.char, event unsafe.Pointer) {
	defer qt.Recovering("callback QWindow::customEvent")

	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
	} else {
		NewQWindowFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
	}
}

func (ptr *QWindow) CustomEvent(event core.QEvent_ITF) {
	defer qt.Recovering("QWindow::customEvent")

	if ptr.Pointer() != nil {
		C.QWindow_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

func (ptr *QWindow) CustomEventDefault(event core.QEvent_ITF) {
	defer qt.Recovering("QWindow::customEvent")

	if ptr.Pointer() != nil {
		C.QWindow_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
	}
}

type QWindowStateChangeEvent struct {
	core.QEvent
}

type QWindowStateChangeEvent_ITF interface {
	core.QEvent_ITF
	QWindowStateChangeEvent_PTR() *QWindowStateChangeEvent
}

func PointerFromQWindowStateChangeEvent(ptr QWindowStateChangeEvent_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QWindowStateChangeEvent_PTR().Pointer()
	}
	return nil
}

func NewQWindowStateChangeEventFromPointer(ptr unsafe.Pointer) *QWindowStateChangeEvent {
	var n = new(QWindowStateChangeEvent)
	n.SetPointer(ptr)
	return n
}

func newQWindowStateChangeEventFromPointer(ptr unsafe.Pointer) *QWindowStateChangeEvent {
	var n = NewQWindowStateChangeEventFromPointer(ptr)
	return n
}

func (ptr *QWindowStateChangeEvent) QWindowStateChangeEvent_PTR() *QWindowStateChangeEvent {
	return ptr
}

func (ptr *QWindowStateChangeEvent) OldState() core.Qt__WindowState {
	defer qt.Recovering("QWindowStateChangeEvent::oldState")

	if ptr.Pointer() != nil {
		return core.Qt__WindowState(C.QWindowStateChangeEvent_OldState(ptr.Pointer()))
	}
	return 0
}