Full Code of MGWL/QtE5 for AI

Repository: MGWL/QtE5
Branch: master
Commit: 7b0743ab4a0e
Files: 371
Total size: 7.9 MB

Directory structure:
gitextract_b_j4onba/

├── ICONS/
│   ├── .directory
│   ├── qt_gui.go
│   ├── qte5.xcf
│   └── Цепочки_Объектов.txt
├── README.md
├── build/
│   ├── QtE56/
│   │   ├── qte56core.cpp
│   │   ├── qte56core.h
│   │   ├── qte56core.pro
│   │   ├── qte56widgets.cpp
│   │   ├── qte56widgets.h
│   │   └── qte56widgets.pro
│   ├── QtE5Qml/
│   │   ├── QtE5Qml.pro
│   │   ├── QtE5Qml.pro.user
│   │   ├── QtE5Qml.pro.user.4f2aa77
│   │   ├── qte5qml.cpp
│   │   ├── qte5qml.h
│   │   └── qte5qml_global.h
│   ├── QtE5Qscintilla/
│   │   ├── Qt4Qt5/
│   │   │   ├── InputMethod.cpp
│   │   │   ├── ListBoxQt.cpp
│   │   │   ├── ListBoxQt.h
│   │   │   ├── MacPasteboardMime.cpp
│   │   │   ├── PlatQt.cpp
│   │   │   ├── Qsci/
│   │   │   │   ├── qsciabstractapis.h
│   │   │   │   ├── qsciapis.h
│   │   │   │   ├── qscicommand.h
│   │   │   │   ├── qscicommandset.h
│   │   │   │   ├── qscidocument.h
│   │   │   │   ├── qsciglobal.h
│   │   │   │   ├── qscilexer.h
│   │   │   │   ├── qscilexeravs.h
│   │   │   │   ├── qscilexerbash.h
│   │   │   │   ├── qscilexerbatch.h
│   │   │   │   ├── qscilexercmake.h
│   │   │   │   ├── qscilexercoffeescript.h
│   │   │   │   ├── qscilexercpp.h
│   │   │   │   ├── qscilexercsharp.h
│   │   │   │   ├── qscilexercss.h
│   │   │   │   ├── qscilexercustom.h
│   │   │   │   ├── qscilexerd.h
│   │   │   │   ├── qscilexerdiff.h
│   │   │   │   ├── qscilexeredifact.h
│   │   │   │   ├── qscilexerfortran.h
│   │   │   │   ├── qscilexerfortran77.h
│   │   │   │   ├── qscilexerhtml.h
│   │   │   │   ├── qscilexeridl.h
│   │   │   │   ├── qscilexerjava.h
│   │   │   │   ├── qscilexerjavascript.h
│   │   │   │   ├── qscilexerjson.h
│   │   │   │   ├── qscilexerlua.h
│   │   │   │   ├── qscilexermakefile.h
│   │   │   │   ├── qscilexermarkdown.h
│   │   │   │   ├── qscilexermatlab.h
│   │   │   │   ├── qscilexeroctave.h
│   │   │   │   ├── qscilexerpascal.h
│   │   │   │   ├── qscilexerperl.h
│   │   │   │   ├── qscilexerpo.h
│   │   │   │   ├── qscilexerpostscript.h
│   │   │   │   ├── qscilexerpov.h
│   │   │   │   ├── qscilexerproperties.h
│   │   │   │   ├── qscilexerpython.h
│   │   │   │   ├── qscilexerruby.h
│   │   │   │   ├── qscilexerspice.h
│   │   │   │   ├── qscilexersql.h
│   │   │   │   ├── qscilexertcl.h
│   │   │   │   ├── qscilexertex.h
│   │   │   │   ├── qscilexerverilog.h
│   │   │   │   ├── qscilexervhdl.h
│   │   │   │   ├── qscilexerxml.h
│   │   │   │   ├── qscilexeryaml.h
│   │   │   │   ├── qscimacro.h
│   │   │   │   ├── qsciprinter.h
│   │   │   │   ├── qsciscintilla.h
│   │   │   │   ├── qsciscintillabase.h
│   │   │   │   ├── qscistyle.h
│   │   │   │   └── qscistyledtext.h
│   │   │   ├── SciAccessibility.cpp
│   │   │   ├── SciAccessibility.h
│   │   │   ├── SciClasses.cpp
│   │   │   ├── SciClasses.h
│   │   │   ├── ScintillaQt.cpp
│   │   │   ├── ScintillaQt.h
│   │   │   ├── features/
│   │   │   │   └── qscintilla2.prf
│   │   │   ├── features_staticlib/
│   │   │   │   └── qscintilla2.prf
│   │   │   ├── qsciabstractapis.cpp
│   │   │   ├── qsciapis.cpp
│   │   │   ├── qscicommand.cpp
│   │   │   ├── qscicommandset.cpp
│   │   │   ├── qscidocument.cpp
│   │   │   ├── qscilexer.cpp
│   │   │   ├── qscilexeravs.cpp
│   │   │   ├── qscilexerbash.cpp
│   │   │   ├── qscilexerbatch.cpp
│   │   │   ├── qscilexercmake.cpp
│   │   │   ├── qscilexercoffeescript.cpp
│   │   │   ├── qscilexercpp.cpp
│   │   │   ├── qscilexercsharp.cpp
│   │   │   ├── qscilexercss.cpp
│   │   │   ├── qscilexercustom.cpp
│   │   │   ├── qscilexerd.cpp
│   │   │   ├── qscilexerdiff.cpp
│   │   │   ├── qscilexeredifact.cpp
│   │   │   ├── qscilexerfortran.cpp
│   │   │   ├── qscilexerfortran77.cpp
│   │   │   ├── qscilexerhtml.cpp
│   │   │   ├── qscilexeridl.cpp
│   │   │   ├── qscilexerjava.cpp
│   │   │   ├── qscilexerjavascript.cpp
│   │   │   ├── qscilexerjson.cpp
│   │   │   ├── qscilexerlua.cpp
│   │   │   ├── qscilexermakefile.cpp
│   │   │   ├── qscilexermarkdown.cpp
│   │   │   ├── qscilexermatlab.cpp
│   │   │   ├── qscilexeroctave.cpp
│   │   │   ├── qscilexerpascal.cpp
│   │   │   ├── qscilexerperl.cpp
│   │   │   ├── qscilexerpo.cpp
│   │   │   ├── qscilexerpostscript.cpp
│   │   │   ├── qscilexerpov.cpp
│   │   │   ├── qscilexerproperties.cpp
│   │   │   ├── qscilexerpython.cpp
│   │   │   ├── qscilexerruby.cpp
│   │   │   ├── qscilexerspice.cpp
│   │   │   ├── qscilexersql.cpp
│   │   │   ├── qscilexertcl.cpp
│   │   │   ├── qscilexertex.cpp
│   │   │   ├── qscilexerverilog.cpp
│   │   │   ├── qscilexervhdl.cpp
│   │   │   ├── qscilexerxml.cpp
│   │   │   ├── qscilexeryaml.cpp
│   │   │   ├── qscimacro.cpp
│   │   │   ├── qscintilla.pro
│   │   │   ├── qscintilla.pro.user
│   │   │   ├── qscintilla_cs.qm
│   │   │   ├── qscintilla_cs.ts
│   │   │   ├── qscintilla_de.qm
│   │   │   ├── qscintilla_de.ts
│   │   │   ├── qscintilla_es.qm
│   │   │   ├── qscintilla_es.ts
│   │   │   ├── qscintilla_fr.qm
│   │   │   ├── qscintilla_fr.ts
│   │   │   ├── qscintilla_pt_br.qm
│   │   │   ├── qscintilla_pt_br.ts
│   │   │   ├── qsciprinter.cpp
│   │   │   ├── qsciscintilla.cpp
│   │   │   ├── qsciscintillabase.cpp
│   │   │   ├── qscistyle.cpp
│   │   │   └── qscistyledtext.cpp
│   │   ├── QtE5Qscintilla.pro
│   │   ├── QtE5Qscintilla.pro.user
│   │   ├── libqscintilla2_qt5.a
│   │   ├── qte5Qsci.cpp
│   │   ├── qte5Qsci.h
│   │   └── qte5Qsci_global.h
│   ├── QtE5Script/
│   │   ├── QtE5Script.pro
│   │   ├── QtE5Script.pro.user
│   │   ├── QtE5Script.pro.user.4f2aa77
│   │   ├── qte5script.cpp
│   │   ├── qte5script.h
│   │   └── qte5script_global.h
│   ├── QtE5Web/
│   │   ├── QtE5Web.pro
│   │   ├── QtE5Web.pro.user
│   │   ├── QtE5Web.pro.user.4f2aa77
│   │   ├── qte5web.cpp
│   │   ├── qte5web.h
│   │   └── qte5web_global.h
│   ├── QtE5WebEngine/
│   │   ├── QtE5WebEngine.pro
│   │   ├── QtE5WebEngine.pro.user
│   │   ├── qte5webengine.cpp
│   │   ├── qte5webengine.h
│   │   └── qte5webengine_global.h
│   └── QtE5Widgets/
│       ├── QtE5widgets.pro
│       ├── ReadMe.txt
│       ├── qte5widgets.cpp
│       ├── qte5widgets.h
│       └── qte5widgets_global.h
├── dub.json
├── example/
│   ├── c.sh
│   └── example.d
├── examples/
│   ├── 1C_vk/
│   │   ├── asc1251.d
│   │   ├── mgw1c_vk1.d
│   │   └── terminal.d
│   ├── FileFind/
│   │   ├── ReadMe.txt
│   │   ├── ffc.d
│   │   ├── fft.ini
│   │   └── ffx.d
│   ├── al1.d
│   ├── calculator.d
│   ├── cbd.d
│   ├── chat.d
│   ├── collatzSequence/
│   │   ├── app.d
│   │   ├── functors.d
│   │   └── qte5.d
│   ├── dgui-1.0.2/
│   │   └── dgui/
│   │       ├── README.md
│   │       ├── build-samples.bat
│   │       ├── dgui/
│   │       │   ├── all.d
│   │       │   ├── application.d
│   │       │   ├── button.d
│   │       │   ├── canvas.d
│   │       │   ├── colordialog.d
│   │       │   ├── combobox.d
│   │       │   ├── contextmenu.d
│   │       │   ├── core/
│   │       │   │   ├── charset.d
│   │       │   │   ├── collection.d
│   │       │   │   ├── controls/
│   │       │   │   │   ├── abstractbutton.d
│   │       │   │   │   ├── containercontrol.d
│   │       │   │   │   ├── control.d
│   │       │   │   │   ├── ownerdrawcontrol.d
│   │       │   │   │   ├── reflectedcontrol.d
│   │       │   │   │   ├── scrollablecontrol.d
│   │       │   │   │   ├── subclassedcontrol.d
│   │       │   │   │   └── textcontrol.d
│   │       │   │   ├── dialogs/
│   │       │   │   │   ├── commondialog.d
│   │       │   │   │   └── dialogresult.d
│   │       │   │   ├── events/
│   │       │   │   │   ├── controlcodeeventargs.d
│   │       │   │   │   ├── event.d
│   │       │   │   │   ├── eventargs.d
│   │       │   │   │   ├── keyeventargs.d
│   │       │   │   │   ├── mouseeventargs.d
│   │       │   │   │   ├── painteventargs.d
│   │       │   │   │   └── scrolleventargs.d
│   │       │   │   ├── exception.d
│   │       │   │   ├── geometry.d
│   │       │   │   ├── handle.d
│   │       │   │   ├── interfaces/
│   │       │   │   │   ├── idisposable.d
│   │       │   │   │   └── ilayoutcontrol.d
│   │       │   │   ├── menu/
│   │       │   │   │   └── abstractmenu.d
│   │       │   │   ├── message.d
│   │       │   │   ├── tag.d
│   │       │   │   ├── utils.d
│   │       │   │   ├── winapi.d
│   │       │   │   ├── wincomp.d
│   │       │   │   └── windowclass.d
│   │       │   ├── filebrowserdialog.d
│   │       │   ├── folderbrowserdialog.d
│   │       │   ├── fontdialog.d
│   │       │   ├── form.d
│   │       │   ├── imagelist.d
│   │       │   ├── label.d
│   │       │   ├── layout/
│   │       │   │   ├── gridpanel.d
│   │       │   │   ├── layoutcontrol.d
│   │       │   │   ├── panel.d
│   │       │   │   └── splitpanel.d
│   │       │   ├── listbox.d
│   │       │   ├── listview.d
│   │       │   ├── menubar.d
│   │       │   ├── messagebox.d
│   │       │   ├── picturebox.d
│   │       │   ├── progressbar.d
│   │       │   ├── registry.d
│   │       │   ├── resources.d
│   │       │   ├── richtextbox.d
│   │       │   ├── scrollbar.d
│   │       │   ├── statusbar.d
│   │       │   ├── tabcontrol.d
│   │       │   ├── textbox.d
│   │       │   ├── timer.d
│   │       │   ├── toolbar.d
│   │       │   ├── tooltip.d
│   │       │   ├── trackbar.d
│   │       │   └── treeview.d
│   │       ├── dgui_samples/
│   │       │   ├── events.d
│   │       │   ├── gradient_rect.d
│   │       │   ├── gradient_triangle.d
│   │       │   ├── grid.d
│   │       │   ├── hello.d
│   │       │   ├── menu.d
│   │       │   ├── picture.d
│   │       │   ├── rawbitmap.d
│   │       │   ├── resource.rc
│   │       │   ├── resource.res
│   │       │   ├── resources.d
│   │       │   ├── splitter.d
│   │       │   ├── tg/
│   │       │   │   ├── dub.json
│   │       │   │   ├── dub.selections.json
│   │       │   │   └── source/
│   │       │   │       └── app.d
│   │       │   └── toolbar_32_x_32.d
│   │       └── dub.json
│   ├── ex5.d
│   ├── example1.d
│   ├── example2.d
│   ├── example3.d
│   ├── example5.d
│   ├── example8.d
│   ├── hello.d
│   ├── nameAll.txt
│   ├── qml/
│   │   ├── qml.d
│   │   ├── qml.js
│   │   └── test3.qml
│   ├── qte56help2/
│   │   ├── ICONS/
│   │   │   ├── help.png~
│   │   │   └── run_sql.png~
│   │   ├── a3.qrc
│   │   ├── asc1251.d
│   │   ├── fQtE56help.ui
│   │   ├── lib56.d
│   │   ├── qte56.d
│   │   ├── qte56help2.d
│   │   └── qte56help2.html
│   ├── t.d
│   ├── t.qrc
│   ├── t.rcc
│   ├── t2.cpp
│   ├── t3.js
│   ├── test2.d
│   ├── test_abstscrolarea.d
│   ├── test_mouse.d
│   ├── test_runKeyPressEvent.d
│   ├── test_script.d
│   ├── test_script2.d
│   ├── testres.d
│   ├── tgrid.d
│   ├── webview.d
│   ├── webview2.d
│   ├── wireworld/
│   │   ├── dub.sdl
│   │   ├── source/
│   │   │   ├── app.d
│   │   │   ├── gui.d
│   │   │   ├── qte5.d
│   │   │   └── wireworld.d
│   │   ├── test.csv
│   │   ├── wire1.csv
│   │   └── wireworld2.csv
│   └── zwezda.d
├── forth/
│   ├── console5_forthd.d
│   ├── f1.f
│   ├── forth.d
│   ├── forthdll.d
│   ├── forthdos.d
│   ├── qt5_for_dforth.f
│   ├── stdlib.f
│   ├── test.f
│   ├── testForth.cpp
│   └── testQtE5.f
├── ide5/
│   ├── bh.ini
│   ├── desktop.ini
│   ├── ex1.d
│   ├── ex2.d
│   ├── ex3.d
│   ├── ex5.d
│   ├── ide5.d
│   ├── ide5sh.txt
│   ├── ini.d
│   ├── mide5.d
│   ├── mide5.prs
│   ├── minimono.d
│   ├── minimsc.d
│   ├── nklab.ini
│   ├── ollydbg.ini
│   ├── qte5prs.d
│   ├── start_ide5.bat
│   ├── start_ide5.sh
│   ├── style.txt
│   ├── tktcl.ini
│   ├── ver.ini
│   ├── veryfqt.d
│   └── zdll.d
├── instruction_rus/
│   ├── Vyzovy_vneshnix_funkciyi.txt
│   ├── qte5_doc.d
│   └── ВызовыВнешнихФункций.txt
├── read_me.txt
├── rtl_qt5_32/
│   └── c.cmd
├── source/
│   ├── ReadMe.txt
│   ├── asc1251.cpp
│   ├── asc1251.d
│   ├── mgwGC.cpp
│   ├── mgwGC.hpp
│   ├── qte5.cpp
│   ├── qte5.d
│   ├── qte5.hpp
│   ├── qte56.d
│   └── t2.cpp
└── tcl/
    ├── qtt2.d
    └── test_qte5.tcl

================================================
FILE CONTENTS
================================================

================================================
FILE: ICONS/.directory
================================================
[Dolphin]
PreviewsShown=true
Timestamp=2016,8,12,23,27,43
Version=3
ViewMode=1


================================================
FILE: ICONS/qt_gui.go
================================================
// Copyright 2015-2016 visualfc <visualfc@gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ui

/*
#include <stdlib.h>
#include "cdrv_def.h"
*/
import "C"
import (
	"unsafe"
)

//struct QAbstractGraphicsShapeItem : QAbstractGraphicsShapeItem
type QAbstractGraphicsShapeItem struct {
	QGraphicsItem
}

//QAbstractGraphicsShapeItem::brush()
func (q *QAbstractGraphicsShapeItem) Brush() *QBrush {
	var __rv uintptr
	q.Drv(1000, 1102, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBrush{}
	_rp.SetDriver(__rv, 9000, true)
	return _rp
}

//QAbstractGraphicsShapeItem::pen()
func (q *QAbstractGraphicsShapeItem) Pen() *QPen {
	var __rv uintptr
	q.Drv(1000, 1103, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPen{}
	_rp.SetDriver(__rv, 93000, true)
	return _rp
}

//QAbstractGraphicsShapeItem::setBrush(QBrush const&)
func (q *QAbstractGraphicsShapeItem) SetBrush(brush *QBrush) {
	q.Drv(1000, 1104, Native(brush), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QAbstractGraphicsShapeItem::setPen(QPen const&)
func (q *QAbstractGraphicsShapeItem) SetPen(pen *QPen) {
	q.Drv(1000, 1105, Native(pen), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//struct QAbstractTextDocumentLayoutPaintContext : QAbstractTextDocumentLayout::PaintContext
type QAbstractTextDocumentLayoutPaintContext struct {
	BaseDrv
}

//QAbstractTextDocumentLayout::PaintContext::PaintContext()
func NewAbstractTextDocumentLayoutPaintContext() *QAbstractTextDocumentLayoutPaintContext {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 2000, 2102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QAbstractTextDocumentLayoutPaintContext{}
	_p.SetDriver(__rv, 2000, true)
	return _p
}

//struct QAbstractTextDocumentLayoutSelection : QAbstractTextDocumentLayout::Selection
type QAbstractTextDocumentLayoutSelection struct {
	BaseDrv
}

//struct QAbstractUndoItem : QAbstractUndoItem
type QAbstractUndoItem struct {
	BaseDrv
}

//QAbstractUndoItem::redo()
func (q *QAbstractUndoItem) Redo() {
	q.Drv(4000, 4102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QAbstractUndoItem::undo()
func (q *QAbstractUndoItem) Undo() {
	q.Drv(4000, 4103, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//struct QActionEvent : QActionEvent
type QActionEvent struct {
	QEvent
}

//QActionEvent::QActionEvent(int,QAction*,QAction*)
func NewActionEvent(_type int32, action *QAction, before *QAction) *QActionEvent {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 5000, 5102, unsafe.Pointer(&_type), Native(action), Native(before), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QActionEvent{}
	_p.SetDriver(__rv, 5000, true)
	return _p
}

//QActionEvent::action()
func (q *QActionEvent) Action() *QAction {
	var __rv uintptr
	q.Drv(5000, 5103, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QAction{}
	_rp.SetDriver(__rv, 209000, false)
	return _rp
}

//QActionEvent::before()
func (q *QActionEvent) Before() *QAction {
	var __rv uintptr
	q.Drv(5000, 5104, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QAction{}
	_rp.SetDriver(__rv, 209000, false)
	return _rp
}

//enum QApplication_Type - QApplication::Type
type QApplication_Type uint32

const (
	QApplication_Tty       QApplication_Type = 0
	QApplication_GuiClient QApplication_Type = 1
	QApplication_GuiServer QApplication_Type = 2
)

//enum QApplication_ColorSpec - QApplication::ColorSpec
type QApplication_ColorSpec uint32

const (
	QApplication_NormalColor QApplication_ColorSpec = 0
	QApplication_CustomColor QApplication_ColorSpec = 1
	QApplication_ManyColor   QApplication_ColorSpec = 2
)

//struct QApplication : QApplication
type QApplication struct {
	QObject
}

// New QApplication from driver
func NewApplicationFromDriver(drv Driver) *QApplication {
	_p := &QApplication{}
	err := _p.SetDriverFrom(drv)
	if err != nil {
		return nil
	}
	return _p
}
func (q *QApplication) OnLastWindowClosed(fn func()) uintptr {
	var __rv uintptr
	q.Drv(6000, 6102, nil, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	signalMap[__rv] = fn
	return __rv
}
func (q *QApplication) OnFocusChanged(fn func(*QWidget, *QWidget)) uintptr {
	var __rv uintptr
	q.Drv(6000, 6103, nil, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	signalMap[__rv] = fn
	return __rv
}
func (q *QApplication) OnSaveStateRequest(fn func(*QSessionManager)) uintptr {
	var __rv uintptr
	q.Drv(6000, 6104, nil, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	signalMap[__rv] = fn
	return __rv
}
func (q *QApplication) OnCommitDataRequest(fn func(*QSessionManager)) uintptr {
	var __rv uintptr
	q.Drv(6000, 6105, nil, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	signalMap[__rv] = fn
	return __rv
}
func (q *QApplication) OnFontDatabaseChanged(fn func()) uintptr {
	var __rv uintptr
	q.Drv(6000, 6106, nil, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	signalMap[__rv] = fn
	return __rv
}

//QApplication::QApplication(int,char**)
func NewApplication(args []string) *QApplication {
	_argc := len(args)
	_argv, _ := NewCSArray(args)
	//defer FreeCSArray(_argv, _argv_size)
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 6000, 6107, unsafe.Pointer(&_argc), unsafe.Pointer(&_argv[0]), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QApplication{}
	_p.SetDriver(__rv, 6000, false)
	return _p
}

//QApplication::aboutQt()
func QApplicationAboutQt() {
	DirectQtDrv(nil, 6000, 6108, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::aboutQt()
func (q *QApplication) AboutQt() {
	q.Drv(6000, 6108, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::activeModalWidget()
func QApplicationActiveModalWidget() *QWidget {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6109, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::activeModalWidget()
func (q *QApplication) ActiveModalWidget() *QWidget {
	var __rv uintptr
	q.Drv(6000, 6109, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::activePopupWidget()
func QApplicationActivePopupWidget() *QWidget {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6110, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::activePopupWidget()
func (q *QApplication) ActivePopupWidget() *QWidget {
	var __rv uintptr
	q.Drv(6000, 6110, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::activeWindow()
func QApplicationActiveWindow() *QWidget {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::activeWindow()
func (q *QApplication) ActiveWindow() *QWidget {
	var __rv uintptr
	q.Drv(6000, 6111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QCoreApplication::addLibraryPath(QString const&)
func QApplicationAddLibraryPath(value string) {
	_value := NewCStringHead(value)
	defer FreeCStringHead(_value)
	DirectQtDrv(nil, 6000, 6112, unsafe.Pointer(_value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::addLibraryPath(QString const&)
func (q *QApplication) AddLibraryPath(value string) {
	_value := NewCStringHead(value)
	defer FreeCStringHead(_value)
	q.Drv(6000, 6112, unsafe.Pointer(_value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::alert(QWidget*)
func QApplicationAlert(widget QWidgetInterface) {
	DirectQtDrv(nil, 6000, 6113, Native(widget), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::alert(QWidget*)
func (q *QApplication) Alert(widget QWidgetInterface) {
	q.Drv(6000, 6113, Native(widget), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::alert(QWidget*,int)
func QApplicationAlertWithWidgetDuration(widget QWidgetInterface, duration int32) {
	DirectQtDrv(nil, 6000, 6114, Native(widget), unsafe.Pointer(&duration), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::alert(QWidget*,int)
func (q *QApplication) AlertWithWidgetDuration(widget QWidgetInterface, duration int32) {
	q.Drv(6000, 6114, Native(widget), unsafe.Pointer(&duration), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::allWidgets()
func QApplicationAllWidgets() []*QWidget {
	var __rv []*QWidget
	DirectQtDrv(nil, 6000, 6115, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::allWidgets()
func (q *QApplication) AllWidgets() []*QWidget {
	var __rv []*QWidget
	q.Drv(6000, 6115, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::applicationDirPath()
func QApplicationApplicationDirPath() string {
	var __rv C.string_head
	DirectQtDrv(nil, 6000, 6116, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::applicationDirPath()
func (q *QApplication) ApplicationDirPath() string {
	var __rv C.string_head
	q.Drv(6000, 6116, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::applicationFilePath()
func QApplicationApplicationFilePath() string {
	var __rv C.string_head
	DirectQtDrv(nil, 6000, 6117, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::applicationFilePath()
func (q *QApplication) ApplicationFilePath() string {
	var __rv C.string_head
	q.Drv(6000, 6117, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::applicationName()
func QApplicationApplicationName() string {
	var __rv C.string_head
	DirectQtDrv(nil, 6000, 6118, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::applicationName()
func (q *QApplication) ApplicationName() string {
	var __rv C.string_head
	q.Drv(6000, 6118, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::applicationPid()
func QApplicationApplicationPid() int64 {
	var __rv int64
	DirectQtDrv(nil, 6000, 6119, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::applicationPid()
func (q *QApplication) ApplicationPid() int64 {
	var __rv int64
	q.Drv(6000, 6119, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::applicationVersion()
func QApplicationApplicationVersion() string {
	var __rv C.string_head
	DirectQtDrv(nil, 6000, 6120, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::applicationVersion()
func (q *QApplication) ApplicationVersion() string {
	var __rv C.string_head
	q.Drv(6000, 6120, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::arguments()
func QApplicationArguments() []string {
	var __rv []string
	DirectQtDrv(nil, 6000, 6121, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::arguments()
func (q *QApplication) Arguments() []string {
	var __rv []string
	q.Drv(6000, 6121, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::autoSipEnabled()
func (q *QApplication) AutoSipEnabled() bool {
	var __rv bool
	q.Drv(6000, 6122, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::beep()
func QApplicationBeep() {
	DirectQtDrv(nil, 6000, 6123, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::beep()
func (q *QApplication) Beep() {
	q.Drv(6000, 6123, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::changeOverrideCursor(QCursor const&)
func QApplicationChangeOverrideCursor(value *QCursor) {
	DirectQtDrv(nil, 6000, 6124, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::changeOverrideCursor(QCursor const&)
func (q *QApplication) ChangeOverrideCursor(value *QCursor) {
	q.Drv(6000, 6124, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::clipboard()
func QApplicationClipboard() *QClipboard {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6125, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QClipboard{}
	_rp.SetDriver(__rv, 216000, false)
	return _rp
}

//QApplication::clipboard()
func (q *QApplication) Clipboard() *QClipboard {
	var __rv uintptr
	q.Drv(6000, 6125, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QClipboard{}
	_rp.SetDriver(__rv, 216000, false)
	return _rp
}

//QApplication::closeAllWindows()
func QApplicationCloseAllWindows() {
	DirectQtDrv(nil, 6000, 6126, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::closeAllWindows()
func (q *QApplication) CloseAllWindows() {
	q.Drv(6000, 6126, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::closingDown()
func QApplicationClosingDown() bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6127, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::closingDown()
func (q *QApplication) ClosingDown() bool {
	var __rv bool
	q.Drv(6000, 6127, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::colorSpec()
func QApplicationColorSpec() int32 {
	var __rv int32
	DirectQtDrv(nil, 6000, 6128, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::colorSpec()
func (q *QApplication) ColorSpec() int32 {
	var __rv int32
	q.Drv(6000, 6128, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::cursorFlashTime()
func QApplicationCursorFlashTime() int32 {
	var __rv int32
	DirectQtDrv(nil, 6000, 6129, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::cursorFlashTime()
func (q *QApplication) CursorFlashTime() int32 {
	var __rv int32
	q.Drv(6000, 6129, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::desktop()
func QApplicationDesktop() *QDesktopWidget {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6130, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDesktopWidget{}
	_rp.SetDriver(__rv, 226000, false)
	return _rp
}

//QApplication::desktop()
func (q *QApplication) Desktop() *QDesktopWidget {
	var __rv uintptr
	q.Drv(6000, 6130, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDesktopWidget{}
	_rp.SetDriver(__rv, 226000, false)
	return _rp
}

//QApplication::desktopSettingsAware()
func QApplicationDesktopSettingsAware() bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6131, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::desktopSettingsAware()
func (q *QApplication) DesktopSettingsAware() bool {
	var __rv bool
	q.Drv(6000, 6131, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::doubleClickInterval()
func QApplicationDoubleClickInterval() int32 {
	var __rv int32
	DirectQtDrv(nil, 6000, 6132, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::doubleClickInterval()
func (q *QApplication) DoubleClickInterval() int32 {
	var __rv int32
	q.Drv(6000, 6132, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::exec()
func QApplicationExec() int32 {
	var __rv int32
	DirectQtDrv(nil, 6000, 6133, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::exec()
func (q *QApplication) Exec() int32 {
	var __rv int32
	q.Drv(6000, 6133, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::exit()
func QApplicationExit() {
	DirectQtDrv(nil, 6000, 6134, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::exit()
func (q *QApplication) Exit() {
	q.Drv(6000, 6134, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::exit(int)
func QApplicationExitWithRetcode(retcode int32) {
	DirectQtDrv(nil, 6000, 6135, unsafe.Pointer(&retcode), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::exit(int)
func (q *QApplication) ExitWithRetcode(retcode int32) {
	q.Drv(6000, 6135, unsafe.Pointer(&retcode), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::flush()
func QApplicationFlush() {
	DirectQtDrv(nil, 6000, 6136, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::flush()
func (q *QApplication) Flush() {
	q.Drv(6000, 6136, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::focusWidget()
func QApplicationFocusWidget() *QWidget {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6137, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::focusWidget()
func (q *QApplication) FocusWidget() *QWidget {
	var __rv uintptr
	q.Drv(6000, 6137, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::font()
func QApplicationFont() *QFont {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6138, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QFont{}
	_rp.SetDriver(__rv, 37000, true)
	return _rp
}

//QApplication::font()
func (q *QApplication) Font() *QFont {
	var __rv uintptr
	q.Drv(6000, 6138, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QFont{}
	_rp.SetDriver(__rv, 37000, true)
	return _rp
}

//QApplication::font(QWidget const*)
func QApplicationFontWithWidget(value QWidgetInterface) *QFont {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6139, Native(value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QFont{}
	_rp.SetDriver(__rv, 37000, true)
	return _rp
}

//QApplication::font(QWidget const*)
func (q *QApplication) FontWithWidget(value QWidgetInterface) *QFont {
	var __rv uintptr
	q.Drv(6000, 6139, Native(value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QFont{}
	_rp.SetDriver(__rv, 37000, true)
	return _rp
}

//QApplication::font(char const*)
func QApplicationFontWithClassname(className string) *QFont {
	_className := NewCStringHead(className)
	defer FreeCStringHead(_className)
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6140, unsafe.Pointer(_className), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QFont{}
	_rp.SetDriver(__rv, 37000, true)
	return _rp
}

//QApplication::font(char const*)
func (q *QApplication) FontWithClassname(className string) *QFont {
	_className := NewCStringHead(className)
	defer FreeCStringHead(_className)
	var __rv uintptr
	q.Drv(6000, 6140, unsafe.Pointer(_className), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QFont{}
	_rp.SetDriver(__rv, 37000, true)
	return _rp
}

//QApplication::fontMetrics()
func QApplicationFontMetrics() *QFontMetrics {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6141, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QFontMetrics{}
	_rp.SetDriver(__rv, 40000, true)
	return _rp
}

//QApplication::fontMetrics()
func (q *QApplication) FontMetrics() *QFontMetrics {
	var __rv uintptr
	q.Drv(6000, 6141, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QFontMetrics{}
	_rp.SetDriver(__rv, 40000, true)
	return _rp
}

//QApplication::globalStrut()
func QApplicationGlobalStrut() *QSize {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6142, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QSize{}
	_rp.SetDriver(__rv, 120000, true)
	return _rp
}

//QApplication::globalStrut()
func (q *QApplication) GlobalStrut() *QSize {
	var __rv uintptr
	q.Drv(6000, 6142, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QSize{}
	_rp.SetDriver(__rv, 120000, true)
	return _rp
}

//QCoreApplication::hasPendingEvents()
func QApplicationHasPendingEvents() bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6143, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::hasPendingEvents()
func (q *QApplication) HasPendingEvents() bool {
	var __rv bool
	q.Drv(6000, 6143, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::installTranslator(QTranslator*)
func QApplicationInstallTranslator(messageFile *QTranslator) {
	DirectQtDrv(nil, 6000, 6144, Native(messageFile), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::installTranslator(QTranslator*)
func (q *QApplication) InstallTranslator(messageFile *QTranslator) {
	q.Drv(6000, 6144, Native(messageFile), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::instance()
func QApplicationInstance() *QApplication {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6145, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QApplication{}
	_rp.SetDriver(__rv, 6000, false)
	return _rp
}

//QCoreApplication::instance()
func (q *QApplication) Instance() *QApplication {
	var __rv uintptr
	q.Drv(6000, 6145, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QApplication{}
	_rp.SetDriver(__rv, 6000, false)
	return _rp
}

//QApplication::isEffectEnabled(Qt::UIEffect)
func QApplicationIsEffectEnabled(value Qt_UIEffect) bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6146, unsafe.Pointer(&value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::isEffectEnabled(Qt::UIEffect)
func (q *QApplication) IsEffectEnabled(value Qt_UIEffect) bool {
	var __rv bool
	q.Drv(6000, 6146, unsafe.Pointer(&value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::isLeftToRight()
func QApplicationIsLeftToRight() bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6147, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::isLeftToRight()
func (q *QApplication) IsLeftToRight() bool {
	var __rv bool
	q.Drv(6000, 6147, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::isRightToLeft()
func QApplicationIsRightToLeft() bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6148, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::isRightToLeft()
func (q *QApplication) IsRightToLeft() bool {
	var __rv bool
	q.Drv(6000, 6148, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::isSessionRestored()
func (q *QApplication) IsSessionRestored() bool {
	var __rv bool
	q.Drv(6000, 6149, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::keyboardInputInterval()
func QApplicationKeyboardInputInterval() int32 {
	var __rv int32
	DirectQtDrv(nil, 6000, 6150, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::keyboardInputInterval()
func (q *QApplication) KeyboardInputInterval() int32 {
	var __rv int32
	q.Drv(6000, 6150, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::keyboardModifiers()
func QApplicationKeyboardModifiers() Qt_KeyboardModifier {
	var __rv Qt_KeyboardModifier
	DirectQtDrv(nil, 6000, 6151, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::keyboardModifiers()
func (q *QApplication) KeyboardModifiers() Qt_KeyboardModifier {
	var __rv Qt_KeyboardModifier
	q.Drv(6000, 6151, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::layoutDirection()
func QApplicationLayoutDirection() Qt_LayoutDirection {
	var __rv Qt_LayoutDirection
	DirectQtDrv(nil, 6000, 6152, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::layoutDirection()
func (q *QApplication) LayoutDirection() Qt_LayoutDirection {
	var __rv Qt_LayoutDirection
	q.Drv(6000, 6152, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::libraryPaths()
func QApplicationLibraryPaths() []string {
	var __rv []string
	DirectQtDrv(nil, 6000, 6153, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::libraryPaths()
func (q *QApplication) LibraryPaths() []string {
	var __rv []string
	q.Drv(6000, 6153, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::mouseButtons()
func QApplicationMouseButtons() Qt_MouseButton {
	var __rv Qt_MouseButton
	DirectQtDrv(nil, 6000, 6154, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::mouseButtons()
func (q *QApplication) MouseButtons() Qt_MouseButton {
	var __rv Qt_MouseButton
	q.Drv(6000, 6154, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::notify(QObject*,QEvent*)
func (q *QApplication) Notify(value2 QObjectInterface, value3 *QEvent) bool {
	var __rv bool
	q.Drv(6000, 6155, Native(value2), Native(value3), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::organizationDomain()
func QApplicationOrganizationDomain() string {
	var __rv C.string_head
	DirectQtDrv(nil, 6000, 6156, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::organizationDomain()
func (q *QApplication) OrganizationDomain() string {
	var __rv C.string_head
	q.Drv(6000, 6156, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::organizationName()
func QApplicationOrganizationName() string {
	var __rv C.string_head
	DirectQtDrv(nil, 6000, 6157, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::organizationName()
func (q *QApplication) OrganizationName() string {
	var __rv C.string_head
	q.Drv(6000, 6157, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QApplication::overrideCursor()
func QApplicationOverrideCursor() *QCursor {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6158, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QCursor{}
	_rp.SetDriver(__rv, 18000, true)
	return _rp
}

//QApplication::overrideCursor()
func (q *QApplication) OverrideCursor() *QCursor {
	var __rv uintptr
	q.Drv(6000, 6158, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QCursor{}
	_rp.SetDriver(__rv, 18000, true)
	return _rp
}

//QApplication::palette()
func QApplicationPalette() *QPalette {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6159, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPalette{}
	_rp.SetDriver(__rv, 92000, true)
	return _rp
}

//QApplication::palette()
func (q *QApplication) Palette() *QPalette {
	var __rv uintptr
	q.Drv(6000, 6159, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPalette{}
	_rp.SetDriver(__rv, 92000, true)
	return _rp
}

//QApplication::palette(QWidget const*)
func QApplicationPaletteWithWidget(value QWidgetInterface) *QPalette {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6160, Native(value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPalette{}
	_rp.SetDriver(__rv, 92000, true)
	return _rp
}

//QApplication::palette(QWidget const*)
func (q *QApplication) PaletteWithWidget(value QWidgetInterface) *QPalette {
	var __rv uintptr
	q.Drv(6000, 6160, Native(value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPalette{}
	_rp.SetDriver(__rv, 92000, true)
	return _rp
}

//QApplication::palette(char const*)
func QApplicationPaletteWithClassname(className string) *QPalette {
	_className := NewCStringHead(className)
	defer FreeCStringHead(_className)
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6161, unsafe.Pointer(_className), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPalette{}
	_rp.SetDriver(__rv, 92000, true)
	return _rp
}

//QApplication::palette(char const*)
func (q *QApplication) PaletteWithClassname(className string) *QPalette {
	_className := NewCStringHead(className)
	defer FreeCStringHead(_className)
	var __rv uintptr
	q.Drv(6000, 6161, unsafe.Pointer(_className), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPalette{}
	_rp.SetDriver(__rv, 92000, true)
	return _rp
}

//QCoreApplication::postEvent(QObject*,QEvent*)
func QApplicationPostEvent(receiver QObjectInterface, event *QEvent) {
	DirectQtDrv(nil, 6000, 6162, Native(receiver), Native(event), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::postEvent(QObject*,QEvent*)
func (q *QApplication) PostEvent(receiver QObjectInterface, event *QEvent) {
	q.Drv(6000, 6162, Native(receiver), Native(event), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::quit()
func QApplicationQuit() {
	DirectQtDrv(nil, 6000, 6163, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::quit()
func (q *QApplication) Quit() {
	q.Drv(6000, 6163, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::quitOnLastWindowClosed()
func QApplicationQuitOnLastWindowClosed() bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6164, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::quitOnLastWindowClosed()
func (q *QApplication) QuitOnLastWindowClosed() bool {
	var __rv bool
	q.Drv(6000, 6164, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::removeLibraryPath(QString const&)
func QApplicationRemoveLibraryPath(value string) {
	_value := NewCStringHead(value)
	defer FreeCStringHead(_value)
	DirectQtDrv(nil, 6000, 6165, unsafe.Pointer(_value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::removeLibraryPath(QString const&)
func (q *QApplication) RemoveLibraryPath(value string) {
	_value := NewCStringHead(value)
	defer FreeCStringHead(_value)
	q.Drv(6000, 6165, unsafe.Pointer(_value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::removePostedEvents(QObject*)
func QApplicationRemovePostedEvents(receiver QObjectInterface) {
	DirectQtDrv(nil, 6000, 6166, Native(receiver), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::removePostedEvents(QObject*)
func (q *QApplication) RemovePostedEvents(receiver QObjectInterface) {
	q.Drv(6000, 6166, Native(receiver), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::removeTranslator(QTranslator*)
func QApplicationRemoveTranslator(messageFile *QTranslator) {
	DirectQtDrv(nil, 6000, 6167, Native(messageFile), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::removeTranslator(QTranslator*)
func (q *QApplication) RemoveTranslator(messageFile *QTranslator) {
	q.Drv(6000, 6167, Native(messageFile), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::restoreOverrideCursor()
func QApplicationRestoreOverrideCursor() {
	DirectQtDrv(nil, 6000, 6168, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::restoreOverrideCursor()
func (q *QApplication) RestoreOverrideCursor() {
	q.Drv(6000, 6168, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::sendEvent(QObject*,QEvent*)
func QApplicationSendEvent(receiver QObjectInterface, event *QEvent) bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6169, Native(receiver), Native(event), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::sendEvent(QObject*,QEvent*)
func (q *QApplication) SendEvent(receiver QObjectInterface, event *QEvent) bool {
	var __rv bool
	q.Drv(6000, 6169, Native(receiver), Native(event), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::sendPostedEvents()
func QApplicationSendPostedEvents() {
	DirectQtDrv(nil, 6000, 6170, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::sendPostedEvents()
func (q *QApplication) SendPostedEvents() {
	q.Drv(6000, 6170, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::sessionId()
func (q *QApplication) SessionId() string {
	var __rv C.string_head
	q.Drv(6000, 6171, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QApplication::sessionKey()
func (q *QApplication) SessionKey() string {
	var __rv C.string_head
	q.Drv(6000, 6172, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QApplication::setActiveWindow(QWidget*)
func QApplicationSetActiveWindow(act QWidgetInterface) {
	DirectQtDrv(nil, 6000, 6173, Native(act), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setActiveWindow(QWidget*)
func (q *QApplication) SetActiveWindow(act QWidgetInterface) {
	q.Drv(6000, 6173, Native(act), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setApplicationName(QString const&)
func QApplicationSetApplicationName(application string) {
	_application := NewCStringHead(application)
	defer FreeCStringHead(_application)
	DirectQtDrv(nil, 6000, 6174, unsafe.Pointer(_application), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setApplicationName(QString const&)
func (q *QApplication) SetApplicationName(application string) {
	_application := NewCStringHead(application)
	defer FreeCStringHead(_application)
	q.Drv(6000, 6174, unsafe.Pointer(_application), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setApplicationVersion(QString const&)
func QApplicationSetApplicationVersion(version string) {
	_version := NewCStringHead(version)
	defer FreeCStringHead(_version)
	DirectQtDrv(nil, 6000, 6175, unsafe.Pointer(_version), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setApplicationVersion(QString const&)
func (q *QApplication) SetApplicationVersion(version string) {
	_version := NewCStringHead(version)
	defer FreeCStringHead(_version)
	q.Drv(6000, 6175, unsafe.Pointer(_version), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setAttribute(Qt::ApplicationAttribute)
func QApplicationSetAttribute(attribute Qt_ApplicationAttribute) {
	DirectQtDrv(nil, 6000, 6176, unsafe.Pointer(&attribute), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setAttribute(Qt::ApplicationAttribute)
func (q *QApplication) SetAttribute(attribute Qt_ApplicationAttribute) {
	q.Drv(6000, 6176, unsafe.Pointer(&attribute), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setAttribute(Qt::ApplicationAttribute,bool)
func QApplicationSetAttributeWithAttributeOn(attribute Qt_ApplicationAttribute, on bool) {
	DirectQtDrv(nil, 6000, 6177, unsafe.Pointer(&attribute), unsafe.Pointer(&on), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setAttribute(Qt::ApplicationAttribute,bool)
func (q *QApplication) SetAttributeWithAttributeOn(attribute Qt_ApplicationAttribute, on bool) {
	q.Drv(6000, 6177, unsafe.Pointer(&attribute), unsafe.Pointer(&on), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setAutoSipEnabled(bool const)
func (q *QApplication) SetAutoSipEnabled(enabled bool) {
	q.Drv(6000, 6178, unsafe.Pointer(&enabled), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setColorSpec(int)
func QApplicationSetColorSpec(value int32) {
	DirectQtDrv(nil, 6000, 6179, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setColorSpec(int)
func (q *QApplication) SetColorSpec(value int32) {
	q.Drv(6000, 6179, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setCursorFlashTime(int)
func QApplicationSetCursorFlashTime(value int32) {
	DirectQtDrv(nil, 6000, 6180, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setCursorFlashTime(int)
func (q *QApplication) SetCursorFlashTime(value int32) {
	q.Drv(6000, 6180, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setDesktopSettingsAware(bool)
func QApplicationSetDesktopSettingsAware(value bool) {
	DirectQtDrv(nil, 6000, 6181, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setDesktopSettingsAware(bool)
func (q *QApplication) SetDesktopSettingsAware(value bool) {
	q.Drv(6000, 6181, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setDoubleClickInterval(int)
func QApplicationSetDoubleClickInterval(value int32) {
	DirectQtDrv(nil, 6000, 6182, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setDoubleClickInterval(int)
func (q *QApplication) SetDoubleClickInterval(value int32) {
	q.Drv(6000, 6182, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setEffectEnabled(Qt::UIEffect)
func QApplicationSetEffectEnabled(value Qt_UIEffect) {
	DirectQtDrv(nil, 6000, 6183, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setEffectEnabled(Qt::UIEffect)
func (q *QApplication) SetEffectEnabled(value Qt_UIEffect) {
	q.Drv(6000, 6183, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setEffectEnabled(Qt::UIEffect,bool)
func QApplicationSetEffectEnabledWithUieffectEnable(value2 Qt_UIEffect, enable bool) {
	DirectQtDrv(nil, 6000, 6184, unsafe.Pointer(&value2), unsafe.Pointer(&enable), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setEffectEnabled(Qt::UIEffect,bool)
func (q *QApplication) SetEffectEnabledWithUieffectEnable(value2 Qt_UIEffect, enable bool) {
	q.Drv(6000, 6184, unsafe.Pointer(&value2), unsafe.Pointer(&enable), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setFont(QFont const&)
func QApplicationSetFont(value *QFont) {
	DirectQtDrv(nil, 6000, 6185, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setFont(QFont const&)
func (q *QApplication) SetFont(value *QFont) {
	q.Drv(6000, 6185, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setFont(QFont const&,char const*)
func QApplicationSetFontWithFontClassname(value2 *QFont, className string) {
	_className := NewCStringHead(className)
	defer FreeCStringHead(_className)
	DirectQtDrv(nil, 6000, 6186, Native(value2), unsafe.Pointer(_className), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setFont(QFont const&,char const*)
func (q *QApplication) SetFontWithFontClassname(value2 *QFont, className string) {
	_className := NewCStringHead(className)
	defer FreeCStringHead(_className)
	q.Drv(6000, 6186, Native(value2), unsafe.Pointer(_className), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setGlobalStrut(QSize const&)
func QApplicationSetGlobalStrut(value *QSize) {
	DirectQtDrv(nil, 6000, 6187, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setGlobalStrut(QSize const&)
func (q *QApplication) SetGlobalStrut(value *QSize) {
	q.Drv(6000, 6187, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setKeyboardInputInterval(int)
func QApplicationSetKeyboardInputInterval(value int32) {
	DirectQtDrv(nil, 6000, 6188, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setKeyboardInputInterval(int)
func (q *QApplication) SetKeyboardInputInterval(value int32) {
	q.Drv(6000, 6188, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setLayoutDirection(Qt::LayoutDirection)
func QApplicationSetLayoutDirection(direction Qt_LayoutDirection) {
	DirectQtDrv(nil, 6000, 6189, unsafe.Pointer(&direction), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setLayoutDirection(Qt::LayoutDirection)
func (q *QApplication) SetLayoutDirection(direction Qt_LayoutDirection) {
	q.Drv(6000, 6189, unsafe.Pointer(&direction), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setLibraryPaths(QStringList const&)
func QApplicationSetLibraryPaths(value []string) {
	_value, _value_size := NewCSArray(value)
	defer FreeCSArray(_value, _value_size)
	DirectQtDrv(nil, 6000, 6190, unsafe.Pointer(&_value[0]), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setLibraryPaths(QStringList const&)
func (q *QApplication) SetLibraryPaths(value []string) {
	_value, _value_size := NewCSArray(value)
	defer FreeCSArray(_value, _value_size)
	q.Drv(6000, 6190, unsafe.Pointer(&_value[0]), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setOrganizationDomain(QString const&)
func QApplicationSetOrganizationDomain(orgDomain string) {
	_orgDomain := NewCStringHead(orgDomain)
	defer FreeCStringHead(_orgDomain)
	DirectQtDrv(nil, 6000, 6191, unsafe.Pointer(_orgDomain), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setOrganizationDomain(QString const&)
func (q *QApplication) SetOrganizationDomain(orgDomain string) {
	_orgDomain := NewCStringHead(orgDomain)
	defer FreeCStringHead(_orgDomain)
	q.Drv(6000, 6191, unsafe.Pointer(_orgDomain), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setOrganizationName(QString const&)
func QApplicationSetOrganizationName(orgName string) {
	_orgName := NewCStringHead(orgName)
	defer FreeCStringHead(_orgName)
	DirectQtDrv(nil, 6000, 6192, unsafe.Pointer(_orgName), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCoreApplication::setOrganizationName(QString const&)
func (q *QApplication) SetOrganizationName(orgName string) {
	_orgName := NewCStringHead(orgName)
	defer FreeCStringHead(_orgName)
	q.Drv(6000, 6192, unsafe.Pointer(_orgName), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setOverrideCursor(QCursor const&)
func QApplicationSetOverrideCursor(value *QCursor) {
	DirectQtDrv(nil, 6000, 6193, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setOverrideCursor(QCursor const&)
func (q *QApplication) SetOverrideCursor(value *QCursor) {
	q.Drv(6000, 6193, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setPalette(QPalette const&)
func QApplicationSetPalette(value *QPalette) {
	DirectQtDrv(nil, 6000, 6194, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setPalette(QPalette const&)
func (q *QApplication) SetPalette(value *QPalette) {
	q.Drv(6000, 6194, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setPalette(QPalette const&,char const*)
func QApplicationSetPaletteWithPaletteClassname(value2 *QPalette, className string) {
	_className := NewCStringHead(className)
	defer FreeCStringHead(_className)
	DirectQtDrv(nil, 6000, 6195, Native(value2), unsafe.Pointer(_className), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setPalette(QPalette const&,char const*)
func (q *QApplication) SetPaletteWithPaletteClassname(value2 *QPalette, className string) {
	_className := NewCStringHead(className)
	defer FreeCStringHead(_className)
	q.Drv(6000, 6195, Native(value2), unsafe.Pointer(_className), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setQuitOnLastWindowClosed(bool)
func QApplicationSetQuitOnLastWindowClosed(quit bool) {
	DirectQtDrv(nil, 6000, 6196, unsafe.Pointer(&quit), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setQuitOnLastWindowClosed(bool)
func (q *QApplication) SetQuitOnLastWindowClosed(quit bool) {
	q.Drv(6000, 6196, unsafe.Pointer(&quit), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setStartDragDistance(int)
func QApplicationSetStartDragDistance(l int32) {
	DirectQtDrv(nil, 6000, 6197, unsafe.Pointer(&l), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setStartDragDistance(int)
func (q *QApplication) SetStartDragDistance(l int32) {
	q.Drv(6000, 6197, unsafe.Pointer(&l), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setStartDragTime(int)
func QApplicationSetStartDragTime(ms int32) {
	DirectQtDrv(nil, 6000, 6198, unsafe.Pointer(&ms), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setStartDragTime(int)
func (q *QApplication) SetStartDragTime(ms int32) {
	q.Drv(6000, 6198, unsafe.Pointer(&ms), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setStyle(QString const&)
func QApplicationSetStyle(value string) *QStyle {
	_value := NewCStringHead(value)
	defer FreeCStringHead(_value)
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6199, unsafe.Pointer(_value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QStyle{}
	_rp.SetDriver(__rv, 359000, false)
	return _rp
}

//QApplication::setStyle(QString const&)
func (q *QApplication) SetStyle(value string) *QStyle {
	_value := NewCStringHead(value)
	defer FreeCStringHead(_value)
	var __rv uintptr
	q.Drv(6000, 6199, unsafe.Pointer(_value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QStyle{}
	_rp.SetDriver(__rv, 359000, false)
	return _rp
}

//QApplication::setStyle(QStyle*)
func QApplicationSetStyleWithStyle(value *QStyle) {
	DirectQtDrv(nil, 6000, 6200, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setStyle(QStyle*)
func (q *QApplication) SetStyleWithStyle(value *QStyle) {
	q.Drv(6000, 6200, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setStyleSheet(QString const&)
func (q *QApplication) SetStyleSheet(sheet string) {
	_sheet := NewCStringHead(sheet)
	defer FreeCStringHead(_sheet)
	q.Drv(6000, 6201, unsafe.Pointer(_sheet), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setWheelScrollLines(int)
func QApplicationSetWheelScrollLines(value int32) {
	DirectQtDrv(nil, 6000, 6202, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setWheelScrollLines(int)
func (q *QApplication) SetWheelScrollLines(value int32) {
	q.Drv(6000, 6202, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setWindowIcon(QIcon const&)
func QApplicationSetWindowIcon(icon *QIcon) {
	DirectQtDrv(nil, 6000, 6203, Native(icon), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::setWindowIcon(QIcon const&)
func (q *QApplication) SetWindowIcon(icon *QIcon) {
	q.Drv(6000, 6203, Native(icon), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QApplication::startDragDistance()
func QApplicationStartDragDistance() int32 {
	var __rv int32
	DirectQtDrv(nil, 6000, 6204, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::startDragDistance()
func (q *QApplication) StartDragDistance() int32 {
	var __rv int32
	q.Drv(6000, 6204, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::startDragTime()
func QApplicationStartDragTime() int32 {
	var __rv int32
	DirectQtDrv(nil, 6000, 6205, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::startDragTime()
func (q *QApplication) StartDragTime() int32 {
	var __rv int32
	q.Drv(6000, 6205, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::startingUp()
func QApplicationStartingUp() bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6206, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::startingUp()
func (q *QApplication) StartingUp() bool {
	var __rv bool
	q.Drv(6000, 6206, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::style()
func QApplicationStyle() *QStyle {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6207, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QStyle{}
	_rp.SetDriver(__rv, 359000, false)
	return _rp
}

//QApplication::style()
func (q *QApplication) Style() *QStyle {
	var __rv uintptr
	q.Drv(6000, 6207, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QStyle{}
	_rp.SetDriver(__rv, 359000, false)
	return _rp
}

//QApplication::styleSheet()
func (q *QApplication) StyleSheet() string {
	var __rv C.string_head
	q.Drv(6000, 6208, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::testAttribute(Qt::ApplicationAttribute)
func QApplicationTestAttribute(attribute Qt_ApplicationAttribute) bool {
	var __rv bool
	DirectQtDrv(nil, 6000, 6209, unsafe.Pointer(&attribute), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::testAttribute(Qt::ApplicationAttribute)
func (q *QApplication) TestAttribute(attribute Qt_ApplicationAttribute) bool {
	var __rv bool
	q.Drv(6000, 6209, unsafe.Pointer(&attribute), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::topLevelAt(QPoint const&)
func QApplicationTopLevelAt(p *QPoint) *QWidget {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6210, Native(p), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::topLevelAt(QPoint const&)
func (q *QApplication) TopLevelAt(p *QPoint) *QWidget {
	var __rv uintptr
	q.Drv(6000, 6210, Native(p), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::topLevelAt(int,int)
func QApplicationTopLevelAtWithXY(x int32, y int32) *QWidget {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6211, unsafe.Pointer(&x), unsafe.Pointer(&y), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::topLevelAt(int,int)
func (q *QApplication) TopLevelAtWithXY(x int32, y int32) *QWidget {
	var __rv uintptr
	q.Drv(6000, 6211, unsafe.Pointer(&x), unsafe.Pointer(&y), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::topLevelWidgets()
func QApplicationTopLevelWidgets() []*QWidget {
	var __rv []*QWidget
	DirectQtDrv(nil, 6000, 6212, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::topLevelWidgets()
func (q *QApplication) TopLevelWidgets() []*QWidget {
	var __rv []*QWidget
	q.Drv(6000, 6212, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCoreApplication::translate(char const*,char const*,char const*)
func QApplicationTranslate(context string, key string, disambiguation string) string {
	_context := NewCStringHead(context)
	defer FreeCStringHead(_context)
	_key := NewCStringHead(key)
	defer FreeCStringHead(_key)
	_disambiguation := NewCStringHead(disambiguation)
	defer FreeCStringHead(_disambiguation)
	var __rv C.string_head
	DirectQtDrv(nil, 6000, 6213, unsafe.Pointer(_context), unsafe.Pointer(_key), unsafe.Pointer(_disambiguation), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::translate(char const*,char const*,char const*)
func (q *QApplication) Translate(context string, key string, disambiguation string) string {
	_context := NewCStringHead(context)
	defer FreeCStringHead(_context)
	_key := NewCStringHead(key)
	defer FreeCStringHead(_key)
	_disambiguation := NewCStringHead(disambiguation)
	defer FreeCStringHead(_disambiguation)
	var __rv C.string_head
	q.Drv(6000, 6213, unsafe.Pointer(_context), unsafe.Pointer(_key), unsafe.Pointer(_disambiguation), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::translaten(char const*,char const*,char const*,int)
func QApplicationTranslaten(context string, key string, disambiguation string, n int32) string {
	_context := NewCStringHead(context)
	defer FreeCStringHead(_context)
	_key := NewCStringHead(key)
	defer FreeCStringHead(_key)
	_disambiguation := NewCStringHead(disambiguation)
	defer FreeCStringHead(_disambiguation)
	var __rv C.string_head
	DirectQtDrv(nil, 6000, 6214, unsafe.Pointer(_context), unsafe.Pointer(_key), unsafe.Pointer(_disambiguation), unsafe.Pointer(&n), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QCoreApplication::translaten(char const*,char const*,char const*,int)
func (q *QApplication) Translaten(context string, key string, disambiguation string, n int32) string {
	_context := NewCStringHead(context)
	defer FreeCStringHead(_context)
	_key := NewCStringHead(key)
	defer FreeCStringHead(_key)
	_disambiguation := NewCStringHead(disambiguation)
	defer FreeCStringHead(_disambiguation)
	var __rv C.string_head
	q.Drv(6000, 6214, unsafe.Pointer(_context), unsafe.Pointer(_key), unsafe.Pointer(_disambiguation), unsafe.Pointer(&n), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QApplication::wheelScrollLines()
func QApplicationWheelScrollLines() int32 {
	var __rv int32
	DirectQtDrv(nil, 6000, 6215, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::wheelScrollLines()
func (q *QApplication) WheelScrollLines() int32 {
	var __rv int32
	q.Drv(6000, 6215, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QApplication::widgetAt(QPoint const&)
func QApplicationWidgetAt(p *QPoint) *QWidget {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6216, Native(p), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::widgetAt(QPoint const&)
func (q *QApplication) WidgetAt(p *QPoint) *QWidget {
	var __rv uintptr
	q.Drv(6000, 6216, Native(p), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::widgetAt(int,int)
func QApplicationWidgetAtWithXY(x int32, y int32) *QWidget {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6217, unsafe.Pointer(&x), unsafe.Pointer(&y), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::widgetAt(int,int)
func (q *QApplication) WidgetAtWithXY(x int32, y int32) *QWidget {
	var __rv uintptr
	q.Drv(6000, 6217, unsafe.Pointer(&x), unsafe.Pointer(&y), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//QApplication::windowIcon()
func QApplicationWindowIcon() *QIcon {
	var __rv uintptr
	DirectQtDrv(nil, 6000, 6218, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QIcon{}
	_rp.SetDriver(__rv, 51000, true)
	return _rp
}

//QApplication::windowIcon()
func (q *QApplication) WindowIcon() *QIcon {
	var __rv uintptr
	q.Drv(6000, 6218, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QIcon{}
	_rp.SetDriver(__rv, 51000, true)
	return _rp
}

//struct QBasicTimer : QBasicTimer
type QBasicTimer struct {
	BaseDrv
}

//QBasicTimer::QBasicTimer()
func NewBasicTimer() *QBasicTimer {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 7000, 7102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBasicTimer{}
	_p.SetDriver(__rv, 7000, true)
	return _p
}

//QBasicTimer::isActive()
func (q *QBasicTimer) IsActive() bool {
	var __rv bool
	q.Drv(7000, 7103, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QBasicTimer::start(int,QObject*)
func (q *QBasicTimer) Start(msec int32, obj QObjectInterface) {
	q.Drv(7000, 7104, unsafe.Pointer(&msec), Native(obj), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBasicTimer::stop()
func (q *QBasicTimer) Stop() {
	q.Drv(7000, 7105, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBasicTimer::timerId()
func (q *QBasicTimer) TimerId() int32 {
	var __rv int32
	q.Drv(7000, 7106, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//struct QBitmap : QBitmap
type QBitmap struct {
	QPixmap
}

//QBitmap::QBitmap()
func NewBitmap() *QBitmap {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 8000, 8102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBitmap{}
	_p.SetDriver(__rv, 8000, true)
	return _p
}

//QBitmap::QBitmap(QPixmap const&)
func NewBitmapWithPixmap(value *QPixmap) *QBitmap {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 8000, 8103, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBitmap{}
	_p.SetDriver(__rv, 8000, true)
	return _p
}

//QBitmap::QBitmap(QSize const&)
func NewBitmapWithSize(value *QSize) *QBitmap {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 8000, 8104, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBitmap{}
	_p.SetDriver(__rv, 8000, true)
	return _p
}

//QBitmap::QBitmap(QString const&,char const*)
func NewBitmapWithFilenameFormat(fileName string, format string) *QBitmap {
	_fileName := NewCStringHead(fileName)
	defer FreeCStringHead(_fileName)
	_format := NewCStringHead(format)
	defer FreeCStringHead(_format)
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 8000, 8105, unsafe.Pointer(_fileName), unsafe.Pointer(_format), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBitmap{}
	_p.SetDriver(__rv, 8000, true)
	return _p
}

//QBitmap::QBitmap(int,int)
func NewBitmapWithWidthHeight(w int32, h int32) *QBitmap {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 8000, 8106, unsafe.Pointer(&w), unsafe.Pointer(&h), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBitmap{}
	_p.SetDriver(__rv, 8000, true)
	return _p
}

//QBitmap::clear()
func (q *QBitmap) Clear() {
	q.Drv(8000, 8107, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBitmap::fromData(QSize const&,unsigned char const*,QImage::Format)
func QBitmapFromData(size *QSize, bits *byte, monoFormat QImage_Format) *QBitmap {
	var __rv uintptr
	DirectQtDrv(nil, 8000, 8108, Native(size), unsafe.Pointer(&bits), unsafe.Pointer(&monoFormat), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//QBitmap::fromData(QSize const&,unsigned char const*,QImage::Format)
func (q *QBitmap) FromData(size *QSize, bits *byte, monoFormat QImage_Format) *QBitmap {
	var __rv uintptr
	q.Drv(8000, 8108, Native(size), unsafe.Pointer(&bits), unsafe.Pointer(&monoFormat), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//QBitmap::fromImage(QImage const&)
func QBitmapFromImage(image *QImage) *QBitmap {
	var __rv uintptr
	DirectQtDrv(nil, 8000, 8109, Native(image), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//QBitmap::fromImage(QImage const&)
func (q *QBitmap) FromImage(image *QImage) *QBitmap {
	var __rv uintptr
	q.Drv(8000, 8109, Native(image), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//QBitmap::fromImage(QImage const&,QFlags<Qt::ImageConversionFlag>)
func QBitmapFromImageWithImageFlags(image *QImage, flags Qt_ImageConversionFlag) *QBitmap {
	var __rv uintptr
	DirectQtDrv(nil, 8000, 8110, Native(image), unsafe.Pointer(&flags), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//QBitmap::fromImage(QImage const&,QFlags<Qt::ImageConversionFlag>)
func (q *QBitmap) FromImageWithImageFlags(image *QImage, flags Qt_ImageConversionFlag) *QBitmap {
	var __rv uintptr
	q.Drv(8000, 8110, Native(image), unsafe.Pointer(&flags), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//QBitmap::transformed(QMatrix const&)
func (q *QBitmap) Transformed(value *QMatrix) *QBitmap {
	var __rv uintptr
	q.Drv(8000, 8111, Native(value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//QBitmap::transformed(QTransform const&)
func (q *QBitmap) TransformedWithTransform(matrix *QTransform) *QBitmap {
	var __rv uintptr
	q.Drv(8000, 8112, Native(matrix), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//struct QBrush : QBrush
type QBrush struct {
	BaseDrv
}

//QBrush::QBrush()
func NewBrush() *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::QBrush(QBrush const&)
func NewBrushCopy(brush *QBrush) *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9103, Native(brush), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::QBrush(QGradient const&)
func NewBrushWithGradient(gradient *QGradient) *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9104, Native(gradient), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::QBrush(QImage const&)
func NewBrushWithImage(image *QImage) *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9105, Native(image), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::QBrush(QPixmap const&)
func NewBrushWithPixmap(pixmap *QPixmap) *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9106, Native(pixmap), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::QBrush(Qt::BrushStyle)
func NewBrushWithBrushstyle(bs Qt_BrushStyle) *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9107, unsafe.Pointer(&bs), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::QBrush(QColor const&,QPixmap const&)
func NewBrushWithColorPixmap(color *QColor, pixmap *QPixmap) *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9108, Native(color), Native(pixmap), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::QBrush(QColor const&,Qt::BrushStyle)
func NewBrushWithColorBrushstyle(color *QColor, bs Qt_BrushStyle) *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9109, Native(color), unsafe.Pointer(&bs), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::QBrush(Qt::GlobalColor,QPixmap const&)
func NewBrushWithGlobalcolorPixmap(color Qt_GlobalColor, pixmap *QPixmap) *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9110, unsafe.Pointer(&color), Native(pixmap), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::QBrush(Qt::GlobalColor,Qt::BrushStyle)
func NewBrushWithGlobalcolorBrushstyle(color Qt_GlobalColor, bs Qt_BrushStyle) *QBrush {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 9000, 9111, unsafe.Pointer(&color), unsafe.Pointer(&bs), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QBrush{}
	_p.SetDriver(__rv, 9000, true)
	return _p
}

//QBrush::color()
func (q *QBrush) Color() *QColor {
	var __rv uintptr
	q.Drv(9000, 9112, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QBrush::gradient()
func (q *QBrush) Gradient() *QGradient {
	var __rv uintptr
	q.Drv(9000, 9113, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QGradient{}
	_rp.SetDriver(__rv, 46000, true)
	return _rp
}

//QBrush::isDetached()
func (q *QBrush) IsDetached() bool {
	var __rv bool
	q.Drv(9000, 9114, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QBrush::isOpaque()
func (q *QBrush) IsOpaque() bool {
	var __rv bool
	q.Drv(9000, 9115, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QBrush::matrix()
func (q *QBrush) Matrix() *QMatrix {
	var __rv uintptr
	q.Drv(9000, 9116, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QMatrix{}
	_rp.SetDriver(__rv, 75000, true)
	return _rp
}

//QBrush::setColor(QColor const&)
func (q *QBrush) SetColor(color *QColor) {
	q.Drv(9000, 9117, Native(color), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBrush::setColor(Qt::GlobalColor)
func (q *QBrush) SetColorWithGlobalcolor(color Qt_GlobalColor) {
	q.Drv(9000, 9118, unsafe.Pointer(&color), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBrush::setMatrix(QMatrix const&)
func (q *QBrush) SetMatrix(mat *QMatrix) {
	q.Drv(9000, 9119, Native(mat), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBrush::setStyle(Qt::BrushStyle)
func (q *QBrush) SetStyle(value Qt_BrushStyle) {
	q.Drv(9000, 9120, unsafe.Pointer(&value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBrush::setTexture(QPixmap const&)
func (q *QBrush) SetTexture(pixmap *QPixmap) {
	q.Drv(9000, 9121, Native(pixmap), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBrush::setTextureImage(QImage const&)
func (q *QBrush) SetTextureImage(image *QImage) {
	q.Drv(9000, 9122, Native(image), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBrush::setTransform(QTransform const&)
func (q *QBrush) SetTransform(value *QTransform) {
	q.Drv(9000, 9123, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QBrush::style()
func (q *QBrush) Style() Qt_BrushStyle {
	var __rv Qt_BrushStyle
	q.Drv(9000, 9124, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QBrush::texture()
func (q *QBrush) Texture() *QPixmap {
	var __rv uintptr
	q.Drv(9000, 9125, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPixmap{}
	_rp.SetDriver(__rv, 97000, true)
	return _rp
}

//QBrush::textureImage()
func (q *QBrush) TextureImage() *QImage {
	var __rv uintptr
	q.Drv(9000, 9126, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QImage{}
	_rp.SetDriver(__rv, 53000, true)
	return _rp
}

//QBrush::transform()
func (q *QBrush) Transform() *QTransform {
	var __rv uintptr
	q.Drv(9000, 9127, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QTransform{}
	_rp.SetDriver(__rv, 178000, true)
	return _rp
}

//struct QByteArrayMatcher : QByteArrayMatcher
type QByteArrayMatcher struct {
	BaseDrv
}

//QByteArrayMatcher::QByteArrayMatcher()
func NewByteArrayMatcher() *QByteArrayMatcher {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 10000, 10102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QByteArrayMatcher{}
	_p.SetDriver(__rv, 10000, true)
	return _p
}

//QByteArrayMatcher::QByteArrayMatcher(QByteArray const&)
func NewByteArrayMatcherWithPattern(pattern []byte) *QByteArrayMatcher {
	_pattern := NewCByteArrayHead(pattern)
	defer FreeCByteArrayHead(_pattern)
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 10000, 10103, unsafe.Pointer(_pattern), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QByteArrayMatcher{}
	_p.SetDriver(__rv, 10000, true)
	return _p
}

//QByteArrayMatcher::QByteArrayMatcher(QByteArrayMatcher const&)
func NewByteArrayMatcherCopy(other *QByteArrayMatcher) *QByteArrayMatcher {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 10000, 10104, Native(other), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QByteArrayMatcher{}
	_p.SetDriver(__rv, 10000, true)
	return _p
}

//QByteArrayMatcher::indexIn(QByteArray const&)
func (q *QByteArrayMatcher) IndexIn(ba []byte) int32 {
	_ba := NewCByteArrayHead(ba)
	defer FreeCByteArrayHead(_ba)
	var __rv int32
	q.Drv(10000, 10105, unsafe.Pointer(_ba), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QByteArrayMatcher::indexIn(QByteArray const&,int)
func (q *QByteArrayMatcher) IndexInWithBaIfrom(ba []byte, from int32) int32 {
	_ba := NewCByteArrayHead(ba)
	defer FreeCByteArrayHead(_ba)
	var __rv int32
	q.Drv(10000, 10106, unsafe.Pointer(_ba), unsafe.Pointer(&from), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QByteArrayMatcher::pattern()
func (q *QByteArrayMatcher) Pattern() []byte {
	var __rv []byte
	q.Drv(10000, 10107, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QByteArrayMatcher::setPattern(QByteArray const&)
func (q *QByteArrayMatcher) SetPattern(pattern []byte) {
	_pattern := NewCByteArrayHead(pattern)
	defer FreeCByteArrayHead(_pattern)
	q.Drv(10000, 10108, unsafe.Pointer(_pattern), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//struct QChildEvent : QChildEvent
type QChildEvent struct {
	QEvent
}

//QChildEvent::QChildEvent(QEvent::Type,QObject*)
func NewChildEvent(_type QEvent_Type, child QObjectInterface) *QChildEvent {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 11000, 11102, unsafe.Pointer(&_type), Native(child), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QChildEvent{}
	_p.SetDriver(__rv, 11000, true)
	return _p
}

//QChildEvent::added()
func (q *QChildEvent) Added() bool {
	var __rv bool
	q.Drv(11000, 11103, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QChildEvent::child()
func (q *QChildEvent) Child() *QObject {
	var __rv uintptr
	q.Drv(11000, 11104, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QObject{}
	_rp.SetDriver(__rv, 316000, false)
	return _rp
}

//QChildEvent::polished()
func (q *QChildEvent) Polished() bool {
	var __rv bool
	q.Drv(11000, 11105, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QChildEvent::removed()
func (q *QChildEvent) Removed() bool {
	var __rv bool
	q.Drv(11000, 11106, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//struct QCloseEvent : QCloseEvent
type QCloseEvent struct {
	QEvent
}

//QCloseEvent::QCloseEvent()
func NewCloseEvent() *QCloseEvent {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 12000, 12102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QCloseEvent{}
	_p.SetDriver(__rv, 12000, true)
	return _p
}

//enum QColor_Spec - QColor::Spec
type QColor_Spec uint32

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
)

//struct QColor : QColor
type QColor struct {
	BaseDrv
}

//QColor::QColor()
func NewColor() *QColor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 13000, 13102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QColor{}
	_p.SetDriver(__rv, 13000, true)
	return _p
}

//QColor::QColor(QColor const&)
func NewColorCopy(color *QColor) *QColor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 13000, 13103, Native(color), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QColor{}
	_p.SetDriver(__rv, 13000, true)
	return _p
}

//QColor::QColor(QColor::Spec)
func NewColorWithSpec(spec QColor_Spec) *QColor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 13000, 13104, unsafe.Pointer(&spec), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QColor{}
	_p.SetDriver(__rv, 13000, true)
	return _p
}

//QColor::QColor(QString const&)
func NewColorWithName(name string) *QColor {
	_name := NewCStringHead(name)
	defer FreeCStringHead(_name)
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 13000, 13105, unsafe.Pointer(_name), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QColor{}
	_p.SetDriver(__rv, 13000, true)
	return _p
}

//QColor::QColor(Qt::GlobalColor)
func NewColorWithGlobalcolor(color Qt_GlobalColor) *QColor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 13000, 13106, unsafe.Pointer(&color), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QColor{}
	_p.SetDriver(__rv, 13000, true)
	return _p
}

//QColor::QColor(unsigned int)
func NewColorWithRgb(rgb uint32) *QColor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 13000, 13107, unsafe.Pointer(&rgb), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QColor{}
	_p.SetDriver(__rv, 13000, true)
	return _p
}

//QColor::QColor(int,int,int,int)
func NewColorWithInt32Int32Int32Int32(r int32, g int32, b int32, a int32) *QColor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 13000, 13108, unsafe.Pointer(&r), unsafe.Pointer(&g), unsafe.Pointer(&b), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QColor{}
	_p.SetDriver(__rv, 13000, true)
	return _p
}

//QColor::alpha()
func (q *QColor) Alpha() int32 {
	var __rv int32
	q.Drv(13000, 13109, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::alphaF()
func (q *QColor) AlphaF() float64 {
	var __rv float64
	q.Drv(13000, 13110, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::black()
func (q *QColor) Black() int32 {
	var __rv int32
	q.Drv(13000, 13111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::blackF()
func (q *QColor) BlackF() float64 {
	var __rv float64
	q.Drv(13000, 13112, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::blue()
func (q *QColor) Blue() int32 {
	var __rv int32
	q.Drv(13000, 13113, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::blueF()
func (q *QColor) BlueF() float64 {
	var __rv float64
	q.Drv(13000, 13114, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::colorNames()
func QColorColorNames() []string {
	var __rv []string
	DirectQtDrv(nil, 13000, 13115, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::colorNames()
func (q *QColor) ColorNames() []string {
	var __rv []string
	q.Drv(13000, 13115, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::convertTo(QColor::Spec)
func (q *QColor) ConvertTo(colorSpec QColor_Spec) *QColor {
	var __rv uintptr
	q.Drv(13000, 13116, unsafe.Pointer(&colorSpec), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::cyan()
func (q *QColor) Cyan() int32 {
	var __rv int32
	q.Drv(13000, 13117, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::cyanF()
func (q *QColor) CyanF() float64 {
	var __rv float64
	q.Drv(13000, 13118, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::dark()
func (q *QColor) Dark() *QColor {
	var __rv uintptr
	q.Drv(13000, 13119, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::dark(int)
func (q *QColor) DarkWithInt32(f int32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13120, unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::darker()
func (q *QColor) Darker() *QColor {
	var __rv uintptr
	q.Drv(13000, 13121, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::darker(int)
func (q *QColor) DarkerWithInt32(f int32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13122, unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromCmyk(int,int,int,int,int)
func QColorFromCmyk(c int32, m int32, y int32, k int32, a int32) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13123, unsafe.Pointer(&c), unsafe.Pointer(&m), unsafe.Pointer(&y), unsafe.Pointer(&k), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromCmyk(int,int,int,int,int)
func (q *QColor) FromCmyk(c int32, m int32, y int32, k int32, a int32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13123, unsafe.Pointer(&c), unsafe.Pointer(&m), unsafe.Pointer(&y), unsafe.Pointer(&k), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromCmykF(double,double,double,double,double)
func QColorFromCmykF(c float64, m float64, y float64, k float64, a float64) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13124, unsafe.Pointer(&c), unsafe.Pointer(&m), unsafe.Pointer(&y), unsafe.Pointer(&k), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromCmykF(double,double,double,double,double)
func (q *QColor) FromCmykF(c float64, m float64, y float64, k float64, a float64) *QColor {
	var __rv uintptr
	q.Drv(13000, 13124, unsafe.Pointer(&c), unsafe.Pointer(&m), unsafe.Pointer(&y), unsafe.Pointer(&k), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromHsl(int,int,int,int)
func QColorFromHsl(h int32, s int32, l int32, a int32) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13125, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&l), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromHsl(int,int,int,int)
func (q *QColor) FromHsl(h int32, s int32, l int32, a int32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13125, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&l), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromHslF(double,double,double,double)
func QColorFromHslF(h float64, s float64, l float64, a float64) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13126, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&l), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromHslF(double,double,double,double)
func (q *QColor) FromHslF(h float64, s float64, l float64, a float64) *QColor {
	var __rv uintptr
	q.Drv(13000, 13126, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&l), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromHsv(int,int,int,int)
func QColorFromHsv(h int32, s int32, v int32, a int32) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13127, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&v), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromHsv(int,int,int,int)
func (q *QColor) FromHsv(h int32, s int32, v int32, a int32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13127, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&v), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromHsvF(double,double,double,double)
func QColorFromHsvF(h float64, s float64, v float64, a float64) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13128, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&v), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromHsvF(double,double,double,double)
func (q *QColor) FromHsvF(h float64, s float64, v float64, a float64) *QColor {
	var __rv uintptr
	q.Drv(13000, 13128, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&v), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromRgb(unsigned int)
func QColorFromRgb(rgb uint32) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13129, unsafe.Pointer(&rgb), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromRgb(unsigned int)
func (q *QColor) FromRgb(rgb uint32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13129, unsafe.Pointer(&rgb), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromRgb(int,int,int,int)
func QColorFromRgbWithInt32Int32Int32Int32(r int32, g int32, b int32, a int32) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13130, unsafe.Pointer(&r), unsafe.Pointer(&g), unsafe.Pointer(&b), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromRgb(int,int,int,int)
func (q *QColor) FromRgbWithInt32Int32Int32Int32(r int32, g int32, b int32, a int32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13130, unsafe.Pointer(&r), unsafe.Pointer(&g), unsafe.Pointer(&b), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromRgbF(double,double,double,double)
func QColorFromRgbF(r float64, g float64, b float64, a float64) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13131, unsafe.Pointer(&r), unsafe.Pointer(&g), unsafe.Pointer(&b), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromRgbF(double,double,double,double)
func (q *QColor) FromRgbF(r float64, g float64, b float64, a float64) *QColor {
	var __rv uintptr
	q.Drv(13000, 13131, unsafe.Pointer(&r), unsafe.Pointer(&g), unsafe.Pointer(&b), unsafe.Pointer(&a), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromRgba(unsigned int)
func QColorFromRgba(rgba uint32) *QColor {
	var __rv uintptr
	DirectQtDrv(nil, 13000, 13132, unsafe.Pointer(&rgba), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::fromRgba(unsigned int)
func (q *QColor) FromRgba(rgba uint32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13132, unsafe.Pointer(&rgba), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::getCmyk(int*,int*,int*,int*,int*)
func (q *QColor) GetCmyk(c *int32, m *int32, y *int32, k *int32, a *int32) {
	q.Drv(13000, 13133, unsafe.Pointer(&c), unsafe.Pointer(&m), unsafe.Pointer(&y), unsafe.Pointer(&k), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil)
}

//QColor::getCmykF(double*,double*,double*,double*,double*)
func (q *QColor) GetCmykF(c *float64, m *float64, y *float64, k *float64, a *float64) {
	q.Drv(13000, 13134, unsafe.Pointer(&c), unsafe.Pointer(&m), unsafe.Pointer(&y), unsafe.Pointer(&k), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil)
}

//QColor::getHsl(int*,int*,int*,int*)
func (q *QColor) GetHsl(h *int32, s *int32, l *int32, a *int32) {
	q.Drv(13000, 13135, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&l), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::getHslF(double*,double*,double*,double*)
func (q *QColor) GetHslF(h *float64, s *float64, l *float64, a *float64) {
	q.Drv(13000, 13136, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&l), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::getHsv(int*,int*,int*,int*)
func (q *QColor) GetHsv(h *int32, s *int32, v *int32, a *int32) {
	q.Drv(13000, 13137, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&v), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::getHsvF(double*,double*,double*,double*)
func (q *QColor) GetHsvF(h *float64, s *float64, v *float64, a *float64) {
	q.Drv(13000, 13138, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&v), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::getRgb(int*,int*,int*,int*)
func (q *QColor) GetRgb(r *int32, g *int32, b *int32, a *int32) {
	q.Drv(13000, 13139, unsafe.Pointer(&r), unsafe.Pointer(&g), unsafe.Pointer(&b), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::getRgbF(double*,double*,double*,double*)
func (q *QColor) GetRgbF(r *float64, g *float64, b *float64, a *float64) {
	q.Drv(13000, 13140, unsafe.Pointer(&r), unsafe.Pointer(&g), unsafe.Pointer(&b), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::green()
func (q *QColor) Green() int32 {
	var __rv int32
	q.Drv(13000, 13141, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::greenF()
func (q *QColor) GreenF() float64 {
	var __rv float64
	q.Drv(13000, 13142, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hslHue()
func (q *QColor) HslHue() int32 {
	var __rv int32
	q.Drv(13000, 13143, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hslHueF()
func (q *QColor) HslHueF() float64 {
	var __rv float64
	q.Drv(13000, 13144, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hslSaturation()
func (q *QColor) HslSaturation() int32 {
	var __rv int32
	q.Drv(13000, 13145, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hslSaturationF()
func (q *QColor) HslSaturationF() float64 {
	var __rv float64
	q.Drv(13000, 13146, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hsvHue()
func (q *QColor) HsvHue() int32 {
	var __rv int32
	q.Drv(13000, 13147, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hsvHueF()
func (q *QColor) HsvHueF() float64 {
	var __rv float64
	q.Drv(13000, 13148, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hsvSaturation()
func (q *QColor) HsvSaturation() int32 {
	var __rv int32
	q.Drv(13000, 13149, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hsvSaturationF()
func (q *QColor) HsvSaturationF() float64 {
	var __rv float64
	q.Drv(13000, 13150, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hue()
func (q *QColor) Hue() int32 {
	var __rv int32
	q.Drv(13000, 13151, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::hueF()
func (q *QColor) HueF() float64 {
	var __rv float64
	q.Drv(13000, 13152, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::isValid()
func (q *QColor) IsValid() bool {
	var __rv bool
	q.Drv(13000, 13153, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::isValidColor(QString const&)
func QColorIsValidColor(name string) bool {
	_name := NewCStringHead(name)
	defer FreeCStringHead(_name)
	var __rv bool
	DirectQtDrv(nil, 13000, 13154, unsafe.Pointer(_name), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::isValidColor(QString const&)
func (q *QColor) IsValidColor(name string) bool {
	_name := NewCStringHead(name)
	defer FreeCStringHead(_name)
	var __rv bool
	q.Drv(13000, 13154, unsafe.Pointer(_name), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::light()
func (q *QColor) Light() *QColor {
	var __rv uintptr
	q.Drv(13000, 13155, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::light(int)
func (q *QColor) LightWithInt32(f int32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13156, unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::lighter()
func (q *QColor) Lighter() *QColor {
	var __rv uintptr
	q.Drv(13000, 13157, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::lighter(int)
func (q *QColor) LighterWithInt32(f int32) *QColor {
	var __rv uintptr
	q.Drv(13000, 13158, unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::lightness()
func (q *QColor) Lightness() int32 {
	var __rv int32
	q.Drv(13000, 13159, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::lightnessF()
func (q *QColor) LightnessF() float64 {
	var __rv float64
	q.Drv(13000, 13160, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::magenta()
func (q *QColor) Magenta() int32 {
	var __rv int32
	q.Drv(13000, 13161, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::magentaF()
func (q *QColor) MagentaF() float64 {
	var __rv float64
	q.Drv(13000, 13162, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::name()
func (q *QColor) Name() string {
	var __rv C.string_head
	q.Drv(13000, 13163, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QColor::red()
func (q *QColor) Red() int32 {
	var __rv int32
	q.Drv(13000, 13164, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::redF()
func (q *QColor) RedF() float64 {
	var __rv float64
	q.Drv(13000, 13165, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::rgb()
func (q *QColor) Rgb() uint32 {
	var __rv uint32
	q.Drv(13000, 13166, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::rgba()
func (q *QColor) Rgba() uint32 {
	var __rv uint32
	q.Drv(13000, 13167, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::saturation()
func (q *QColor) Saturation() int32 {
	var __rv int32
	q.Drv(13000, 13168, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::saturationF()
func (q *QColor) SaturationF() float64 {
	var __rv float64
	q.Drv(13000, 13169, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::setAlpha(int)
func (q *QColor) SetAlpha(alpha int32) {
	q.Drv(13000, 13170, unsafe.Pointer(&alpha), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setAlphaF(double)
func (q *QColor) SetAlphaF(alpha float64) {
	q.Drv(13000, 13171, unsafe.Pointer(&alpha), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setBlue(int)
func (q *QColor) SetBlue(blue int32) {
	q.Drv(13000, 13172, unsafe.Pointer(&blue), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setBlueF(double)
func (q *QColor) SetBlueF(blue float64) {
	q.Drv(13000, 13173, unsafe.Pointer(&blue), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setCmyk(int,int,int,int,int)
func (q *QColor) SetCmyk(c int32, m int32, y int32, k int32, a int32) {
	q.Drv(13000, 13174, unsafe.Pointer(&c), unsafe.Pointer(&m), unsafe.Pointer(&y), unsafe.Pointer(&k), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setCmykF(double,double,double,double,double)
func (q *QColor) SetCmykF(c float64, m float64, y float64, k float64, a float64) {
	q.Drv(13000, 13175, unsafe.Pointer(&c), unsafe.Pointer(&m), unsafe.Pointer(&y), unsafe.Pointer(&k), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setGreen(int)
func (q *QColor) SetGreen(green int32) {
	q.Drv(13000, 13176, unsafe.Pointer(&green), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setGreenF(double)
func (q *QColor) SetGreenF(green float64) {
	q.Drv(13000, 13177, unsafe.Pointer(&green), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setHsl(int,int,int,int)
func (q *QColor) SetHsl(h int32, s int32, l int32, a int32) {
	q.Drv(13000, 13178, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&l), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setHslF(double,double,double,double)
func (q *QColor) SetHslF(h float64, s float64, l float64, a float64) {
	q.Drv(13000, 13179, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&l), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setHsv(int,int,int,int)
func (q *QColor) SetHsv(h int32, s int32, v int32, a int32) {
	q.Drv(13000, 13180, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&v), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setHsvF(double,double,double,double)
func (q *QColor) SetHsvF(h float64, s float64, v float64, a float64) {
	q.Drv(13000, 13181, unsafe.Pointer(&h), unsafe.Pointer(&s), unsafe.Pointer(&v), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setNamedColor(QString const&)
func (q *QColor) SetNamedColor(name string) {
	_name := NewCStringHead(name)
	defer FreeCStringHead(_name)
	q.Drv(13000, 13182, unsafe.Pointer(_name), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setRed(int)
func (q *QColor) SetRed(red int32) {
	q.Drv(13000, 13183, unsafe.Pointer(&red), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setRedF(double)
func (q *QColor) SetRedF(red float64) {
	q.Drv(13000, 13184, unsafe.Pointer(&red), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setRgb(unsigned int)
func (q *QColor) SetRgb(rgb uint32) {
	q.Drv(13000, 13185, unsafe.Pointer(&rgb), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setRgb(int,int,int,int)
func (q *QColor) SetRgbWithInt32Int32Int32Int32(r int32, g int32, b int32, a int32) {
	q.Drv(13000, 13186, unsafe.Pointer(&r), unsafe.Pointer(&g), unsafe.Pointer(&b), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setRgbF(double,double,double,double)
func (q *QColor) SetRgbF(r float64, g float64, b float64, a float64) {
	q.Drv(13000, 13187, unsafe.Pointer(&r), unsafe.Pointer(&g), unsafe.Pointer(&b), unsafe.Pointer(&a), nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::setRgba(unsigned int)
func (q *QColor) SetRgba(rgba uint32) {
	q.Drv(13000, 13188, unsafe.Pointer(&rgba), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColor::spec()
func (q *QColor) Spec() QColor_Spec {
	var __rv QColor_Spec
	q.Drv(13000, 13189, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::toCmyk()
func (q *QColor) ToCmyk() *QColor {
	var __rv uintptr
	q.Drv(13000, 13190, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::toHsl()
func (q *QColor) ToHsl() *QColor {
	var __rv uintptr
	q.Drv(13000, 13191, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::toHsv()
func (q *QColor) ToHsv() *QColor {
	var __rv uintptr
	q.Drv(13000, 13192, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::toRgb()
func (q *QColor) ToRgb() *QColor {
	var __rv uintptr
	q.Drv(13000, 13193, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColor::value()
func (q *QColor) Value() int32 {
	var __rv int32
	q.Drv(13000, 13194, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::valueF()
func (q *QColor) ValueF() float64 {
	var __rv float64
	q.Drv(13000, 13195, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::yellow()
func (q *QColor) Yellow() int32 {
	var __rv int32
	q.Drv(13000, 13196, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColor::yellowF()
func (q *QColor) YellowF() float64 {
	var __rv float64
	q.Drv(13000, 13197, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//enum QColormap_Mode - QColormap::Mode
type QColormap_Mode uint32

const (
	QColormap_Direct  QColormap_Mode = 0
	QColormap_Indexed QColormap_Mode = 1
	QColormap_Gray    QColormap_Mode = 2
)

//struct QColormap : QColormap
type QColormap struct {
	BaseDrv
}

//QColormap::QColormap(QColormap const&)
func NewColormap(colormap *QColormap) *QColormap {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 14000, 14102, Native(colormap), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QColormap{}
	_p.SetDriver(__rv, 14000, true)
	return _p
}

//QColormap::cleanup()
func QColormapCleanup() {
	DirectQtDrv(nil, 14000, 14103, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColormap::cleanup()
func (q *QColormap) Cleanup() {
	q.Drv(14000, 14103, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColormap::colorAt(unsigned int)
func (q *QColormap) ColorAt(pixel uint32) *QColor {
	var __rv uintptr
	q.Drv(14000, 14104, unsafe.Pointer(&pixel), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColor{}
	_rp.SetDriver(__rv, 13000, true)
	return _rp
}

//QColormap::colormap()
func (q *QColormap) Colormap() []*QColor {
	var __rv []*QColor
	q.Drv(14000, 14105, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColormap::depth()
func (q *QColormap) Depth() int32 {
	var __rv int32
	q.Drv(14000, 14106, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColormap::initialize()
func QColormapInitialize() {
	DirectQtDrv(nil, 14000, 14107, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColormap::initialize()
func (q *QColormap) Initialize() {
	q.Drv(14000, 14107, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QColormap::instance()
func QColormapInstance() *QColormap {
	var __rv uintptr
	DirectQtDrv(nil, 14000, 14108, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColormap{}
	_rp.SetDriver(__rv, 14000, true)
	return _rp
}

//QColormap::instance()
func (q *QColormap) Instance() *QColormap {
	var __rv uintptr
	q.Drv(14000, 14108, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColormap{}
	_rp.SetDriver(__rv, 14000, true)
	return _rp
}

//QColormap::instance(int)
func QColormapInstanceWithScreen(screen int32) *QColormap {
	var __rv uintptr
	DirectQtDrv(nil, 14000, 14109, unsafe.Pointer(&screen), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColormap{}
	_rp.SetDriver(__rv, 14000, true)
	return _rp
}

//QColormap::instance(int)
func (q *QColormap) InstanceWithScreen(screen int32) *QColormap {
	var __rv uintptr
	q.Drv(14000, 14109, unsafe.Pointer(&screen), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QColormap{}
	_rp.SetDriver(__rv, 14000, true)
	return _rp
}

//QColormap::mode()
func (q *QColormap) Mode() QColormap_Mode {
	var __rv QColormap_Mode
	q.Drv(14000, 14110, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColormap::pixel(QColor const&)
func (q *QColormap) Pixel(color *QColor) uint32 {
	var __rv uint32
	q.Drv(14000, 14111, Native(color), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QColormap::size()
func (q *QColormap) Size() int32 {
	var __rv int32
	q.Drv(14000, 14112, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//struct QConicalGradient : QConicalGradient
type QConicalGradient struct {
	QGradient
}

//QConicalGradient::QConicalGradient()
func NewConicalGradient() *QConicalGradient {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 15000, 15102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QConicalGradient{}
	_p.SetDriver(__rv, 15000, true)
	return _p
}

//QConicalGradient::QConicalGradient(QPointF const&,double)
func NewConicalGradientWithCenterStartangle(center *QPointF, startAngle float64) *QConicalGradient {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 15000, 15103, Native(center), unsafe.Pointer(&startAngle), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QConicalGradient{}
	_p.SetDriver(__rv, 15000, true)
	return _p
}

//QConicalGradient::QConicalGradient(double,double,double)
func NewConicalGradientWithCxCyStartangle(cx float64, cy float64, startAngle float64) *QConicalGradient {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 15000, 15104, unsafe.Pointer(&cx), unsafe.Pointer(&cy), unsafe.Pointer(&startAngle), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QConicalGradient{}
	_p.SetDriver(__rv, 15000, true)
	return _p
}

//QConicalGradient::angle()
func (q *QConicalGradient) Angle() float64 {
	var __rv float64
	q.Drv(15000, 15105, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QConicalGradient::center()
func (q *QConicalGradient) Center() *QPointF {
	var __rv uintptr
	q.Drv(15000, 15106, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPointF{}
	_rp.SetDriver(__rv, 101000, true)
	return _rp
}

//QConicalGradient::setAngle(double)
func (q *QConicalGradient) SetAngle(angle float64) {
	q.Drv(15000, 15107, unsafe.Pointer(&angle), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QConicalGradient::setCenter(QPointF const&)
func (q *QConicalGradient) SetCenter(center *QPointF) {
	q.Drv(15000, 15108, Native(center), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QConicalGradient::setCenter(double,double)
func (q *QConicalGradient) SetCenterFWithXY(x float64, y float64) {
	q.Drv(15000, 15109, unsafe.Pointer(&x), unsafe.Pointer(&y), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//enum QContextMenuEvent_Reason - QContextMenuEvent::Reason
type QContextMenuEvent_Reason uint32

const (
	QContextMenuEvent_Mouse    QContextMenuEvent_Reason = 0
	QContextMenuEvent_Keyboard QContextMenuEvent_Reason = 1
	QContextMenuEvent_Other    QContextMenuEvent_Reason = 2
)

//struct QContextMenuEvent : QContextMenuEvent
type QContextMenuEvent struct {
	QInputEvent
}

//QContextMenuEvent::QContextMenuEvent(QContextMenuEvent::Reason,QPoint const&)
func NewContextMenuEvent(reason QContextMenuEvent_Reason, pos *QPoint) *QContextMenuEvent {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 16000, 16102, unsafe.Pointer(&reason), Native(pos), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QContextMenuEvent{}
	_p.SetDriver(__rv, 16000, true)
	return _p
}

//QContextMenuEvent::QContextMenuEvent(QContextMenuEvent::Reason,QPoint const&,QPoint const&)
func NewContextMenuEventWithReasonPosGlobalpos(reason QContextMenuEvent_Reason, pos *QPoint, globalPos *QPoint) *QContextMenuEvent {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 16000, 16103, unsafe.Pointer(&reason), Native(pos), Native(globalPos), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QContextMenuEvent{}
	_p.SetDriver(__rv, 16000, true)
	return _p
}

//QContextMenuEvent::QContextMenuEvent(QContextMenuEvent::Reason,QPoint const&,QPoint const&,QFlags<Qt::KeyboardModifier>)
func NewContextMenuEventWithReasonPosGlobalposModifiers(reason QContextMenuEvent_Reason, pos *QPoint, globalPos *QPoint, modifiers Qt_KeyboardModifier) *QContextMenuEvent {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 16000, 16104, unsafe.Pointer(&reason), Native(pos), Native(globalPos), unsafe.Pointer(&modifiers), nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QContextMenuEvent{}
	_p.SetDriver(__rv, 16000, true)
	return _p
}

//QContextMenuEvent::globalPos()
func (q *QContextMenuEvent) GlobalPos() *QPoint {
	var __rv uintptr
	q.Drv(16000, 16105, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPoint{}
	_rp.SetDriver(__rv, 100000, true)
	return _rp
}

//QContextMenuEvent::globalX()
func (q *QContextMenuEvent) GlobalX() int32 {
	var __rv int32
	q.Drv(16000, 16106, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QContextMenuEvent::globalY()
func (q *QContextMenuEvent) GlobalY() int32 {
	var __rv int32
	q.Drv(16000, 16107, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QContextMenuEvent::pos()
func (q *QContextMenuEvent) Pos() *QPoint {
	var __rv uintptr
	q.Drv(16000, 16108, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPoint{}
	_rp.SetDriver(__rv, 100000, true)
	return _rp
}

//QContextMenuEvent::reason()
func (q *QContextMenuEvent) Reason() QContextMenuEvent_Reason {
	var __rv QContextMenuEvent_Reason
	q.Drv(16000, 16109, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QContextMenuEvent::x()
func (q *QContextMenuEvent) X() int32 {
	var __rv int32
	q.Drv(16000, 16110, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QContextMenuEvent::y()
func (q *QContextMenuEvent) Y() int32 {
	var __rv int32
	q.Drv(16000, 16111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//enum QCryptographicHash_Algorithm - QCryptographicHash::Algorithm
type QCryptographicHash_Algorithm uint32

const (
	QCryptographicHash_Md4  QCryptographicHash_Algorithm = 0
	QCryptographicHash_Md5  QCryptographicHash_Algorithm = 1
	QCryptographicHash_Sha1 QCryptographicHash_Algorithm = 2
)

//struct QCryptographicHash : QCryptographicHash
type QCryptographicHash struct {
	BaseDrv
}

//QCryptographicHash::QCryptographicHash(QCryptographicHash::Algorithm)
func NewCryptographicHash(method QCryptographicHash_Algorithm) *QCryptographicHash {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 17000, 17102, unsafe.Pointer(&method), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QCryptographicHash{}
	_p.SetDriver(__rv, 17000, true)
	return _p
}

//QCryptographicHash::addData(QByteArray const&)
func (q *QCryptographicHash) AddData(data []byte) {
	_data := NewCByteArrayHead(data)
	defer FreeCByteArrayHead(_data)
	q.Drv(17000, 17103, unsafe.Pointer(_data), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCryptographicHash::hash(QByteArray const&,QCryptographicHash::Algorithm)
func QCryptographicHashHash(data []byte, method QCryptographicHash_Algorithm) []byte {
	_data := NewCByteArrayHead(data)
	defer FreeCByteArrayHead(_data)
	var __rv []byte
	DirectQtDrv(nil, 17000, 17104, unsafe.Pointer(_data), unsafe.Pointer(&method), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCryptographicHash::hash(QByteArray const&,QCryptographicHash::Algorithm)
func (q *QCryptographicHash) Hash(data []byte, method QCryptographicHash_Algorithm) []byte {
	_data := NewCByteArrayHead(data)
	defer FreeCByteArrayHead(_data)
	var __rv []byte
	q.Drv(17000, 17104, unsafe.Pointer(_data), unsafe.Pointer(&method), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QCryptographicHash::reset()
func (q *QCryptographicHash) Reset() {
	q.Drv(17000, 17105, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCryptographicHash::result()
func (q *QCryptographicHash) Result() []byte {
	var __rv []byte
	q.Drv(17000, 17106, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//struct QCursor : QCursor
type QCursor struct {
	BaseDrv
}

//QCursor::QCursor()
func NewCursor() *QCursor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 18000, 18102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QCursor{}
	_p.SetDriver(__rv, 18000, true)
	return _p
}

//QCursor::QCursor(QCursor const&)
func NewCursorCopy(cursor *QCursor) *QCursor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 18000, 18103, Native(cursor), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QCursor{}
	_p.SetDriver(__rv, 18000, true)
	return _p
}

//QCursor::QCursor(Qt::CursorShape)
func NewCursorWithShape(shape Qt_CursorShape) *QCursor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 18000, 18104, unsafe.Pointer(&shape), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QCursor{}
	_p.SetDriver(__rv, 18000, true)
	return _p
}

//QCursor::QCursor(QPixmap const&,int,int)
func NewCursorWithPixmapHotxHoty(pixmap *QPixmap, hotX int32, hotY int32) *QCursor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 18000, 18105, Native(pixmap), unsafe.Pointer(&hotX), unsafe.Pointer(&hotY), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QCursor{}
	_p.SetDriver(__rv, 18000, true)
	return _p
}

//QCursor::QCursor(QBitmap const&,QBitmap const&,int,int)
func NewCursorWithBitmapMaskHotxHoty(bitmap *QBitmap, mask *QBitmap, hotX int32, hotY int32) *QCursor {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 18000, 18106, Native(bitmap), Native(mask), unsafe.Pointer(&hotX), unsafe.Pointer(&hotY), nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QCursor{}
	_p.SetDriver(__rv, 18000, true)
	return _p
}

//QCursor::bitmap()
func (q *QCursor) Bitmap() *QBitmap {
	var __rv uintptr
	q.Drv(18000, 18107, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//QCursor::hotSpot()
func (q *QCursor) HotSpot() *QPoint {
	var __rv uintptr
	q.Drv(18000, 18108, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPoint{}
	_rp.SetDriver(__rv, 100000, true)
	return _rp
}

//QCursor::mask()
func (q *QCursor) Mask() *QBitmap {
	var __rv uintptr
	q.Drv(18000, 18109, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QBitmap{}
	_rp.SetDriver(__rv, 8000, true)
	return _rp
}

//QCursor::pixmap()
func (q *QCursor) Pixmap() *QPixmap {
	var __rv uintptr
	q.Drv(18000, 18110, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPixmap{}
	_rp.SetDriver(__rv, 97000, true)
	return _rp
}

//QCursor::pos()
func QCursorPos() *QPoint {
	var __rv uintptr
	DirectQtDrv(nil, 18000, 18111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPoint{}
	_rp.SetDriver(__rv, 100000, true)
	return _rp
}

//QCursor::pos()
func (q *QCursor) Pos() *QPoint {
	var __rv uintptr
	q.Drv(18000, 18111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPoint{}
	_rp.SetDriver(__rv, 100000, true)
	return _rp
}

//QCursor::setPos(QPoint const&)
func QCursorSetPos(p *QPoint) {
	DirectQtDrv(nil, 18000, 18112, Native(p), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCursor::setPos(QPoint const&)
func (q *QCursor) SetPos(p *QPoint) {
	q.Drv(18000, 18112, Native(p), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCursor::setPos(int,int)
func QCursorSetPosWithXY(x int32, y int32) {
	DirectQtDrv(nil, 18000, 18113, unsafe.Pointer(&x), unsafe.Pointer(&y), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCursor::setPos(int,int)
func (q *QCursor) SetPosWithXY(x int32, y int32) {
	q.Drv(18000, 18113, unsafe.Pointer(&x), unsafe.Pointer(&y), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCursor::setShape(Qt::CursorShape)
func (q *QCursor) SetShape(newShape Qt_CursorShape) {
	q.Drv(18000, 18114, unsafe.Pointer(&newShape), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QCursor::shape()
func (q *QCursor) Shape() Qt_CursorShape {
	var __rv Qt_CursorShape
	q.Drv(18000, 18115, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//enum QDate_MonthNameType - QDate::MonthNameType
type QDate_MonthNameType uint32

const (
	QDate_DateFormat       QDate_MonthNameType = 0
	QDate_StandaloneFormat QDate_MonthNameType = 0
)

//struct QDate : QDate
type QDate struct {
	BaseDrv
}

//QDate::QDate()
func NewDate() *QDate {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 19000, 19102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDate{}
	_p.SetDriver(__rv, 19000, true)
	return _p
}

//QDate::QDate(QDate const&)
func NewDateCopy(other *QDate) *QDate {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 19000, 19103, Native(other), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDate{}
	_p.SetDriver(__rv, 19000, true)
	return _p
}

//QDate::QDate(int,int,int)
func NewDateWithYInt32Int32(y int32, m int32, d int32) *QDate {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 19000, 19104, unsafe.Pointer(&y), unsafe.Pointer(&m), unsafe.Pointer(&d), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDate{}
	_p.SetDriver(__rv, 19000, true)
	return _p
}

//QDate::addDays(int)
func (q *QDate) AddDays(days int32) *QDate {
	var __rv uintptr
	q.Drv(19000, 19105, unsafe.Pointer(&days), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::addMonths(int)
func (q *QDate) AddMonths(months int32) *QDate {
	var __rv uintptr
	q.Drv(19000, 19106, unsafe.Pointer(&months), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::addYears(int)
func (q *QDate) AddYears(years int32) *QDate {
	var __rv uintptr
	q.Drv(19000, 19107, unsafe.Pointer(&years), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::currentDate()
func QDateCurrentDate() *QDate {
	var __rv uintptr
	DirectQtDrv(nil, 19000, 19108, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::currentDate()
func (q *QDate) CurrentDate() *QDate {
	var __rv uintptr
	q.Drv(19000, 19108, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::day()
func (q *QDate) Day() int32 {
	var __rv int32
	q.Drv(19000, 19109, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::dayOfWeek()
func (q *QDate) DayOfWeek() int32 {
	var __rv int32
	q.Drv(19000, 19110, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::dayOfYear()
func (q *QDate) DayOfYear() int32 {
	var __rv int32
	q.Drv(19000, 19111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::daysInMonth()
func (q *QDate) DaysInMonth() int32 {
	var __rv int32
	q.Drv(19000, 19112, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::daysInYear()
func (q *QDate) DaysInYear() int32 {
	var __rv int32
	q.Drv(19000, 19113, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::daysTo(QDate const&)
func (q *QDate) DaysTo(value *QDate) int32 {
	var __rv int32
	q.Drv(19000, 19114, Native(value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::fromJulianDay(int)
func QDateFromJulianDay(jd int32) *QDate {
	var __rv uintptr
	DirectQtDrv(nil, 19000, 19115, unsafe.Pointer(&jd), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::fromJulianDay(int)
func (q *QDate) FromJulianDay(jd int32) *QDate {
	var __rv uintptr
	q.Drv(19000, 19115, unsafe.Pointer(&jd), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::fromString(QString const&)
func QDateFromString(s string) *QDate {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	var __rv uintptr
	DirectQtDrv(nil, 19000, 19116, unsafe.Pointer(_s), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::fromString(QString const&)
func (q *QDate) FromString(s string) *QDate {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	var __rv uintptr
	q.Drv(19000, 19116, unsafe.Pointer(_s), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::fromString(QString const&,QString const&)
func QDateFromStringWithTextFormat(s string, format string) *QDate {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	_format := NewCStringHead(format)
	defer FreeCStringHead(_format)
	var __rv uintptr
	DirectQtDrv(nil, 19000, 19117, unsafe.Pointer(_s), unsafe.Pointer(_format), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::fromString(QString const&,QString const&)
func (q *QDate) FromStringWithTextFormat(s string, format string) *QDate {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	_format := NewCStringHead(format)
	defer FreeCStringHead(_format)
	var __rv uintptr
	q.Drv(19000, 19117, unsafe.Pointer(_s), unsafe.Pointer(_format), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::fromString(QString const&,Qt::DateFormat)
func QDateFromStringWithTextDateformat(s string, f Qt_DateFormat) *QDate {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	var __rv uintptr
	DirectQtDrv(nil, 19000, 19118, unsafe.Pointer(_s), unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::fromString(QString const&,Qt::DateFormat)
func (q *QDate) FromStringWithTextDateformat(s string, f Qt_DateFormat) *QDate {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	var __rv uintptr
	q.Drv(19000, 19118, unsafe.Pointer(_s), unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDate::getDate(int*,int*,int*)
func (q *QDate) GetDate(year *int32, month *int32, day *int32) {
	q.Drv(19000, 19119, unsafe.Pointer(&year), unsafe.Pointer(&month), unsafe.Pointer(&day), nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDate::isLeapYear(int)
func QDateIsLeapYear(year int32) bool {
	var __rv bool
	DirectQtDrv(nil, 19000, 19120, unsafe.Pointer(&year), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::isLeapYear(int)
func (q *QDate) IsLeapYear(year int32) bool {
	var __rv bool
	q.Drv(19000, 19120, unsafe.Pointer(&year), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::isNull()
func (q *QDate) IsNull() bool {
	var __rv bool
	q.Drv(19000, 19121, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::isValid()
func (q *QDate) IsValid() bool {
	var __rv bool
	q.Drv(19000, 19122, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::isValid(int,int,int)
func QDateIsValidWithYInt32Int32(y int32, m int32, d int32) bool {
	var __rv bool
	DirectQtDrv(nil, 19000, 19123, unsafe.Pointer(&y), unsafe.Pointer(&m), unsafe.Pointer(&d), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::isValid(int,int,int)
func (q *QDate) IsValidWithYInt32Int32(y int32, m int32, d int32) bool {
	var __rv bool
	q.Drv(19000, 19123, unsafe.Pointer(&y), unsafe.Pointer(&m), unsafe.Pointer(&d), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::longDayName(int)
func QDateLongDayName(weekday int32) string {
	var __rv C.string_head
	DirectQtDrv(nil, 19000, 19124, unsafe.Pointer(&weekday), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::longDayName(int)
func (q *QDate) LongDayName(weekday int32) string {
	var __rv C.string_head
	q.Drv(19000, 19124, unsafe.Pointer(&weekday), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::longDayName(int,QDate::MonthNameType)
func QDateLongDayNameWithWeekdayType(weekday int32, _type QDate_MonthNameType) string {
	var __rv C.string_head
	DirectQtDrv(nil, 19000, 19125, unsafe.Pointer(&weekday), unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::longDayName(int,QDate::MonthNameType)
func (q *QDate) LongDayNameWithWeekdayType(weekday int32, _type QDate_MonthNameType) string {
	var __rv C.string_head
	q.Drv(19000, 19125, unsafe.Pointer(&weekday), unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::longMonthName(int)
func QDateLongMonthName(month int32) string {
	var __rv C.string_head
	DirectQtDrv(nil, 19000, 19126, unsafe.Pointer(&month), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::longMonthName(int)
func (q *QDate) LongMonthName(month int32) string {
	var __rv C.string_head
	q.Drv(19000, 19126, unsafe.Pointer(&month), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::longMonthName(int,QDate::MonthNameType)
func QDateLongMonthNameWithMonthType(month int32, _type QDate_MonthNameType) string {
	var __rv C.string_head
	DirectQtDrv(nil, 19000, 19127, unsafe.Pointer(&month), unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::longMonthName(int,QDate::MonthNameType)
func (q *QDate) LongMonthNameWithMonthType(month int32, _type QDate_MonthNameType) string {
	var __rv C.string_head
	q.Drv(19000, 19127, unsafe.Pointer(&month), unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::month()
func (q *QDate) Month() int32 {
	var __rv int32
	q.Drv(19000, 19128, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::setDate(int,int,int)
func (q *QDate) SetDate(year int32, month int32, day int32) bool {
	var __rv bool
	q.Drv(19000, 19129, unsafe.Pointer(&year), unsafe.Pointer(&month), unsafe.Pointer(&day), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::shortDayName(int)
func QDateShortDayName(weekday int32) string {
	var __rv C.string_head
	DirectQtDrv(nil, 19000, 19130, unsafe.Pointer(&weekday), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::shortDayName(int)
func (q *QDate) ShortDayName(weekday int32) string {
	var __rv C.string_head
	q.Drv(19000, 19130, unsafe.Pointer(&weekday), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::shortDayName(int,QDate::MonthNameType)
func QDateShortDayNameWithWeekdayType(weekday int32, _type QDate_MonthNameType) string {
	var __rv C.string_head
	DirectQtDrv(nil, 19000, 19131, unsafe.Pointer(&weekday), unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::shortDayName(int,QDate::MonthNameType)
func (q *QDate) ShortDayNameWithWeekdayType(weekday int32, _type QDate_MonthNameType) string {
	var __rv C.string_head
	q.Drv(19000, 19131, unsafe.Pointer(&weekday), unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::shortMonthName(int)
func QDateShortMonthName(month int32) string {
	var __rv C.string_head
	DirectQtDrv(nil, 19000, 19132, unsafe.Pointer(&month), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::shortMonthName(int)
func (q *QDate) ShortMonthName(month int32) string {
	var __rv C.string_head
	q.Drv(19000, 19132, unsafe.Pointer(&month), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::shortMonthName(int,QDate::MonthNameType)
func QDateShortMonthNameWithMonthType(month int32, _type QDate_MonthNameType) string {
	var __rv C.string_head
	DirectQtDrv(nil, 19000, 19133, unsafe.Pointer(&month), unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::shortMonthName(int,QDate::MonthNameType)
func (q *QDate) ShortMonthNameWithMonthType(month int32, _type QDate_MonthNameType) string {
	var __rv C.string_head
	q.Drv(19000, 19133, unsafe.Pointer(&month), unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::toJulianDay()
func (q *QDate) ToJulianDay() int32 {
	var __rv int32
	q.Drv(19000, 19134, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::toString()
func (q *QDate) ToString() string {
	var __rv C.string_head
	q.Drv(19000, 19135, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::toString(QString const&)
func (q *QDate) ToStringWithFormat(format string) string {
	_format := NewCStringHead(format)
	defer FreeCStringHead(_format)
	var __rv C.string_head
	q.Drv(19000, 19136, unsafe.Pointer(_format), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::toString(Qt::DateFormat)
func (q *QDate) ToStringWithDateformat(f Qt_DateFormat) string {
	var __rv C.string_head
	q.Drv(19000, 19137, unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDate::weekNumber()
func (q *QDate) WeekNumber() int32 {
	var __rv int32
	q.Drv(19000, 19138, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::weekNumber(int*)
func (q *QDate) WeekNumberWithYearnum(yearNum *int32) int32 {
	var __rv int32
	q.Drv(19000, 19139, unsafe.Pointer(&yearNum), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDate::year()
func (q *QDate) Year() int32 {
	var __rv int32
	q.Drv(19000, 19140, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//struct QDateTime : QDateTime
type QDateTime struct {
	BaseDrv
}

//QDateTime::QDateTime()
func NewDateTime() *QDateTime {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 20000, 20102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDateTime{}
	_p.SetDriver(__rv, 20000, true)
	return _p
}

//QDateTime::QDateTime(QDate const&)
func NewDateTimeWithDate(value *QDate) *QDateTime {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 20000, 20103, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDateTime{}
	_p.SetDriver(__rv, 20000, true)
	return _p
}

//QDateTime::QDateTime(QDateTime const&)
func NewDateTimeCopy(other *QDateTime) *QDateTime {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 20000, 20104, Native(other), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDateTime{}
	_p.SetDriver(__rv, 20000, true)
	return _p
}

//QDateTime::QDateTime(QDate const&,QTime const&,Qt::TimeSpec)
func NewDateTimeWithDateTimeSpec(value2 *QDate, value3 *QTime, spec Qt_TimeSpec) *QDateTime {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 20000, 20105, Native(value2), Native(value3), unsafe.Pointer(&spec), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDateTime{}
	_p.SetDriver(__rv, 20000, true)
	return _p
}

//QDateTime::addDays(int)
func (q *QDateTime) AddDays(days int32) *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20106, unsafe.Pointer(&days), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::addMSecs(qint64)
func (q *QDateTime) AddMSecs(msecs int64) *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20107, unsafe.Pointer(&msecs), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::addMonths(int)
func (q *QDateTime) AddMonths(months int32) *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20108, unsafe.Pointer(&months), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::addSecs(int)
func (q *QDateTime) AddSecs(secs int32) *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20109, unsafe.Pointer(&secs), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::addYears(int)
func (q *QDateTime) AddYears(years int32) *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20110, unsafe.Pointer(&years), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::currentDateTime()
func QDateTimeCurrentDateTime() *QDateTime {
	var __rv uintptr
	DirectQtDrv(nil, 20000, 20111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::currentDateTime()
func (q *QDateTime) CurrentDateTime() *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::currentDateTimeUtc()
func QDateTimeCurrentDateTimeUtc() *QDateTime {
	var __rv uintptr
	DirectQtDrv(nil, 20000, 20112, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::currentDateTimeUtc()
func (q *QDateTime) CurrentDateTimeUtc() *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20112, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::currentMSecsSinceEpoch()
func QDateTimeCurrentMSecsSinceEpoch() int64 {
	var __rv int64
	DirectQtDrv(nil, 20000, 20113, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::currentMSecsSinceEpoch()
func (q *QDateTime) CurrentMSecsSinceEpoch() int64 {
	var __rv int64
	q.Drv(20000, 20113, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::date()
func (q *QDateTime) Date() *QDate {
	var __rv uintptr
	q.Drv(20000, 20114, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDate{}
	_rp.SetDriver(__rv, 19000, true)
	return _rp
}

//QDateTime::daysTo(QDateTime const&)
func (q *QDateTime) DaysTo(value *QDateTime) int32 {
	var __rv int32
	q.Drv(20000, 20115, Native(value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::fromMSecsSinceEpoch(qint64)
func QDateTimeFromMSecsSinceEpoch(msecs int64) *QDateTime {
	var __rv uintptr
	DirectQtDrv(nil, 20000, 20116, unsafe.Pointer(&msecs), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::fromMSecsSinceEpoch(qint64)
func (q *QDateTime) FromMSecsSinceEpoch(msecs int64) *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20116, unsafe.Pointer(&msecs), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::fromString(QString const&)
func QDateTimeFromString(s string) *QDateTime {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	var __rv uintptr
	DirectQtDrv(nil, 20000, 20117, unsafe.Pointer(_s), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::fromString(QString const&)
func (q *QDateTime) FromString(s string) *QDateTime {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	var __rv uintptr
	q.Drv(20000, 20117, unsafe.Pointer(_s), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::fromString(QString const&,QString const&)
func QDateTimeFromStringWithTextFormat(s string, format string) *QDateTime {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	_format := NewCStringHead(format)
	defer FreeCStringHead(_format)
	var __rv uintptr
	DirectQtDrv(nil, 20000, 20118, unsafe.Pointer(_s), unsafe.Pointer(_format), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::fromString(QString const&,QString const&)
func (q *QDateTime) FromStringWithTextFormat(s string, format string) *QDateTime {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	_format := NewCStringHead(format)
	defer FreeCStringHead(_format)
	var __rv uintptr
	q.Drv(20000, 20118, unsafe.Pointer(_s), unsafe.Pointer(_format), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::fromString(QString const&,Qt::DateFormat)
func QDateTimeFromStringWithTextDateformat(s string, f Qt_DateFormat) *QDateTime {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	var __rv uintptr
	DirectQtDrv(nil, 20000, 20119, unsafe.Pointer(_s), unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::fromString(QString const&,Qt::DateFormat)
func (q *QDateTime) FromStringWithTextDateformat(s string, f Qt_DateFormat) *QDateTime {
	_s := NewCStringHead(s)
	defer FreeCStringHead(_s)
	var __rv uintptr
	q.Drv(20000, 20119, unsafe.Pointer(_s), unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::fromTime_t(unsigned int)
func QDateTimeFromTime_t(secsSince1Jan1970UTC uint32) *QDateTime {
	var __rv uintptr
	DirectQtDrv(nil, 20000, 20120, unsafe.Pointer(&secsSince1Jan1970UTC), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::fromTime_t(unsigned int)
func (q *QDateTime) FromTime_t(secsSince1Jan1970UTC uint32) *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20120, unsafe.Pointer(&secsSince1Jan1970UTC), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::isNull()
func (q *QDateTime) IsNull() bool {
	var __rv bool
	q.Drv(20000, 20121, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::isValid()
func (q *QDateTime) IsValid() bool {
	var __rv bool
	q.Drv(20000, 20122, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::msecsTo(QDateTime const&)
func (q *QDateTime) MsecsTo(value *QDateTime) int64 {
	var __rv int64
	q.Drv(20000, 20123, Native(value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::secsTo(QDateTime const&)
func (q *QDateTime) SecsTo(value *QDateTime) int32 {
	var __rv int32
	q.Drv(20000, 20124, Native(value), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::setDate(QDate const&)
func (q *QDateTime) SetDate(date *QDate) {
	q.Drv(20000, 20125, Native(date), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDateTime::setMSecsSinceEpoch(qint64)
func (q *QDateTime) SetMSecsSinceEpoch(msecs int64) {
	q.Drv(20000, 20126, unsafe.Pointer(&msecs), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDateTime::setTime(QTime const&)
func (q *QDateTime) SetTime(time *QTime) {
	q.Drv(20000, 20127, Native(time), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDateTime::setTimeSpec(Qt::TimeSpec)
func (q *QDateTime) SetTimeSpec(spec Qt_TimeSpec) {
	q.Drv(20000, 20128, unsafe.Pointer(&spec), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDateTime::setTime_t(unsigned int)
func (q *QDateTime) SetTime_t(secsSince1Jan1970UTC uint32) {
	q.Drv(20000, 20129, unsafe.Pointer(&secsSince1Jan1970UTC), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDateTime::setUtcOffset(int)
func (q *QDateTime) SetUtcOffset(seconds int32) {
	q.Drv(20000, 20130, unsafe.Pointer(&seconds), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDateTime::time()
func (q *QDateTime) Time() *QTime {
	var __rv uintptr
	q.Drv(20000, 20131, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QTime{}
	_rp.SetDriver(__rv, 172000, true)
	return _rp
}

//QDateTime::timeSpec()
func (q *QDateTime) TimeSpec() Qt_TimeSpec {
	var __rv Qt_TimeSpec
	q.Drv(20000, 20132, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::toLocalTime()
func (q *QDateTime) ToLocalTime() *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20133, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::toMSecsSinceEpoch()
func (q *QDateTime) ToMSecsSinceEpoch() int64 {
	var __rv int64
	q.Drv(20000, 20134, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::toString()
func (q *QDateTime) ToString() string {
	var __rv C.string_head
	q.Drv(20000, 20135, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDateTime::toString(QString const&)
func (q *QDateTime) ToStringWithFormat(format string) string {
	_format := NewCStringHead(format)
	defer FreeCStringHead(_format)
	var __rv C.string_head
	q.Drv(20000, 20136, unsafe.Pointer(_format), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDateTime::toString(Qt::DateFormat)
func (q *QDateTime) ToStringWithDateformat(f Qt_DateFormat) string {
	var __rv C.string_head
	q.Drv(20000, 20137, unsafe.Pointer(&f), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDateTime::toTimeSpec(Qt::TimeSpec)
func (q *QDateTime) ToTimeSpec(spec Qt_TimeSpec) *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20138, unsafe.Pointer(&spec), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::toTime_t()
func (q *QDateTime) ToTime_t() uint32 {
	var __rv uint32
	q.Drv(20000, 20139, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDateTime::toUTC()
func (q *QDateTime) ToUTC() *QDateTime {
	var __rv uintptr
	q.Drv(20000, 20140, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDateTime{}
	_rp.SetDriver(__rv, 20000, true)
	return _rp
}

//QDateTime::utcOffset()
func (q *QDateTime) UtcOffset() int32 {
	var __rv int32
	q.Drv(20000, 20141, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//enum QDesktopServices_StandardLocation - QDesktopServices::StandardLocation
type QDesktopServices_StandardLocation uint32

const (
	QDesktopServices_DesktopLocation      QDesktopServices_StandardLocation = 0
	QDesktopServices_DocumentsLocation    QDesktopServices_StandardLocation = 1
	QDesktopServices_FontsLocation        QDesktopServices_StandardLocation = 2
	QDesktopServices_ApplicationsLocation QDesktopServices_StandardLocation = 3
	QDesktopServices_MusicLocation        QDesktopServices_StandardLocation = 4
	QDesktopServices_MoviesLocation       QDesktopServices_StandardLocation = 5
	QDesktopServices_PicturesLocation     QDesktopServices_StandardLocation = 6
	QDesktopServices_TempLocation         QDesktopServices_StandardLocation = 7
	QDesktopServices_HomeLocation         QDesktopServices_StandardLocation = 8
	QDesktopServices_DataLocation         QDesktopServices_StandardLocation = 9
	QDesktopServices_CacheLocation        QDesktopServices_StandardLocation = 10
)

//struct QDesktopServices : QDesktopServices
type QDesktopServices struct {
	BaseDrv
}

//QDesktopServices::QDesktopServices()
func NewDesktopServices() *QDesktopServices {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 21000, 21102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDesktopServices{}
	_p.SetDriver(__rv, 21000, true)
	return _p
}

//QDesktopServices::displayName(QDesktopServices::StandardLocation)
func QDesktopServicesDisplayName(_type QDesktopServices_StandardLocation) string {
	var __rv C.string_head
	DirectQtDrv(nil, 21000, 21103, unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDesktopServices::displayName(QDesktopServices::StandardLocation)
func (q *QDesktopServices) DisplayName(_type QDesktopServices_StandardLocation) string {
	var __rv C.string_head
	q.Drv(21000, 21103, unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDesktopServices::openUrl(QUrl const&)
func QDesktopServicesOpenUrl(url *QUrl) bool {
	var __rv bool
	DirectQtDrv(nil, 21000, 21104, Native(url), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDesktopServices::openUrl(QUrl const&)
func (q *QDesktopServices) OpenUrl(url *QUrl) bool {
	var __rv bool
	q.Drv(21000, 21104, Native(url), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDesktopServices::setUrlHandler(QString const&,QObject*,char const*)
func QDesktopServicesSetUrlHandler(scheme string, receiver QObjectInterface, method string) {
	_scheme := NewCStringHead(scheme)
	defer FreeCStringHead(_scheme)
	_method := NewCStringHead(method)
	defer FreeCStringHead(_method)
	DirectQtDrv(nil, 21000, 21105, unsafe.Pointer(_scheme), Native(receiver), unsafe.Pointer(_method), nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDesktopServices::setUrlHandler(QString const&,QObject*,char const*)
func (q *QDesktopServices) SetUrlHandler(scheme string, receiver QObjectInterface, method string) {
	_scheme := NewCStringHead(scheme)
	defer FreeCStringHead(_scheme)
	_method := NewCStringHead(method)
	defer FreeCStringHead(_method)
	q.Drv(21000, 21105, unsafe.Pointer(_scheme), Native(receiver), unsafe.Pointer(_method), nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDesktopServices::storageLocation(QDesktopServices::StandardLocation)
func QDesktopServicesStorageLocation(_type QDesktopServices_StandardLocation) string {
	var __rv C.string_head
	DirectQtDrv(nil, 21000, 21106, unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDesktopServices::storageLocation(QDesktopServices::StandardLocation)
func (q *QDesktopServices) StorageLocation(_type QDesktopServices_StandardLocation) string {
	var __rv C.string_head
	q.Drv(21000, 21106, unsafe.Pointer(&_type), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDesktopServices::unsetUrlHandler(QString const&)
func QDesktopServicesUnsetUrlHandler(scheme string) {
	_scheme := NewCStringHead(scheme)
	defer FreeCStringHead(_scheme)
	DirectQtDrv(nil, 21000, 21107, unsafe.Pointer(_scheme), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDesktopServices::unsetUrlHandler(QString const&)
func (q *QDesktopServices) UnsetUrlHandler(scheme string) {
	_scheme := NewCStringHead(scheme)
	defer FreeCStringHead(_scheme)
	q.Drv(21000, 21107, unsafe.Pointer(_scheme), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//enum QDir_Filter - QDir::Filter
type QDir_Filter int32

const (
	QDir_Dirs           QDir_Filter = 0x001
	QDir_Files          QDir_Filter = 0x002
	QDir_Drives         QDir_Filter = 0x004
	QDir_NoSymLinks     QDir_Filter = 0x008
	QDir_AllEntries     QDir_Filter = QDir_Dirs | QDir_Files | QDir_Drives
	QDir_TypeMask       QDir_Filter = 0x00f
	QDir_Readable       QDir_Filter = 0x010
	QDir_Writable       QDir_Filter = 0x020
	QDir_Executable     QDir_Filter = 0x040
	QDir_PermissionMask QDir_Filter = 0x070
	QDir_Modified       QDir_Filter = 0x080
	QDir_Hidden         QDir_Filter = 0x100
	QDir_System         QDir_Filter = 0x200
	QDir_AccessMask     QDir_Filter = 0x3F0
	QDir_AllDirs        QDir_Filter = 0x400
	QDir_CaseSensitive  QDir_Filter = 0x800
	QDir_NoDotAndDotDot QDir_Filter = 0x1000
	QDir_NoDot          QDir_Filter = 0x2000
	QDir_NoDotDot       QDir_Filter = 0x4000
	QDir_NoFilter       QDir_Filter = -1
)

//enum QDir_SortFlag - QDir::SortFlag
type QDir_SortFlag int32

const (
	QDir_Name        QDir_SortFlag = 0x00
	QDir_Time        QDir_SortFlag = 0x01
	QDir_Size        QDir_SortFlag = 0x02
	QDir_Unsorted    QDir_SortFlag = 0x03
	QDir_SortByMask  QDir_SortFlag = 0x03
	QDir_DirsFirst   QDir_SortFlag = 0x04
	QDir_Reversed    QDir_SortFlag = 0x08
	QDir_IgnoreCase  QDir_SortFlag = 0x10
	QDir_DirsLast    QDir_SortFlag = 0x20
	QDir_LocaleAware QDir_SortFlag = 0x40
	QDir_Type        QDir_SortFlag = 0x80
	QDir_NoSort      QDir_SortFlag = -1
)

//struct QDir : QDir
type QDir struct {
	BaseDrv
}

//QDir::QDir()
func NewDir() *QDir {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 22000, 22102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDir{}
	_p.SetDriver(__rv, 22000, true)
	return _p
}

//QDir::QDir(QDir const&)
func NewDirCopy(value *QDir) *QDir {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 22000, 22103, Native(value), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDir{}
	_p.SetDriver(__rv, 22000, true)
	return _p
}

//QDir::QDir(QString const&)
func NewDirWithPath(path string) *QDir {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 22000, 22104, unsafe.Pointer(_path), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDir{}
	_p.SetDriver(__rv, 22000, true)
	return _p
}

//QDir::QDir(QString const&,QString const&,QFlags<QDir::SortFlag>,QFlags<QDir::Filter>)
func NewDirWithPathNamefilterSortFilter(path string, nameFilter string, sort QDir_SortFlag, filter QDir_Filter) *QDir {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	_nameFilter := NewCStringHead(nameFilter)
	defer FreeCStringHead(_nameFilter)
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 22000, 22105, unsafe.Pointer(_path), unsafe.Pointer(_nameFilter), unsafe.Pointer(&sort), unsafe.Pointer(&filter), nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDir{}
	_p.SetDriver(__rv, 22000, true)
	return _p
}

//QDir::absoluteFilePath(QString const&)
func (q *QDir) AbsoluteFilePath(fileName string) string {
	_fileName := NewCStringHead(fileName)
	defer FreeCStringHead(_fileName)
	var __rv C.string_head
	q.Drv(22000, 22106, unsafe.Pointer(_fileName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::absolutePath()
func (q *QDir) AbsolutePath() string {
	var __rv C.string_head
	q.Drv(22000, 22107, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::addResourceSearchPath(QString const&)
func QDirAddResourceSearchPath(path string) {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	DirectQtDrv(nil, 22000, 22108, unsafe.Pointer(_path), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::addResourceSearchPath(QString const&)
func (q *QDir) AddResourceSearchPath(path string) {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	q.Drv(22000, 22108, unsafe.Pointer(_path), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::addSearchPath(QString const&,QString const&)
func QDirAddSearchPath(prefix string, path string) {
	_prefix := NewCStringHead(prefix)
	defer FreeCStringHead(_prefix)
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	DirectQtDrv(nil, 22000, 22109, unsafe.Pointer(_prefix), unsafe.Pointer(_path), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::addSearchPath(QString const&,QString const&)
func (q *QDir) AddSearchPath(prefix string, path string) {
	_prefix := NewCStringHead(prefix)
	defer FreeCStringHead(_prefix)
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	q.Drv(22000, 22109, unsafe.Pointer(_prefix), unsafe.Pointer(_path), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::canonicalPath()
func (q *QDir) CanonicalPath() string {
	var __rv C.string_head
	q.Drv(22000, 22110, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::cd(QString const&)
func (q *QDir) Cd(dirName string) bool {
	_dirName := NewCStringHead(dirName)
	defer FreeCStringHead(_dirName)
	var __rv bool
	q.Drv(22000, 22111, unsafe.Pointer(_dirName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::cdUp()
func (q *QDir) CdUp() bool {
	var __rv bool
	q.Drv(22000, 22112, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::cleanPath(QString const&)
func QDirCleanPath(path string) string {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv C.string_head
	DirectQtDrv(nil, 22000, 22113, unsafe.Pointer(_path), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::cleanPath(QString const&)
func (q *QDir) CleanPath(path string) string {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv C.string_head
	q.Drv(22000, 22113, unsafe.Pointer(_path), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::count()
func (q *QDir) Count() uint32 {
	var __rv uint32
	q.Drv(22000, 22114, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::current()
func QDirCurrent() *QDir {
	var __rv uintptr
	DirectQtDrv(nil, 22000, 22115, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDir{}
	_rp.SetDriver(__rv, 22000, true)
	return _rp
}

//QDir::current()
func (q *QDir) Current() *QDir {
	var __rv uintptr
	q.Drv(22000, 22115, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDir{}
	_rp.SetDriver(__rv, 22000, true)
	return _rp
}

//QDir::currentPath()
func QDirCurrentPath() string {
	var __rv C.string_head
	DirectQtDrv(nil, 22000, 22116, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::currentPath()
func (q *QDir) CurrentPath() string {
	var __rv C.string_head
	q.Drv(22000, 22116, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::dirName()
func (q *QDir) DirName() string {
	var __rv C.string_head
	q.Drv(22000, 22117, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::drives()
func QDirDrives() []*QFileInfo {
	var __rv []*QFileInfo
	DirectQtDrv(nil, 22000, 22118, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::drives()
func (q *QDir) Drives() []*QFileInfo {
	var __rv []*QFileInfo
	q.Drv(22000, 22118, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::entryInfoList()
func (q *QDir) EntryInfoList() []*QFileInfo {
	var __rv []*QFileInfo
	q.Drv(22000, 22119, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::entryInfoList(QStringList const&)
func (q *QDir) EntryInfoListWithNamefilters(nameFilters []string) []*QFileInfo {
	_nameFilters, _nameFilters_size := NewCSArray(nameFilters)
	defer FreeCSArray(_nameFilters, _nameFilters_size)
	var __rv []*QFileInfo
	q.Drv(22000, 22120, unsafe.Pointer(&_nameFilters[0]), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::entryInfoList(QFlags<QDir::Filter>,QFlags<QDir::SortFlag>)
func (q *QDir) EntryInfoListWithFiltersSort(filters QDir_Filter, sort QDir_SortFlag) []*QFileInfo {
	var __rv []*QFileInfo
	q.Drv(22000, 22121, unsafe.Pointer(&filters), unsafe.Pointer(&sort), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::entryInfoList(QStringList const&,QFlags<QDir::Filter>,QFlags<QDir::SortFlag>)
func (q *QDir) EntryInfoListWithNamefiltersFiltersSort(nameFilters []string, filters QDir_Filter, sort QDir_SortFlag) []*QFileInfo {
	_nameFilters, _nameFilters_size := NewCSArray(nameFilters)
	defer FreeCSArray(_nameFilters, _nameFilters_size)
	var __rv []*QFileInfo
	q.Drv(22000, 22122, unsafe.Pointer(&_nameFilters[0]), unsafe.Pointer(&filters), unsafe.Pointer(&sort), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::entryList()
func (q *QDir) EntryList() []string {
	var __rv []string
	q.Drv(22000, 22123, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::entryList(QStringList const&)
func (q *QDir) EntryListWithNamefilters(nameFilters []string) []string {
	_nameFilters, _nameFilters_size := NewCSArray(nameFilters)
	defer FreeCSArray(_nameFilters, _nameFilters_size)
	var __rv []string
	q.Drv(22000, 22124, unsafe.Pointer(&_nameFilters[0]), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::entryList(QFlags<QDir::Filter>,QFlags<QDir::SortFlag>)
func (q *QDir) EntryListWithFiltersSort(filters QDir_Filter, sort QDir_SortFlag) []string {
	var __rv []string
	q.Drv(22000, 22125, unsafe.Pointer(&filters), unsafe.Pointer(&sort), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::entryList(QStringList const&,QFlags<QDir::Filter>,QFlags<QDir::SortFlag>)
func (q *QDir) EntryListWithNamefiltersFiltersSort(nameFilters []string, filters QDir_Filter, sort QDir_SortFlag) []string {
	_nameFilters, _nameFilters_size := NewCSArray(nameFilters)
	defer FreeCSArray(_nameFilters, _nameFilters_size)
	var __rv []string
	q.Drv(22000, 22126, unsafe.Pointer(&_nameFilters[0]), unsafe.Pointer(&filters), unsafe.Pointer(&sort), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::exists()
func (q *QDir) Exists() bool {
	var __rv bool
	q.Drv(22000, 22127, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::exists(QString const&)
func (q *QDir) ExistsWithName(name string) bool {
	_name := NewCStringHead(name)
	defer FreeCStringHead(_name)
	var __rv bool
	q.Drv(22000, 22128, unsafe.Pointer(_name), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::filePath(QString const&)
func (q *QDir) FilePath(fileName string) string {
	_fileName := NewCStringHead(fileName)
	defer FreeCStringHead(_fileName)
	var __rv C.string_head
	q.Drv(22000, 22129, unsafe.Pointer(_fileName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::filter()
func (q *QDir) Filter() QDir_Filter {
	var __rv QDir_Filter
	q.Drv(22000, 22130, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::fromNativeSeparators(QString const&)
func QDirFromNativeSeparators(pathName string) string {
	_pathName := NewCStringHead(pathName)
	defer FreeCStringHead(_pathName)
	var __rv C.string_head
	DirectQtDrv(nil, 22000, 22131, unsafe.Pointer(_pathName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::fromNativeSeparators(QString const&)
func (q *QDir) FromNativeSeparators(pathName string) string {
	_pathName := NewCStringHead(pathName)
	defer FreeCStringHead(_pathName)
	var __rv C.string_head
	q.Drv(22000, 22131, unsafe.Pointer(_pathName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::home()
func QDirHome() *QDir {
	var __rv uintptr
	DirectQtDrv(nil, 22000, 22132, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDir{}
	_rp.SetDriver(__rv, 22000, true)
	return _rp
}

//QDir::home()
func (q *QDir) Home() *QDir {
	var __rv uintptr
	q.Drv(22000, 22132, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDir{}
	_rp.SetDriver(__rv, 22000, true)
	return _rp
}

//QDir::homePath()
func QDirHomePath() string {
	var __rv C.string_head
	DirectQtDrv(nil, 22000, 22133, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::homePath()
func (q *QDir) HomePath() string {
	var __rv C.string_head
	q.Drv(22000, 22133, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::isAbsolute()
func (q *QDir) IsAbsolute() bool {
	var __rv bool
	q.Drv(22000, 22134, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::isAbsolutePath(QString const&)
func QDirIsAbsolutePath(path string) bool {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv bool
	DirectQtDrv(nil, 22000, 22135, unsafe.Pointer(_path), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::isAbsolutePath(QString const&)
func (q *QDir) IsAbsolutePath(path string) bool {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv bool
	q.Drv(22000, 22135, unsafe.Pointer(_path), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::isReadable()
func (q *QDir) IsReadable() bool {
	var __rv bool
	q.Drv(22000, 22136, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::isRelative()
func (q *QDir) IsRelative() bool {
	var __rv bool
	q.Drv(22000, 22137, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::isRelativePath(QString const&)
func QDirIsRelativePath(path string) bool {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv bool
	DirectQtDrv(nil, 22000, 22138, unsafe.Pointer(_path), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::isRelativePath(QString const&)
func (q *QDir) IsRelativePath(path string) bool {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv bool
	q.Drv(22000, 22138, unsafe.Pointer(_path), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::isRoot()
func (q *QDir) IsRoot() bool {
	var __rv bool
	q.Drv(22000, 22139, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::makeAbsolute()
func (q *QDir) MakeAbsolute() bool {
	var __rv bool
	q.Drv(22000, 22140, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::match(QString const&,QString const&)
func QDirMatchWithFilterFilename(filter string, fileName string) bool {
	_filter := NewCStringHead(filter)
	defer FreeCStringHead(_filter)
	_fileName := NewCStringHead(fileName)
	defer FreeCStringHead(_fileName)
	var __rv bool
	DirectQtDrv(nil, 22000, 22141, unsafe.Pointer(_filter), unsafe.Pointer(_fileName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::match(QString const&,QString const&)
func (q *QDir) MatchWithFilterFilename(filter string, fileName string) bool {
	_filter := NewCStringHead(filter)
	defer FreeCStringHead(_filter)
	_fileName := NewCStringHead(fileName)
	defer FreeCStringHead(_fileName)
	var __rv bool
	q.Drv(22000, 22141, unsafe.Pointer(_filter), unsafe.Pointer(_fileName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::match(QStringList const&,QString const&)
func QDirMatchWithFiltersFilename(filters []string, fileName string) bool {
	_filters, _filters_size := NewCSArray(filters)
	defer FreeCSArray(_filters, _filters_size)
	_fileName := NewCStringHead(fileName)
	defer FreeCStringHead(_fileName)
	var __rv bool
	DirectQtDrv(nil, 22000, 22142, unsafe.Pointer(&_filters[0]), unsafe.Pointer(_fileName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::match(QStringList const&,QString const&)
func (q *QDir) MatchWithFiltersFilename(filters []string, fileName string) bool {
	_filters, _filters_size := NewCSArray(filters)
	defer FreeCSArray(_filters, _filters_size)
	_fileName := NewCStringHead(fileName)
	defer FreeCStringHead(_fileName)
	var __rv bool
	q.Drv(22000, 22142, unsafe.Pointer(&_filters[0]), unsafe.Pointer(_fileName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::mkdir(QString const&)
func (q *QDir) Mkdir(dirName string) bool {
	_dirName := NewCStringHead(dirName)
	defer FreeCStringHead(_dirName)
	var __rv bool
	q.Drv(22000, 22143, unsafe.Pointer(_dirName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::mkpath(QString const&)
func (q *QDir) Mkpath(dirPath string) bool {
	_dirPath := NewCStringHead(dirPath)
	defer FreeCStringHead(_dirPath)
	var __rv bool
	q.Drv(22000, 22144, unsafe.Pointer(_dirPath), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::nameFilters()
func (q *QDir) NameFilters() []string {
	var __rv []string
	q.Drv(22000, 22145, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::nameFiltersFromString(QString const&)
func QDirNameFiltersFromString(nameFilter string) []string {
	_nameFilter := NewCStringHead(nameFilter)
	defer FreeCStringHead(_nameFilter)
	var __rv []string
	DirectQtDrv(nil, 22000, 22146, unsafe.Pointer(_nameFilter), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::nameFiltersFromString(QString const&)
func (q *QDir) NameFiltersFromString(nameFilter string) []string {
	_nameFilter := NewCStringHead(nameFilter)
	defer FreeCStringHead(_nameFilter)
	var __rv []string
	q.Drv(22000, 22146, unsafe.Pointer(_nameFilter), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::path()
func (q *QDir) Path() string {
	var __rv C.string_head
	q.Drv(22000, 22147, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::refresh()
func (q *QDir) Refresh() {
	q.Drv(22000, 22148, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::relativeFilePath(QString const&)
func (q *QDir) RelativeFilePath(fileName string) string {
	_fileName := NewCStringHead(fileName)
	defer FreeCStringHead(_fileName)
	var __rv C.string_head
	q.Drv(22000, 22149, unsafe.Pointer(_fileName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::remove(QString const&)
func (q *QDir) Remove(fileName string) bool {
	_fileName := NewCStringHead(fileName)
	defer FreeCStringHead(_fileName)
	var __rv bool
	q.Drv(22000, 22150, unsafe.Pointer(_fileName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::rename(QString const&,QString const&)
func (q *QDir) Rename(oldName string, newName string) bool {
	_oldName := NewCStringHead(oldName)
	defer FreeCStringHead(_oldName)
	_newName := NewCStringHead(newName)
	defer FreeCStringHead(_newName)
	var __rv bool
	q.Drv(22000, 22151, unsafe.Pointer(_oldName), unsafe.Pointer(_newName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::rmdir(QString const&)
func (q *QDir) Rmdir(dirName string) bool {
	_dirName := NewCStringHead(dirName)
	defer FreeCStringHead(_dirName)
	var __rv bool
	q.Drv(22000, 22152, unsafe.Pointer(_dirName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::rmpath(QString const&)
func (q *QDir) Rmpath(dirPath string) bool {
	_dirPath := NewCStringHead(dirPath)
	defer FreeCStringHead(_dirPath)
	var __rv bool
	q.Drv(22000, 22153, unsafe.Pointer(_dirPath), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::root()
func QDirRoot() *QDir {
	var __rv uintptr
	DirectQtDrv(nil, 22000, 22154, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDir{}
	_rp.SetDriver(__rv, 22000, true)
	return _rp
}

//QDir::root()
func (q *QDir) Root() *QDir {
	var __rv uintptr
	q.Drv(22000, 22154, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDir{}
	_rp.SetDriver(__rv, 22000, true)
	return _rp
}

//QDir::rootPath()
func QDirRootPath() string {
	var __rv C.string_head
	DirectQtDrv(nil, 22000, 22155, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::rootPath()
func (q *QDir) RootPath() string {
	var __rv C.string_head
	q.Drv(22000, 22155, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::searchPaths(QString const&)
func QDirSearchPaths(prefix string) []string {
	_prefix := NewCStringHead(prefix)
	defer FreeCStringHead(_prefix)
	var __rv []string
	DirectQtDrv(nil, 22000, 22156, unsafe.Pointer(_prefix), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::searchPaths(QString const&)
func (q *QDir) SearchPaths(prefix string) []string {
	_prefix := NewCStringHead(prefix)
	defer FreeCStringHead(_prefix)
	var __rv []string
	q.Drv(22000, 22156, unsafe.Pointer(_prefix), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::separator()
func QDirSeparator() rune {
	var __rv rune
	DirectQtDrv(nil, 22000, 22157, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::separator()
func (q *QDir) Separator() rune {
	var __rv rune
	q.Drv(22000, 22157, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::setCurrent(QString const&)
func QDirSetCurrent(path string) bool {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv bool
	DirectQtDrv(nil, 22000, 22158, unsafe.Pointer(_path), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::setCurrent(QString const&)
func (q *QDir) SetCurrent(path string) bool {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv bool
	q.Drv(22000, 22158, unsafe.Pointer(_path), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::setFilter(QFlags<QDir::Filter>)
func (q *QDir) SetFilter(filter QDir_Filter) {
	q.Drv(22000, 22159, unsafe.Pointer(&filter), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::setNameFilters(QStringList const&)
func (q *QDir) SetNameFilters(nameFilters []string) {
	_nameFilters, _nameFilters_size := NewCSArray(nameFilters)
	defer FreeCSArray(_nameFilters, _nameFilters_size)
	q.Drv(22000, 22160, unsafe.Pointer(&_nameFilters[0]), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::setPath(QString const&)
func (q *QDir) SetPath(path string) {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	q.Drv(22000, 22161, unsafe.Pointer(_path), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::setSearchPaths(QString const&,QStringList const&)
func QDirSetSearchPaths(prefix string, searchPaths []string) {
	_prefix := NewCStringHead(prefix)
	defer FreeCStringHead(_prefix)
	_searchPaths, _searchPaths_size := NewCSArray(searchPaths)
	defer FreeCSArray(_searchPaths, _searchPaths_size)
	DirectQtDrv(nil, 22000, 22162, unsafe.Pointer(_prefix), unsafe.Pointer(&_searchPaths[0]), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::setSearchPaths(QString const&,QStringList const&)
func (q *QDir) SetSearchPaths(prefix string, searchPaths []string) {
	_prefix := NewCStringHead(prefix)
	defer FreeCStringHead(_prefix)
	_searchPaths, _searchPaths_size := NewCSArray(searchPaths)
	defer FreeCSArray(_searchPaths, _searchPaths_size)
	q.Drv(22000, 22162, unsafe.Pointer(_prefix), unsafe.Pointer(&_searchPaths[0]), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::setSorting(QFlags<QDir::SortFlag>)
func (q *QDir) SetSorting(sort QDir_SortFlag) {
	q.Drv(22000, 22163, unsafe.Pointer(&sort), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDir::sorting()
func (q *QDir) Sorting() QDir_SortFlag {
	var __rv QDir_SortFlag
	q.Drv(22000, 22164, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDir::temp()
func QDirTemp() *QDir {
	var __rv uintptr
	DirectQtDrv(nil, 22000, 22165, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDir{}
	_rp.SetDriver(__rv, 22000, true)
	return _rp
}

//QDir::temp()
func (q *QDir) Temp() *QDir {
	var __rv uintptr
	q.Drv(22000, 22165, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QDir{}
	_rp.SetDriver(__rv, 22000, true)
	return _rp
}

//QDir::tempPath()
func QDirTempPath() string {
	var __rv C.string_head
	DirectQtDrv(nil, 22000, 22166, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::tempPath()
func (q *QDir) TempPath() string {
	var __rv C.string_head
	q.Drv(22000, 22166, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::toNativeSeparators(QString const&)
func QDirToNativeSeparators(pathName string) string {
	_pathName := NewCStringHead(pathName)
	defer FreeCStringHead(_pathName)
	var __rv C.string_head
	DirectQtDrv(nil, 22000, 22167, unsafe.Pointer(_pathName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDir::toNativeSeparators(QString const&)
func (q *QDir) ToNativeSeparators(pathName string) string {
	_pathName := NewCStringHead(pathName)
	defer FreeCStringHead(_pathName)
	var __rv C.string_head
	q.Drv(22000, 22167, unsafe.Pointer(_pathName), unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//enum QDirIterator_IteratorFlag - QDirIterator::IteratorFlag
type QDirIterator_IteratorFlag uint32

const (
	QDirIterator_NoIteratorFlags QDirIterator_IteratorFlag = 0x0
	QDirIterator_FollowSymlinks  QDirIterator_IteratorFlag = 0x1
	QDirIterator_Subdirectories  QDirIterator_IteratorFlag = 0x2
)

//struct QDirIterator : QDirIterator
type QDirIterator struct {
	BaseDrv
}

//QDirIterator::QDirIterator(QDir const&,QFlags<QDirIterator::IteratorFlag>)
func NewDirIterator(dir *QDir, flags QDirIterator_IteratorFlag) *QDirIterator {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 23000, 23102, Native(dir), unsafe.Pointer(&flags), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDirIterator{}
	_p.SetDriver(__rv, 23000, true)
	return _p
}

//QDirIterator::QDirIterator(QString const&,QFlags<QDirIterator::IteratorFlag>)
func NewDirIteratorWithPathFlags(path string, flags QDirIterator_IteratorFlag) *QDirIterator {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 23000, 23103, unsafe.Pointer(_path), unsafe.Pointer(&flags), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDirIterator{}
	_p.SetDriver(__rv, 23000, true)
	return _p
}

//QDirIterator::QDirIterator(QString const&,QFlags<QDir::Filter>,QFlags<QDirIterator::IteratorFlag>)
func NewDirIteratorWithPathFilterFlags(path string, filter QDir_Filter, flags QDirIterator_IteratorFlag) *QDirIterator {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 23000, 23104, unsafe.Pointer(_path), unsafe.Pointer(&filter), unsafe.Pointer(&flags), nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDirIterator{}
	_p.SetDriver(__rv, 23000, true)
	return _p
}

//QDirIterator::QDirIterator(QString const&,QStringList const&,QFlags<QDir::Filter>,QFlags<QDirIterator::IteratorFlag>)
func NewDirIteratorWithPathNamefiltersFiltersFlags(path string, nameFilters []string, filters QDir_Filter, flags QDirIterator_IteratorFlag) *QDirIterator {
	_path := NewCStringHead(path)
	defer FreeCStringHead(_path)
	_nameFilters, _nameFilters_size := NewCSArray(nameFilters)
	defer FreeCSArray(_nameFilters, _nameFilters_size)
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 23000, 23105, unsafe.Pointer(_path), unsafe.Pointer(&_nameFilters[0]), unsafe.Pointer(&filters), unsafe.Pointer(&flags), nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDirIterator{}
	_p.SetDriver(__rv, 23000, true)
	return _p
}

//QDirIterator::fileInfo()
func (q *QDirIterator) FileInfo() *QFileInfo {
	var __rv uintptr
	q.Drv(23000, 23106, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QFileInfo{}
	_rp.SetDriver(__rv, 34000, true)
	return _rp
}

//QDirIterator::fileName()
func (q *QDirIterator) FileName() string {
	var __rv C.string_head
	q.Drv(23000, 23107, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDirIterator::filePath()
func (q *QDirIterator) FilePath() string {
	var __rv C.string_head
	q.Drv(23000, 23108, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDirIterator::hasNext()
func (q *QDirIterator) HasNext() bool {
	var __rv bool
	q.Drv(23000, 23109, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDirIterator::next()
func (q *QDirIterator) Next() string {
	var __rv C.string_head
	q.Drv(23000, 23110, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//QDirIterator::path()
func (q *QDirIterator) Path() string {
	var __rv C.string_head
	q.Drv(23000, 23111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return C.GoStringN(__rv.data, __rv.size)
}

//struct QDragEnterEvent : QDragEnterEvent
type QDragEnterEvent struct {
	QDragMoveEvent
}

//struct QDragLeaveEvent : QDragLeaveEvent
type QDragLeaveEvent struct {
	QEvent
}

//QDragLeaveEvent::QDragLeaveEvent()
func NewDragLeaveEvent() *QDragLeaveEvent {
	var __rv uintptr
	err := DirectQtDrv(unsafe.Pointer(&__rv), 25000, 25102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if err != nil || __rv == 0 {
		return nil
	}
	_p := &QDragLeaveEvent{}
	_p.SetDriver(__rv, 25000, true)
	return _p
}

//struct QDragMoveEvent : QDragMoveEvent
type QDragMoveEvent struct {
	QDropEvent
}

//QDragMoveEvent::accept()
func (q *QDragMoveEvent) Accept() {
	q.Drv(26000, 26102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDragMoveEvent::accept(QRect const&)
func (q *QDragMoveEvent) AcceptWithRect(r *QRect) {
	q.Drv(26000, 26103, Native(r), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDragMoveEvent::answerRect()
func (q *QDragMoveEvent) AnswerRect() *QRect {
	var __rv uintptr
	q.Drv(26000, 26104, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QRect{}
	_rp.SetDriver(__rv, 111000, true)
	return _rp
}

//QDragMoveEvent::ignore()
func (q *QDragMoveEvent) Ignore() {
	q.Drv(26000, 26105, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDragMoveEvent::ignore(QRect const&)
func (q *QDragMoveEvent) IgnoreWithRect(r *QRect) {
	q.Drv(26000, 26106, Native(r), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//struct QDropEvent : QDropEvent
type QDropEvent struct {
	QEvent
}

//QDropEvent::acceptProposedAction()
func (q *QDropEvent) AcceptProposedAction() {
	q.Drv(27000, 27102, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDropEvent::dropAction()
func (q *QDropEvent) DropAction() Qt_DropAction {
	var __rv Qt_DropAction
	q.Drv(27000, 27103, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDropEvent::keyboardModifiers()
func (q *QDropEvent) KeyboardModifiers() Qt_KeyboardModifier {
	var __rv Qt_KeyboardModifier
	q.Drv(27000, 27104, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDropEvent::mimeData()
func (q *QDropEvent) MimeData() *QMimeData {
	var __rv uintptr
	q.Drv(27000, 27105, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QMimeData{}
	_rp.SetDriver(__rv, 313000, false)
	return _rp
}

//QDropEvent::mouseButtons()
func (q *QDropEvent) MouseButtons() Qt_MouseButton {
	var __rv Qt_MouseButton
	q.Drv(27000, 27106, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDropEvent::pos()
func (q *QDropEvent) Pos() *QPoint {
	var __rv uintptr
	q.Drv(27000, 27107, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QPoint{}
	_rp.SetDriver(__rv, 100000, true)
	return _rp
}

//QDropEvent::possibleActions()
func (q *QDropEvent) PossibleActions() Qt_DropAction {
	var __rv Qt_DropAction
	q.Drv(27000, 27108, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDropEvent::proposedAction()
func (q *QDropEvent) ProposedAction() Qt_DropAction {
	var __rv Qt_DropAction
	q.Drv(27000, 27109, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	return __rv
}

//QDropEvent::setDropAction(Qt::DropAction)
func (q *QDropEvent) SetDropAction(action Qt_DropAction) {
	q.Drv(27000, 27110, unsafe.Pointer(&action), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
}

//QDropEvent::source()
func (q *QDropEvent) Source() *QWidget {
	var __rv uintptr
	q.Drv(27000, 27111, unsafe.Pointer(&__rv), nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
	if __rv == 0 {
		return nil
	}
	_rp := &QWidget{}
	_rp.SetDriver(__rv, 397000, false)
	return _rp
}

//struct QDynamicPropertyChangeEvent : QDynamicPropertyChangeEvent
type QDynamicPropertyChangeEvent struct {
	QEvent
}

//QDynamicPropertyChangeEvent::QDynamicPropertyChangeEvent(QByteArray const&)
func NewDynamicPropertyChangeEvent(name []byte) *QDynamicPropertyChangeEvent {
	_name := NewC