cleanup internal/parser

README.md

@@ -110,7 +110,7 @@ If you use the STUB version, you are forced to use `qtminimal` otherwise it's op
 
 4. Download the binding
 
-	* `go get -v github.com/therecipe/qt/cmd/...`
+	* `go get -u -v github.com/therecipe/qt/cmd/...`
 
 5. Generate, install and test (20 min) (MSYS2: run within the MSYS2 MinGW 32-bit or MSYS2 MinGW 64-bit shell)
 
@@ -143,7 +143,7 @@ If you use the STUB version, you are forced to use `qtminimal` otherwise it's op
 
 4. Download the binding
 
-	* `go get -v github.com/therecipe/qt/cmd/...`
+	* `go get -u -v github.com/therecipe/qt/cmd/...`
 
 5. Generate, install and test (20 min)
 
@@ -185,7 +185,7 @@ If you use the STUB version, you are forced to use `qtminimal` otherwise it's op
 
 4. Download the binding
 
-	* `go get -v github.com/therecipe/qt/cmd/...`
+	* `go get -u -v github.com/therecipe/qt/cmd/...`
 
 5. Generate, install and test (20 min)
 

bluetooth/bluetooth.cpp

@@ -868,6 +868,11 @@ void* QBluetoothServer_NextPendingConnection(void* ptr)
 	return static_cast<QBluetoothServer*>(ptr)->nextPendingConnection();
 }
 
+long long QBluetoothServer_SecurityFlags(void* ptr)
+{
+	return static_cast<QBluetoothServer*>(ptr)->securityFlags();
+}
+
 void* QBluetoothServer_ServerAddress(void* ptr)
 {
 	return new QBluetoothAddress(static_cast<QBluetoothServer*>(ptr)->serverAddress());
@@ -883,6 +888,11 @@ void QBluetoothServer_SetMaxPendingConnections(void* ptr, int numConnections)
 	static_cast<QBluetoothServer*>(ptr)->setMaxPendingConnections(numConnections);
 }
 
+void QBluetoothServer_SetSecurityFlags(void* ptr, long long security)
+{
+	static_cast<QBluetoothServer*>(ptr)->setSecurityFlags(static_cast<QBluetooth::Security>(security));
+}
+
 void QBluetoothServer_TimerEvent(void* ptr, void* event)
 {
 	static_cast<QBluetoothServer*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
@@ -1611,6 +1621,16 @@ unsigned short QBluetoothSocket_PeerPort(void* ptr)
 	return static_cast<QBluetoothSocket*>(ptr)->peerPort();
 }
 
+long long QBluetoothSocket_PreferredSecurityFlags(void* ptr)
+{
+	return static_cast<QBluetoothSocket*>(ptr)->preferredSecurityFlags();
+}
+
+void QBluetoothSocket_SetPreferredSecurityFlags(void* ptr, long long flags)
+{
+	static_cast<QBluetoothSocket*>(ptr)->setPreferredSecurityFlags(static_cast<QBluetooth::Security>(flags));
+}
+
 char QBluetoothSocket_SetSocketDescriptor(void* ptr, int socketDescriptor, long long socketType, long long socketState, long long openMode)
 {
 	return static_cast<QBluetoothSocket*>(ptr)->setSocketDescriptor(socketDescriptor, static_cast<QBluetoothServiceInfo::Protocol>(socketType), static_cast<QBluetoothSocket::SocketState>(socketState), static_cast<QIODevice::OpenModeFlag>(openMode));
@@ -2545,11 +2565,21 @@ long long QLowEnergyCharacteristicData_Properties(void* ptr)
 	return static_cast<QLowEnergyCharacteristicData*>(ptr)->properties();
 }
 
+long long QLowEnergyCharacteristicData_ReadConstraints(void* ptr)
+{
+	return static_cast<QLowEnergyCharacteristicData*>(ptr)->readConstraints();
+}
+
 void QLowEnergyCharacteristicData_SetProperties(void* ptr, long long properties)
 {
 	static_cast<QLowEnergyCharacteristicData*>(ptr)->setProperties(static_cast<QLowEnergyCharacteristic::PropertyType>(properties));
 }
 
+void QLowEnergyCharacteristicData_SetReadConstraints(void* ptr, long long constraints)
+{
+	static_cast<QLowEnergyCharacteristicData*>(ptr)->setReadConstraints(static_cast<QBluetooth::AttAccessConstraint>(constraints));
+}
+
 void QLowEnergyCharacteristicData_SetUuid(void* ptr, void* uuid)
 {
 	static_cast<QLowEnergyCharacteristicData*>(ptr)->setUuid(*static_cast<QBluetoothUuid*>(uuid));
@@ -2565,6 +2595,11 @@ void QLowEnergyCharacteristicData_SetValueLength(void* ptr, int minimum, int max
 	static_cast<QLowEnergyCharacteristicData*>(ptr)->setValueLength(minimum, maximum);
 }
 
+void QLowEnergyCharacteristicData_SetWriteConstraints(void* ptr, long long constraints)
+{
+	static_cast<QLowEnergyCharacteristicData*>(ptr)->setWriteConstraints(static_cast<QBluetooth::AttAccessConstraint>(constraints));
+}
+
 void QLowEnergyCharacteristicData_Swap(void* ptr, void* other)
 {
 	static_cast<QLowEnergyCharacteristicData*>(ptr)->swap(*static_cast<QLowEnergyCharacteristicData*>(other));
@@ -2580,6 +2615,11 @@ void* QLowEnergyCharacteristicData_Value(void* ptr)
 	return new QByteArray(static_cast<QLowEnergyCharacteristicData*>(ptr)->value());
 }
 
+long long QLowEnergyCharacteristicData_WriteConstraints(void* ptr)
+{
+	return static_cast<QLowEnergyCharacteristicData*>(ptr)->writeConstraints();
+}
+
 void QLowEnergyCharacteristicData_DestroyQLowEnergyCharacteristicData(void* ptr)
 {
 	static_cast<QLowEnergyCharacteristicData*>(ptr)->~QLowEnergyCharacteristicData();
@@ -3041,6 +3081,16 @@ char QLowEnergyDescriptorData_IsWritable(void* ptr)
 	return static_cast<QLowEnergyDescriptorData*>(ptr)->isWritable();
 }
 
+long long QLowEnergyDescriptorData_ReadConstraints(void* ptr)
+{
+	return static_cast<QLowEnergyDescriptorData*>(ptr)->readConstraints();
+}
+
+void QLowEnergyDescriptorData_SetReadPermissions(void* ptr, char readable, long long constraints)
+{
+	static_cast<QLowEnergyDescriptorData*>(ptr)->setReadPermissions(readable != 0, static_cast<QBluetooth::AttAccessConstraint>(constraints));
+}
+
 void QLowEnergyDescriptorData_SetUuid(void* ptr, void* uuid)
 {
 	static_cast<QLowEnergyDescriptorData*>(ptr)->setUuid(*static_cast<QBluetoothUuid*>(uuid));
@@ -3051,6 +3101,11 @@ void QLowEnergyDescriptorData_SetValue(void* ptr, void* value)
 	static_cast<QLowEnergyDescriptorData*>(ptr)->setValue(*static_cast<QByteArray*>(value));
 }
 
+void QLowEnergyDescriptorData_SetWritePermissions(void* ptr, char writable, long long constraints)
+{
+	static_cast<QLowEnergyDescriptorData*>(ptr)->setWritePermissions(writable != 0, static_cast<QBluetooth::AttAccessConstraint>(constraints));
+}
+
 void QLowEnergyDescriptorData_Swap(void* ptr, void* other)
 {
 	static_cast<QLowEnergyDescriptorData*>(ptr)->swap(*static_cast<QLowEnergyDescriptorData*>(other));
@@ -3066,6 +3121,11 @@ void* QLowEnergyDescriptorData_Value(void* ptr)
 	return new QByteArray(static_cast<QLowEnergyDescriptorData*>(ptr)->value());
 }
 
+long long QLowEnergyDescriptorData_WriteConstraints(void* ptr)
+{
+	return static_cast<QLowEnergyDescriptorData*>(ptr)->writeConstraints();
+}
+
 void QLowEnergyDescriptorData_DestroyQLowEnergyDescriptorData(void* ptr)
 {
 	static_cast<QLowEnergyDescriptorData*>(ptr)->~QLowEnergyDescriptorData();

bluetooth/bluetooth.go

@@ -22,6 +22,136 @@ func cGoUnpackString(s C.struct_QtBluetooth_PackedString) string {
 	return C.GoStringN(s.data, C.int(s.len))
 }
 
+//OSXBluetooth::CentralManagerState
+type OSXBluetooth__CentralManagerState int64
+
+const (
+	OSXBluetooth__CentralManagerIdle          = OSXBluetooth__CentralManagerState(0)
+	OSXBluetooth__CentralManagerUpdating      = OSXBluetooth__CentralManagerState(1)
+	OSXBluetooth__CentralManagerConnecting    = OSXBluetooth__CentralManagerState(2)
+	OSXBluetooth__CentralManagerDiscovering   = OSXBluetooth__CentralManagerState(3)
+	OSXBluetooth__CentralManagerDisconnecting = OSXBluetooth__CentralManagerState(4)
+)
+
+//OSXBluetooth::OBEXRequest
+type OSXBluetooth__OBEXRequest int64
+
+const (
+	OSXBluetooth__OBEXNoop       = OSXBluetooth__OBEXRequest(0)
+	OSXBluetooth__OBEXConnect    = OSXBluetooth__OBEXRequest(1)
+	OSXBluetooth__OBEXDisconnect = OSXBluetooth__OBEXRequest(2)
+	OSXBluetooth__OBEXPut        = OSXBluetooth__OBEXRequest(3)
+	OSXBluetooth__OBEXGet        = OSXBluetooth__OBEXRequest(4)
+	OSXBluetooth__OBEXSetPath    = OSXBluetooth__OBEXRequest(5)
+	OSXBluetooth__OBEXAbort      = OSXBluetooth__OBEXRequest(6)
+)
+
+type OSXBluetooth struct {
+	ptr unsafe.Pointer
+}
+
+type OSXBluetooth_ITF interface {
+	OSXBluetooth_PTR() *OSXBluetooth
+}
+
+func (p *OSXBluetooth) OSXBluetooth_PTR() *OSXBluetooth {
+	return p
+}
+
+func (p *OSXBluetooth) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *OSXBluetooth) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromOSXBluetooth(ptr OSXBluetooth_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.OSXBluetooth_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewOSXBluetoothFromPointer(ptr unsafe.Pointer) *OSXBluetooth {
+	var n = new(OSXBluetooth)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *OSXBluetooth) DestroyOSXBluetooth() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
+//QBluetooth::AttAccessConstraint
+type QBluetooth__AttAccessConstraint int64
+
+const (
+	QBluetooth__AttAuthorizationRequired  = QBluetooth__AttAccessConstraint(0x1)
+	QBluetooth__AttAuthenticationRequired = QBluetooth__AttAccessConstraint(0x2)
+	QBluetooth__AttEncryptionRequired     = QBluetooth__AttAccessConstraint(0x4)
+)
+
+//QBluetooth::Security
+type QBluetooth__Security int64
+
+const (
+	QBluetooth__NoSecurity     = QBluetooth__Security(0x00)
+	QBluetooth__Authorization  = QBluetooth__Security(0x01)
+	QBluetooth__Authentication = QBluetooth__Security(0x02)
+	QBluetooth__Encryption     = QBluetooth__Security(0x04)
+	QBluetooth__Secure         = QBluetooth__Security(0x08)
+)
+
+type QBluetooth struct {
+	ptr unsafe.Pointer
+}
+
+type QBluetooth_ITF interface {
+	QBluetooth_PTR() *QBluetooth
+}
+
+func (p *QBluetooth) QBluetooth_PTR() *QBluetooth {
+	return p
+}
+
+func (p *QBluetooth) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QBluetooth) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQBluetooth(ptr QBluetooth_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QBluetooth_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQBluetoothFromPointer(ptr unsafe.Pointer) *QBluetooth {
+	var n = new(QBluetooth)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QBluetooth) DestroyQBluetooth() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QBluetoothAddress struct {
 	ptr unsafe.Pointer
 }
@@ -2212,6 +2342,13 @@ func (ptr *QBluetoothServer) NextPendingConnection() *QBluetoothSocket {
 	return nil
 }
 
+func (ptr *QBluetoothServer) SecurityFlags() QBluetooth__Security {
+	if ptr.Pointer() != nil {
+		return QBluetooth__Security(C.QBluetoothServer_SecurityFlags(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QBluetoothServer) ServerAddress() *QBluetoothAddress {
 	if ptr.Pointer() != nil {
 		var tmpValue = NewQBluetoothAddressFromPointer(C.QBluetoothServer_ServerAddress(ptr.Pointer()))
@@ -2234,6 +2371,12 @@ func (ptr *QBluetoothServer) SetMaxPendingConnections(numConnections int) {
 	}
 }
 
+func (ptr *QBluetoothServer) SetSecurityFlags(security QBluetooth__Security) {
+	if ptr.Pointer() != nil {
+		C.QBluetoothServer_SetSecurityFlags(ptr.Pointer(), C.longlong(security))
+	}
+}
+
 //export callbackQBluetoothServer_TimerEvent
 func callbackQBluetoothServer_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
 
@@ -4010,6 +4153,19 @@ func (ptr *QBluetoothSocket) PeerPort() uint16 {
 	return 0
 }
 
+func (ptr *QBluetoothSocket) PreferredSecurityFlags() QBluetooth__Security {
+	if ptr.Pointer() != nil {
+		return QBluetooth__Security(C.QBluetoothSocket_PreferredSecurityFlags(ptr.Pointer()))
+	}
+	return 0
+}
+
+func (ptr *QBluetoothSocket) SetPreferredSecurityFlags(flags QBluetooth__Security) {
+	if ptr.Pointer() != nil {
+		C.QBluetoothSocket_SetPreferredSecurityFlags(ptr.Pointer(), C.longlong(flags))
+	}
+}
+
 func (ptr *QBluetoothSocket) SetSocketDescriptor(socketDescriptor int, socketType QBluetoothServiceInfo__Protocol, socketState QBluetoothSocket__SocketState, openMode core.QIODevice__OpenModeFlag) bool {
 	if ptr.Pointer() != nil {
 		return C.QBluetoothSocket_SetSocketDescriptor(ptr.Pointer(), C.int(int32(socketDescriptor)), C.longlong(socketType), C.longlong(socketState), C.longlong(openMode)) != 0
@@ -6989,12 +7145,25 @@ func (ptr *QLowEnergyCharacteristicData) Properties() QLowEnergyCharacteristic__
 	return 0
 }
 
+func (ptr *QLowEnergyCharacteristicData) ReadConstraints() QBluetooth__AttAccessConstraint {
+	if ptr.Pointer() != nil {
+		return QBluetooth__AttAccessConstraint(C.QLowEnergyCharacteristicData_ReadConstraints(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QLowEnergyCharacteristicData) SetProperties(properties QLowEnergyCharacteristic__PropertyType) {
 	if ptr.Pointer() != nil {
 		C.QLowEnergyCharacteristicData_SetProperties(ptr.Pointer(), C.longlong(properties))
 	}
 }
 
+func (ptr *QLowEnergyCharacteristicData) SetReadConstraints(constraints QBluetooth__AttAccessConstraint) {
+	if ptr.Pointer() != nil {
+		C.QLowEnergyCharacteristicData_SetReadConstraints(ptr.Pointer(), C.longlong(constraints))
+	}
+}
+
 func (ptr *QLowEnergyCharacteristicData) SetUuid(uuid QBluetoothUuid_ITF) {
 	if ptr.Pointer() != nil {
 		C.QLowEnergyCharacteristicData_SetUuid(ptr.Pointer(), PointerFromQBluetoothUuid(uuid))
@@ -7013,6 +7182,12 @@ func (ptr *QLowEnergyCharacteristicData) SetValueLength(minimum int, maximum int
 	}
 }
 
+func (ptr *QLowEnergyCharacteristicData) SetWriteConstraints(constraints QBluetooth__AttAccessConstraint) {
+	if ptr.Pointer() != nil {
+		C.QLowEnergyCharacteristicData_SetWriteConstraints(ptr.Pointer(), C.longlong(constraints))
+	}
+}
+
 func (ptr *QLowEnergyCharacteristicData) Swap(other QLowEnergyCharacteristicData_ITF) {
 	if ptr.Pointer() != nil {
 		C.QLowEnergyCharacteristicData_Swap(ptr.Pointer(), PointerFromQLowEnergyCharacteristicData(other))
@@ -7037,6 +7212,13 @@ func (ptr *QLowEnergyCharacteristicData) Value() *core.QByteArray {
 	return nil
 }
 
+func (ptr *QLowEnergyCharacteristicData) WriteConstraints() QBluetooth__AttAccessConstraint {
+	if ptr.Pointer() != nil {
+		return QBluetooth__AttAccessConstraint(C.QLowEnergyCharacteristicData_WriteConstraints(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QLowEnergyCharacteristicData) DestroyQLowEnergyCharacteristicData() {
 	if ptr.Pointer() != nil {
 		C.QLowEnergyCharacteristicData_DestroyQLowEnergyCharacteristicData(ptr.Pointer())
@@ -8135,6 +8317,19 @@ func (ptr *QLowEnergyDescriptorData) IsWritable() bool {
 	return false
 }
 
+func (ptr *QLowEnergyDescriptorData) ReadConstraints() QBluetooth__AttAccessConstraint {
+	if ptr.Pointer() != nil {
+		return QBluetooth__AttAccessConstraint(C.QLowEnergyDescriptorData_ReadConstraints(ptr.Pointer()))
+	}
+	return 0
+}
+
+func (ptr *QLowEnergyDescriptorData) SetReadPermissions(readable bool, constraints QBluetooth__AttAccessConstraint) {
+	if ptr.Pointer() != nil {
+		C.QLowEnergyDescriptorData_SetReadPermissions(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(readable))), C.longlong(constraints))
+	}
+}
+
 func (ptr *QLowEnergyDescriptorData) SetUuid(uuid QBluetoothUuid_ITF) {
 	if ptr.Pointer() != nil {
 		C.QLowEnergyDescriptorData_SetUuid(ptr.Pointer(), PointerFromQBluetoothUuid(uuid))
@@ -8147,6 +8342,12 @@ func (ptr *QLowEnergyDescriptorData) SetValue(value core.QByteArray_ITF) {
 	}
 }
 
+func (ptr *QLowEnergyDescriptorData) SetWritePermissions(writable bool, constraints QBluetooth__AttAccessConstraint) {
+	if ptr.Pointer() != nil {
+		C.QLowEnergyDescriptorData_SetWritePermissions(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(writable))), C.longlong(constraints))
+	}
+}
+
 func (ptr *QLowEnergyDescriptorData) Swap(other QLowEnergyDescriptorData_ITF) {
 	if ptr.Pointer() != nil {
 		C.QLowEnergyDescriptorData_Swap(ptr.Pointer(), PointerFromQLowEnergyDescriptorData(other))
@@ -8171,6 +8372,13 @@ func (ptr *QLowEnergyDescriptorData) Value() *core.QByteArray {
 	return nil
 }
 
+func (ptr *QLowEnergyDescriptorData) WriteConstraints() QBluetooth__AttAccessConstraint {
+	if ptr.Pointer() != nil {
+		return QBluetooth__AttAccessConstraint(C.QLowEnergyDescriptorData_WriteConstraints(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QLowEnergyDescriptorData) DestroyQLowEnergyDescriptorData() {
 	if ptr.Pointer() != nil {
 		C.QLowEnergyDescriptorData_DestroyQLowEnergyDescriptorData(ptr.Pointer())

bluetooth/bluetooth.h

@@ -165,9 +165,11 @@ void QBluetoothServer_Close(void* ptr);
 char QBluetoothServer_HasPendingConnections(void* ptr);
 char QBluetoothServer_Listen(void* ptr, void* address, unsigned short port);
 void* QBluetoothServer_NextPendingConnection(void* ptr);
+long long QBluetoothServer_SecurityFlags(void* ptr);
 void* QBluetoothServer_ServerAddress(void* ptr);
 unsigned short QBluetoothServer_ServerPort(void* ptr);
 void QBluetoothServer_SetMaxPendingConnections(void* ptr, int numConnections);
+void QBluetoothServer_SetSecurityFlags(void* ptr, long long security);
 void QBluetoothServer_TimerEvent(void* ptr, void* event);
 void QBluetoothServer_TimerEventDefault(void* ptr, void* event);
 void QBluetoothServer_ChildEvent(void* ptr, void* event);
@@ -302,6 +304,8 @@ unsigned short QBluetoothSocket_LocalPort(void* ptr);
 void* QBluetoothSocket_PeerAddress(void* ptr);
 struct QtBluetooth_PackedString QBluetoothSocket_PeerName(void* ptr);
 unsigned short QBluetoothSocket_PeerPort(void* ptr);
+long long QBluetoothSocket_PreferredSecurityFlags(void* ptr);
+void QBluetoothSocket_SetPreferredSecurityFlags(void* ptr, long long flags);
 char QBluetoothSocket_SetSocketDescriptor(void* ptr, int socketDescriptor, long long socketType, long long socketState, long long openMode);
 void QBluetoothSocket_SetSocketError(void* ptr, long long error_);
 void QBluetoothSocket_SetSocketState(void* ptr, long long state);
@@ -481,13 +485,17 @@ char QLowEnergyCharacteristicData_IsValid(void* ptr);
 int QLowEnergyCharacteristicData_MaximumValueLength(void* ptr);
 int QLowEnergyCharacteristicData_MinimumValueLength(void* ptr);
 long long QLowEnergyCharacteristicData_Properties(void* ptr);
+long long QLowEnergyCharacteristicData_ReadConstraints(void* ptr);
 void QLowEnergyCharacteristicData_SetProperties(void* ptr, long long properties);
+void QLowEnergyCharacteristicData_SetReadConstraints(void* ptr, long long constraints);
 void QLowEnergyCharacteristicData_SetUuid(void* ptr, void* uuid);
 void QLowEnergyCharacteristicData_SetValue(void* ptr, void* value);
 void QLowEnergyCharacteristicData_SetValueLength(void* ptr, int minimum, int maximum);
+void QLowEnergyCharacteristicData_SetWriteConstraints(void* ptr, long long constraints);
 void QLowEnergyCharacteristicData_Swap(void* ptr, void* other);
 void* QLowEnergyCharacteristicData_Uuid(void* ptr);
 void* QLowEnergyCharacteristicData_Value(void* ptr);
+long long QLowEnergyCharacteristicData_WriteConstraints(void* ptr);
 void QLowEnergyCharacteristicData_DestroyQLowEnergyCharacteristicData(void* ptr);
 void* QLowEnergyCharacteristicData_descriptors_atList(void* ptr, int i);
 void* QLowEnergyConnectionParameters_NewQLowEnergyConnectionParameters();
@@ -576,11 +584,15 @@ void* QLowEnergyDescriptorData_NewQLowEnergyDescriptorData3(void* other);
 char QLowEnergyDescriptorData_IsReadable(void* ptr);
 char QLowEnergyDescriptorData_IsValid(void* ptr);
 char QLowEnergyDescriptorData_IsWritable(void* ptr);
+long long QLowEnergyDescriptorData_ReadConstraints(void* ptr);
+void QLowEnergyDescriptorData_SetReadPermissions(void* ptr, char readable, long long constraints);
 void QLowEnergyDescriptorData_SetUuid(void* ptr, void* uuid);
 void QLowEnergyDescriptorData_SetValue(void* ptr, void* value);
+void QLowEnergyDescriptorData_SetWritePermissions(void* ptr, char writable, long long constraints);
 void QLowEnergyDescriptorData_Swap(void* ptr, void* other);
 void* QLowEnergyDescriptorData_Uuid(void* ptr);
 void* QLowEnergyDescriptorData_Value(void* ptr);
+long long QLowEnergyDescriptorData_WriteConstraints(void* ptr);
 void QLowEnergyDescriptorData_DestroyQLowEnergyDescriptorData(void* ptr);
 void QLowEnergyService_ConnectCharacteristicChanged(void* ptr);
 void QLowEnergyService_DisconnectCharacteristicChanged(void* ptr);

cmd/qtdeploy/qtdeploy.go

@@ -162,7 +162,7 @@ func args() {
 	}
 
 	if !filepath.IsAbs(appPath) {
-		appPath = utils.GetAbsPath(appPath)
+		appPath, _ = utils.Abs(appPath)
 	}
 	appName = filepath.Base(appPath)
 
@@ -187,7 +187,7 @@ func args() {
 	case "build", "test":
 		{
 			utils.RemoveAll(depPath)
-			utils.MakeFolder(depPath)
+			utils.MkdirAll(depPath)
 		}
 	}
 
@@ -505,10 +505,10 @@ func predeploy() {
 	switch buildTarget {
 	case "android":
 		{
-			utils.MakeFolder(filepath.Join(appPath, "android"))
+			utils.MkdirAll(filepath.Join(appPath, "android"))
 
 			var libPath = filepath.Join(depPath, "build", "libs", "armeabi-v7a")
-			utils.MakeFolder(libPath)
+			utils.MkdirAll(libPath)
 
 			var compiler = filepath.Join(utils.ANDROID_NDK_DIR(), "toolchains", "arm-linux-androideabi-4.9", "prebuilt", runtime.GOOS+"-x86_64", "bin", "arm-linux-androideabi-g++")
 
@@ -574,11 +574,11 @@ func predeploy() {
 
 	case "ios", "ios-simulator":
 		{
-			utils.MakeFolder(filepath.Join(appPath, buildTarget))
+			utils.MkdirAll(filepath.Join(appPath, buildTarget))
 
 			var buildPath = filepath.Join(depPath, "build")
-			utils.MakeFolder(filepath.Join(buildPath, "project.xcodeproj"))
-			utils.MakeFolder(filepath.Join(buildPath, "Images.xcassets", "AppIcon.appiconset"))
+			utils.MkdirAll(filepath.Join(buildPath, "project.xcodeproj"))
+			utils.MkdirAll(filepath.Join(buildPath, "Images.xcassets", "AppIcon.appiconset"))
 
 			//add c_main_wrappers
 			utils.Save(filepath.Join(depPath, "c_main_wrapper.cpp"), "#include \"libgo.h\"\nint main(int argc, char *argv[]) { go_main_wrapper(); }")
@@ -654,10 +654,10 @@ func predeploy() {
 
 	case "sailfish", "sailfish-emulator":
 		{
-			utils.MakeFolder(filepath.Join(appPath, buildTarget))
+			utils.MkdirAll(filepath.Join(appPath, buildTarget))
 
 			//create default assets
-			utils.MakeFolder(filepath.Join(depPath, "rpm"))
+			utils.MkdirAll(filepath.Join(depPath, "rpm"))
 			utils.Save(filepath.Join(depPath, "rpm", appName+".spec"), sailfishSpec())
 			utils.Save(filepath.Join(depPath, appName+".desktop"), sailfishDesktop())
 
@@ -704,7 +704,7 @@ func deploy() {
 				"--gradle",
 			)
 
-			if utils.Exists(filepath.Join(appPath, "android", appName+".keystore")) {
+			if utils.ExistsFile(filepath.Join(appPath, "android", appName+".keystore")) {
 				deploy.Args = append(deploy.Args,
 					"--sign", filepath.Join(appPath, "android", appName+".keystore"),
 					strings.TrimSpace(utils.Load(filepath.Join(appPath, "android", "alias.txt"))),
@@ -769,7 +769,7 @@ func deploy() {
 						} else {
 							output = utils.RunCmd(exec.Command("/usr/lib/mxe/usr/bin/i686-w64-mingw32.shared-objdump", "-x", filepath.Join(depPath, appName+ending)), fmt.Sprintf("objdump binary for %v on %v", buildTarget, runtime.GOOS))
 						}
-						for lib, deps := range templater.LibDeps {
+						for lib, deps := range parser.LibDeps {
 							if strings.Contains(output, lib) && lib != parser.MOC {
 								for _, lib := range append(deps, lib) {
 									utils.RunCmd(exec.Command("cp", filepath.Join(libraryPath, fmt.Sprintf("Qt5%v.dll", lib)), depPath), fmt.Sprintf("copy %v for %v on %v", lib, buildTarget, runtime.GOOS))
@@ -818,7 +818,7 @@ func deploy() {
 
 					libraryPath = filepath.Join(utils.QT_MSYS2_DIR(), "bin")
 					var output = utils.RunCmd(exec.Command(filepath.Join(utils.QT_MSYS2_DIR(), "bin", "objdump"), "-x", filepath.Join(depPath, appName+ending)), fmt.Sprintf("objdump binary for %v on %v", buildTarget, runtime.GOOS))
-					for lib, deps := range templater.LibDeps {
+					for lib, deps := range parser.LibDeps {
 						if strings.Contains(output, lib) && lib != parser.MOC {
 							for _, lib := range append(deps, lib) {
 								utils.RunCmd(exec.Command(copyCmd, filepath.Join(libraryPath, fmt.Sprintf("Qt5%v.dll", lib)), depPath), fmt.Sprintf("copy %v for %v on %v", lib, buildTarget, runtime.GOOS))
@@ -867,7 +867,7 @@ func deploy() {
 						return
 					}
 
-					utils.MakeFolder(filepath.Join(depPath, "lib"))
+					utils.MkdirAll(filepath.Join(depPath, "lib"))
 
 					var (
 						libraryPath string
@@ -899,18 +899,18 @@ func deploy() {
 								}
 							}
 
-							if utils.Exists(filepath.Join(libraryPath, libName)) {
+							if utils.ExistsFile(filepath.Join(libraryPath, libName)) {
 								utils.RunCmd(exec.Command("cp", "-L", filepath.Join(libraryPath, libName), filepath.Join(depPath, "lib", libName)), fmt.Sprintf("copy %v for %v on %v", libName, buildTarget, runtime.GOOS))
 							}
 						}
 					}
 
 					for _, libName := range []string{"DBus", "XcbQpa", "Quick", "Widgets", "EglDeviceIntegration", "EglFsKmsSupport", "OpenGL", "WaylandClient", "WaylandCompositor", "QuickControls2", "QuickTemplates2", "QuickWidgets", "QuickParticles", "CLucene", "Concurrent"} {
-						if utils.Exists(filepath.Join(libraryPath, fmt.Sprintf("libQt5%v.so.5", libName))) {
+						if utils.ExistsFile(filepath.Join(libraryPath, fmt.Sprintf("libQt5%v.so.5", libName))) {
 							utils.RunCmd(exec.Command("cp", "-L", filepath.Join(libraryPath, fmt.Sprintf("libQt5%v.so.5", libName)), filepath.Join(depPath, "lib", fmt.Sprintf("libQt5%v.so.5", libName))), fmt.Sprintf("copy %v for %v on %v", libName, buildTarget, runtime.GOOS))
 						}
 					}
-					if utils.Exists(filepath.Join(libraryPath, "libqgsttools_p.so.1.0.0")) {
+					if utils.ExistsFile(filepath.Join(libraryPath, "libqgsttools_p.so.1.0.0")) {
 						utils.RunCmd(exec.Command("cp", "-L", filepath.Join(libraryPath, "libqgsttools_p.so.1.0.0"), filepath.Join(depPath, "lib", "libqgsttools_p.so.1")), fmt.Sprintf("copy libqgsttools_p.so.1 for %v on %v", buildTarget, runtime.GOOS))
 					}
 
@@ -964,7 +964,7 @@ func pastdeploy() {
 				}
 			}
 
-			if utils.Exists(filepath.Join(appPath, "android", appName+".keystore")) {
+			if utils.ExistsFile(filepath.Join(appPath, "android", appName+".keystore")) {
 				utils.RunCmd(exec.Command(copyCmd, filepath.Join(depPath, "build", "build", "outputs", "apk", "build-release-signed.apk"), filepath.Join(depPath, fmt.Sprintf("%v.%v", appName, apkEnding))), fmt.Sprintf("copy release apk for %v on %v", buildTarget, runtime.GOOS))
 			} else {
 				utils.RunCmd(exec.Command(copyCmd, filepath.Join(depPath, "build", "build", "outputs", "apk", "build-debug.apk"), filepath.Join(depPath, fmt.Sprintf("%v.%v", appName, apkEnding))), fmt.Sprintf("copy debug apk for %v on %v", buildTarget, runtime.GOOS))

cmd/qtminimal/qtminimal.go

@@ -34,7 +34,7 @@ func main() {
 		}
 	}
 	if !filepath.IsAbs(appPath) {
-		appPath = utils.GetAbsPath(appPath)
+		appPath, _ = utils.Abs(appPath)
 	}
 	if _, err := ioutil.ReadDir(appPath); err != nil {
 		utils.Log.Fatalln("usage:", "qtminimal", "[ desktop | android | ... ]", filepath.Join("path", "to", "project"))
@@ -43,7 +43,7 @@ func main() {
 	var (
 		imported       []string
 		cached         []string
-		importedPkgMap = make(map[string]bool)
+		importedPkgMap = make(map[string]struct{})
 		goPaths        = strings.Split(os.Getenv("GOPATH"), string(os.PathListSeparator))
 	)
 
@@ -66,16 +66,16 @@ func main() {
 					} else {
 						if iPath := strings.Replace(i.Path.Value, "\"", "", -1); iPath != "github.com/therecipe/qt" {
 							var pkg string
-							for _, pkgs := range templater.Libs {
+							for _, pkgs := range parser.Libs {
 								if strings.ToLower(pkgs) == strings.TrimPrefix(iPath, "github.com/therecipe/qt/") {
 									pkg = pkgs
 								}
 							}
-							if _, exists := templater.LibDeps[pkg]; exists {
-								importedPkgMap[pkg] = true
-								for _, dep := range templater.LibDeps[pkg] {
-									if _, exists := templater.LibDeps[dep]; exists {
-										importedPkgMap[dep] = true
+							if _, exists := parser.LibDeps[pkg]; exists {
+								importedPkgMap[pkg] = struct{}{}
+								for _, dep := range parser.LibDeps[pkg] {
+									if _, exists := parser.LibDeps[dep]; exists {
+										importedPkgMap[dep] = struct{}{}
 									}
 								}
 							}
@@ -110,22 +110,21 @@ func main() {
 	}
 
 	var importedPkgs []string
-	for _, dep := range templater.Libs {
+	for _, dep := range parser.Libs {
 		if _, exist := importedPkgMap[dep]; exist {
 			importedPkgs = append(importedPkgs, dep)
 		}
 	}
 
 	for _, module := range importedPkgs {
-		utils.Log.Debugf("loading qt/%v", strings.ToLower(module))
-		if _, err := parser.GetModule(module); err != nil {
-			utils.Log.WithError(err).Errorf("failed to load qt/%v", strings.ToLower(module))
+		if err := parser.LoadModule(module); err != nil {
+			return //err
 		}
 	}
 
 	var file = strings.Join(cached, "")
 
-	for className, c := range parser.ClassMap {
+	for className, c := range parser.CurrentState.ClassMap {
 		if strings.Contains(file, className) {
 			c.Export = true
 
@@ -138,7 +137,7 @@ func main() {
 			}
 
 			for _, bc := range c.GetAllBases() {
-				parser.ClassMap[bc].Export = true
+				parser.CurrentState.ClassMap[bc].Export = true
 			}
 		}
 
@@ -179,15 +178,15 @@ func main() {
 	}
 
 	if buildTarget == "sailfish" || buildTarget == "sailfish-emulator" {
-		parser.ClassMap["QQuickWidget"].Export = false
+		parser.CurrentState.ClassMap["QQuickWidget"].Export = false
 	}
 
 	if buildTarget == "ios" || buildTarget == "ios-simulator" {
-		parser.ClassMap["QProcess"].Export = false
-		parser.ClassMap["QProcessEnvironment"].Export = false
+		parser.CurrentState.ClassMap["QProcess"].Export = false
+		parser.CurrentState.ClassMap["QProcessEnvironment"].Export = false
 	}
 
-	templater.Minimal = true
+	parser.CurrentState.Minimal = true
 	for _, module := range importedPkgs {
 		utils.Log.Debugf("generating minimal qt/%v", strings.ToLower(module))
 		templater.GenModule(strings.Title(module))
@@ -203,24 +202,24 @@ func exportFunction(class *parser.Class, function *parser.Function) {
 			class.Export = true
 
 			for _, bc := range class.GetAllBases() {
-				parser.ClassMap[bc].Export = true
+				parser.CurrentState.ClassMap[bc].Export = true
 			}
 
 			for _, p := range f.Parameters {
-				if class, exists := parser.ClassMap[converter.CleanValue(p.Value)]; exists {
+				if class, exists := parser.CurrentState.ClassMap[converter.CleanValue(p.Value)]; exists {
 					class.Export = true
 
 					for _, bc := range class.GetAllBases() {
-						parser.ClassMap[bc].Export = true
+						parser.CurrentState.ClassMap[bc].Export = true
 					}
 				}
 			}
 
-			if class, exists := parser.ClassMap[converter.CleanValue(f.Output)]; exists {
+			if class, exists := parser.CurrentState.ClassMap[converter.CleanValue(f.Output)]; exists {
 				class.Export = true
 
 				for _, bc := range class.GetAllBases() {
-					parser.ClassMap[bc].Export = true
+					parser.CurrentState.ClassMap[bc].Export = true
 				}
 			}
 
@@ -236,7 +235,7 @@ func exportFunction(class *parser.Class, function *parser.Function) {
 }
 
 func hasPureVirtualFunctions(className string) bool {
-	for _, f := range parser.ClassMap[className].Functions {
+	for _, f := range parser.CurrentState.ClassMap[className].Functions {
 		if f.Virtual == parser.PURE {
 			return true
 		}

cmd/qtmoc/qtmoc.go

@@ -42,7 +42,7 @@ func main() {
 
 	// validate that path is readable and a directory
 	if !filepath.IsAbs(appPath) {
-		appPath = utils.GetAbsPath(appPath)
+		appPath, _ = utils.Abs(appPath)
 	}
 	fields["app_path"] = appPath
 

cmd/qtrcc/qtrcc.go

@@ -22,7 +22,7 @@ func main() {
 		}
 	}
 	if !filepath.IsAbs(appPath) {
-		appPath = utils.GetAbsPath(appPath)
+		appPath, _ = utils.Abs(appPath)
 	}
 	if _, err := ioutil.ReadDir(appPath); err != nil {
 		utils.Log.Fatalln("usage:", "qtrcc", filepath.Join("path", "to", "project"))
@@ -30,7 +30,7 @@ func main() {
 
 	var appName = filepath.Base(appPath)
 
-	utils.MakeFolder(filepath.Join(appPath, "qml"))
+	utils.MkdirAll(filepath.Join(appPath, "qml"))
 
 	var (
 		rccPath string
@@ -72,7 +72,7 @@ func main() {
 
 	utils.Save(qmlQrc, strings.Replace(utils.Load(qmlQrc), "<file>./", "<file>qml/", -1))
 
-	if utils.Exists(filepath.Join(appPath, "qtquickcontrols2.conf")) {
+	if utils.ExistsFile(filepath.Join(appPath, "qtquickcontrols2.conf")) {
 		utils.Save(qmlQrc, strings.Replace(utils.Load(qmlQrc), "<qresource>", "<qresource>\n<file>qtquickcontrols2.conf</file>", -1))
 	}
 

cmd/qtsetup/generate.go

@@ -11,32 +11,27 @@ import (
 func generate(buildTarget string) {
 	utils.Log.Info("running setup/generate")
 
-	if testFile := utils.GoQtPkgPath("core", "cgo_desktop_darwin_amd64.go"); utils.Exists(testFile) && strings.Contains(utils.Load(testFile), utils.QT_DIR()) {
+	if testFile := utils.GoQtPkgPath("core", "cgo_desktop_darwin_amd64.go"); utils.ExistsFile(testFile) && strings.Contains(utils.Load(testFile), utils.QT_DIR()) {
 		if buildTarget != "desktop" && utils.QT_STUB() &&
-			!utils.Exists(utils.GoQtPkgPath("core", "core.h")) &&
-			!utils.Exists(utils.GoQtPkgPath("core", "core.cpp")) {
+			!utils.ExistsFile(utils.GoQtPkgPath("core", "core.h")) &&
+			!utils.ExistsFile(utils.GoQtPkgPath("core", "core.cpp")) {
 
 			utils.Log.Debug("stub files are up to date -> don't re-generate")
 			return
 		}
 
 		if buildTarget != "desktop" && !utils.QT_STUB() &&
-			utils.Exists(utils.GoQtPkgPath("core", "core.h")) &&
-			utils.Exists(utils.GoQtPkgPath("core", "core.cpp")) {
+			utils.ExistsFile(utils.GoQtPkgPath("core", "core.h")) &&
+			utils.ExistsFile(utils.GoQtPkgPath("core", "core.cpp")) {
 
 			utils.Log.Debug("real files are up to date -> don't re-generate")
 			return
 		}
 	}
 
-	for _, module := range templater.GetLibs() {
-		utils.Log.Debugf("loading qt/%v", strings.ToLower(module))
-		if _, err := parser.GetModule(module); err != nil {
-			utils.Log.WithError(err).Errorf("failed to load qt/%v", strings.ToLower(module))
-		}
-	}
+	parser.LoadModules()
 
-	for _, module := range templater.GetLibs() {
+	for _, module := range parser.GetLibs() {
 		utils.Log.Infof("generating %v qt/%v", func() string {
 			if utils.QT_STUB() {
 				return "stub"

cmd/qtsetup/install.go

@@ -9,6 +9,7 @@ import (
 	"runtime"
 	"strings"
 
+	"github.com/therecipe/qt/internal/binding/parser"
 	"github.com/therecipe/qt/internal/binding/templater"
 	"github.com/therecipe/qt/internal/utils"
 )
@@ -71,7 +72,7 @@ func install(buildTarget string) {
 		return ""
 	}())
 
-	for _, module := range templater.GetLibs() {
+	for _, module := range parser.GetLibs() {
 		if templater.ShouldBuild(module) {
 
 			if !(buildTarget == "android" && (module == "DBus" || module == "WebEngine" || module == "Designer" || (strings.HasSuffix(module, "Extras") && module != "AndroidExtras"))) &&

cmd/qtsetup/prep.go

@@ -18,9 +18,9 @@ func prep() {
 		utils.RunCmdOptional(exec.Command("cmd", "/C", "mklink", "/H", filepath.Join(os.Getenv("QT_MSYS2_DIR"), "usr", "bin", "go.exe"), filepath.Join(runtime.GOROOT(), "bin", "go.exe")), fmt.Sprintf("create go symlink in your QT_MSYS2_DIR/usr/bin (%v)", filepath.Join(utils.QT_MSYS2_DIR(), "..", "usr", "bin")))
 	}
 
-	utils.RunCmd(exec.Command("go", "get", "-v", "github.com/emirpasic/gods/lists/arraylist"), "install emirpasic/gods") //needed for widgets/table example
-	utils.RunCmd(exec.Command("go", "get", "-v", "github.com/fogleman/ln/ln"), "install fogleman/ln")                    //needed for widgets/renderer example
-	utils.RunCmd(exec.Command("go", "get", "-v", "github.com/fogleman/pt/pt"), "install fogleman/pt")                    //needed for widgets/renderer example
+	utils.RunCmd(exec.Command("go", "get", "-u", "-v", "github.com/emirpasic/gods/lists/arraylist"), "install emirpasic/gods") //needed for widgets/table example
+	utils.RunCmd(exec.Command("go", "get", "-u", "-v", "github.com/fogleman/ln/ln"), "install fogleman/ln")                    //needed for widgets/renderer example
+	utils.RunCmd(exec.Command("go", "get", "-u", "-v", "github.com/fogleman/pt/pt"), "install fogleman/pt")                    //needed for widgets/renderer example
 
 	for _, app := range []string{"qtdeploy", "qtmoc", "qtrcc", "qtminimal"} {
 		switch runtime.GOOS {

core/core.cpp

@@ -1094,6 +1094,11 @@ char QAbstractItemModel_InsertRowsDefault(void* ptr, int row, int count, void* p
 	return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
 }
 
+struct QtCore_PackedList QAbstractItemModel_Match(void* ptr, void* start, int role, void* value, int hits, long long flags)
+{
+	return ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(static_cast<QAbstractItemModel*>(ptr)->match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 struct QtCore_PackedString QAbstractItemModel_MimeTypes(void* ptr)
 {
 	return ({ QByteArray ta50262 = static_cast<QAbstractItemModel*>(ptr)->mimeTypes().join("|").toUtf8(); QtCore_PackedString { const_cast<char*>(ta50262.prepend("WHITESPACE").constData()+10), ta50262.size()-10 }; });
@@ -6887,6 +6892,11 @@ void QEasingCurve_DestroyQEasingCurve(void* ptr)
 	static_cast<QEasingCurve*>(ptr)->~QEasingCurve();
 }
 
+void* QEasingCurve_cubicBezierSpline_atList(void* ptr, int i)
+{
+	return ({ QPointF tmpValue = static_cast<QList<QPointF>*>(ptr)->at(i); new QPointF(tmpValue.x(), tmpValue.y()); });
+}
+
 void* QEasingCurve_toCubicSpline_atList(void* ptr, int i)
 {
 	return ({ QPointF tmpValue = static_cast<QVector<QPointF>*>(ptr)->at(i); new QPointF(tmpValue.x(), tmpValue.y()); });
@@ -9770,6 +9780,11 @@ void* QIdentityProxyModel_MapToSourceDefault(void* ptr, void* proxyIndex)
 	return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
 }
 
+struct QtCore_PackedList QIdentityProxyModel_Match(void* ptr, void* start, int role, void* value, int hits, long long flags)
+{
+	return ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(static_cast<QIdentityProxyModel*>(ptr)->match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 void* QIdentityProxyModel_Parent(void* ptr, void* child)
 {
 	return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->parent(*static_cast<QModelIndex*>(child)));
@@ -18586,6 +18601,11 @@ void* QSortFilterProxyModel_MapToSourceDefault(void* ptr, void* proxyIndex)
 	return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
 }
 
+struct QtCore_PackedList QSortFilterProxyModel_Match(void* ptr, void* start, int role, void* value, int hits, long long flags)
+{
+	return ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(static_cast<QSortFilterProxyModel*>(ptr)->match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 struct QtCore_PackedString QSortFilterProxyModel_MimeTypes(void* ptr)
 {
 	return ({ QByteArray t6364b8 = static_cast<QSortFilterProxyModel*>(ptr)->mimeTypes().join("|").toUtf8(); QtCore_PackedString { const_cast<char*>(t6364b8.prepend("WHITESPACE").constData()+10), t6364b8.size()-10 }; });
@@ -21359,6 +21379,11 @@ public:
 	 ~MyQTextCodec() { callbackQTextCodec_DestroyQTextCodec(this); };
 };
 
+struct QtCore_PackedList QTextCodec_Aliases(void* ptr)
+{
+	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(static_cast<QTextCodec*>(ptr)->aliases()); QtCore_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 struct QtCore_PackedList QTextCodec_QTextCodec_AvailableCodecs()
 {
 	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QTextCodec::availableCodecs()); QtCore_PackedList { tmpValue, tmpValue->size() }; });
@@ -23484,6 +23509,11 @@ void QUrl_DestroyQUrl(void* ptr)
 	static_cast<QUrl*>(ptr)->~QUrl();
 }
 
+void* QUrl_allEncodedQueryItemValues_atList(void* ptr, int i)
+{
+	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
+}
+
 void* QUrl_fromStringList_atList(void* ptr, int i)
 {
 	return new QUrl(static_cast<QList<QUrl>*>(ptr)->at(i));

core/core.go

@@ -2670,6 +2670,19 @@ func (ptr *QAbstractItemModel) InsertRowsDefault(row int, count int, parent QMod
 	return false
 }
 
+func (ptr *QAbstractItemModel) Match(start QModelIndex_ITF, role int, value QVariant_ITF, hits int, flags Qt__MatchFlag) []*QModelIndex {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
+			var out = make([]*QModelIndex, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQAbstractItemModelFromPointer(l.data).match_atList(i)
+			}
+			return out
+		}(C.QAbstractItemModel_Match(ptr.Pointer(), PointerFromQModelIndex(start), C.int(int32(role)), PointerFromQVariant(value), C.int(int32(hits)), C.longlong(flags)))
+	}
+	return nil
+}
+
 //export callbackQAbstractItemModel_MimeTypes
 func callbackQAbstractItemModel_MimeTypes(ptr unsafe.Pointer) *C.char {
 
@@ -18620,6 +18633,15 @@ func (ptr *QEasingCurve) DestroyQEasingCurve() {
 	}
 }
 
+func (ptr *QEasingCurve) cubicBezierSpline_atList(i int) *QPointF {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQPointFFromPointer(C.QEasingCurve_cubicBezierSpline_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*QPointF).DestroyQPointF)
+		return tmpValue
+	}
+	return nil
+}
+
 func (ptr *QEasingCurve) toCubicSpline_atList(i int) *QPointF {
 	if ptr.Pointer() != nil {
 		var tmpValue = NewQPointFFromPointer(C.QEasingCurve_toCubicSpline_atList(ptr.Pointer(), C.int(int32(i))))
@@ -27613,6 +27635,19 @@ func (ptr *QIdentityProxyModel) MapToSourceDefault(proxyIndex QModelIndex_ITF) *
 	return nil
 }
 
+func (ptr *QIdentityProxyModel) Match(start QModelIndex_ITF, role int, value QVariant_ITF, hits int, flags Qt__MatchFlag) []*QModelIndex {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
+			var out = make([]*QModelIndex, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQIdentityProxyModelFromPointer(l.data).match_atList(i)
+			}
+			return out
+		}(C.QIdentityProxyModel_Match(ptr.Pointer(), PointerFromQModelIndex(start), C.int(int32(role)), PointerFromQVariant(value), C.int(int32(hits)), C.longlong(flags)))
+	}
+	return nil
+}
+
 //export callbackQIdentityProxyModel_Parent
 func callbackQIdentityProxyModel_Parent(ptr unsafe.Pointer, child unsafe.Pointer) unsafe.Pointer {
 
@@ -51858,6 +51893,19 @@ func (ptr *QSortFilterProxyModel) MapToSourceDefault(proxyIndex QModelIndex_ITF)
 	return nil
 }
 
+func (ptr *QSortFilterProxyModel) Match(start QModelIndex_ITF, role int, value QVariant_ITF, hits int, flags Qt__MatchFlag) []*QModelIndex {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtCore_PackedList) []*QModelIndex {
+			var out = make([]*QModelIndex, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQSortFilterProxyModelFromPointer(l.data).match_atList(i)
+			}
+			return out
+		}(C.QSortFilterProxyModel_Match(ptr.Pointer(), PointerFromQModelIndex(start), C.int(int32(role)), PointerFromQVariant(value), C.int(int32(hits)), C.longlong(flags)))
+	}
+	return nil
+}
+
 //export callbackQSortFilterProxyModel_MimeTypes
 func callbackQSortFilterProxyModel_MimeTypes(ptr unsafe.Pointer) *C.char {
 
@@ -59287,6 +59335,19 @@ func NewQTextCodecFromPointer(ptr unsafe.Pointer) *QTextCodec {
 	n.SetPointer(ptr)
 	return n
 }
+func (ptr *QTextCodec) Aliases() []*QByteArray {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtCore_PackedList) []*QByteArray {
+			var out = make([]*QByteArray, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQTextCodecFromPointer(l.data).aliases_atList(i)
+			}
+			return out
+		}(C.QTextCodec_Aliases(ptr.Pointer()))
+	}
+	return nil
+}
+
 func QTextCodec_AvailableCodecs() []*QByteArray {
 	return func(l C.struct_QtCore_PackedList) []*QByteArray {
 		var out = make([]*QByteArray, int(l.len))
@@ -64908,6 +64969,15 @@ func (ptr *QUrl) DestroyQUrl() {
 	}
 }
 
+func (ptr *QUrl) allEncodedQueryItemValues_atList(i int) *QByteArray {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQByteArrayFromPointer(C.QUrl_allEncodedQueryItemValues_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*QByteArray).DestroyQByteArray)
+		return tmpValue
+	}
+	return nil
+}
+
 func (ptr *QUrl) fromStringList_atList(i int) *QUrl {
 	if ptr.Pointer() != nil {
 		var tmpValue = NewQUrlFromPointer(C.QUrl_fromStringList_atList(ptr.Pointer(), C.int(int32(i))))

core/core.h

@@ -171,6 +171,7 @@ char QAbstractItemModel_InsertColumnsDefault(void* ptr, int column, int count, v
 char QAbstractItemModel_InsertRow(void* ptr, int row, void* parent);
 char QAbstractItemModel_InsertRows(void* ptr, int row, int count, void* parent);
 char QAbstractItemModel_InsertRowsDefault(void* ptr, int row, int count, void* parent);
+struct QtCore_PackedList QAbstractItemModel_Match(void* ptr, void* start, int role, void* value, int hits, long long flags);
 struct QtCore_PackedString QAbstractItemModel_MimeTypes(void* ptr);
 struct QtCore_PackedString QAbstractItemModel_MimeTypesDefault(void* ptr);
 void QAbstractItemModel_ConnectModelAboutToBeReset(void* ptr);
@@ -1281,6 +1282,7 @@ struct QtCore_PackedList QEasingCurve_ToCubicSpline(void* ptr);
 long long QEasingCurve_Type(void* ptr);
 double QEasingCurve_ValueForProgress(void* ptr, double progress);
 void QEasingCurve_DestroyQEasingCurve(void* ptr);
+void* QEasingCurve_cubicBezierSpline_atList(void* ptr, int i);
 void* QEasingCurve_toCubicSpline_atList(void* ptr, int i);
 void* QElapsedTimer_NewQElapsedTimer();
 char QElapsedTimer_HasExpired(void* ptr, long long timeout);
@@ -1807,6 +1809,7 @@ void* QIdentityProxyModel_MapSelectionToSource(void* ptr, void* selection);
 void* QIdentityProxyModel_MapSelectionToSourceDefault(void* ptr, void* selection);
 void* QIdentityProxyModel_MapToSource(void* ptr, void* proxyIndex);
 void* QIdentityProxyModel_MapToSourceDefault(void* ptr, void* proxyIndex);
+struct QtCore_PackedList QIdentityProxyModel_Match(void* ptr, void* start, int role, void* value, int hits, long long flags);
 void* QIdentityProxyModel_Parent(void* ptr, void* child);
 void* QIdentityProxyModel_ParentDefault(void* ptr, void* child);
 char QIdentityProxyModel_RemoveColumns(void* ptr, int column, int count, void* parent);
@@ -3501,6 +3504,7 @@ void* QSortFilterProxyModel_MapSelectionToSource(void* ptr, void* proxySelection
 void* QSortFilterProxyModel_MapSelectionToSourceDefault(void* ptr, void* proxySelection);
 void* QSortFilterProxyModel_MapToSource(void* ptr, void* proxyIndex);
 void* QSortFilterProxyModel_MapToSourceDefault(void* ptr, void* proxyIndex);
+struct QtCore_PackedList QSortFilterProxyModel_Match(void* ptr, void* start, int role, void* value, int hits, long long flags);
 struct QtCore_PackedString QSortFilterProxyModel_MimeTypes(void* ptr);
 struct QtCore_PackedString QSortFilterProxyModel_MimeTypesDefault(void* ptr);
 void* QSortFilterProxyModel_Parent(void* ptr, void* child);
@@ -4006,6 +4010,7 @@ int QTextBoundaryFinder_ToPreviousBoundary(void* ptr);
 void QTextBoundaryFinder_ToStart(void* ptr);
 long long QTextBoundaryFinder_Type(void* ptr);
 void QTextBoundaryFinder_DestroyQTextBoundaryFinder(void* ptr);
+struct QtCore_PackedList QTextCodec_Aliases(void* ptr);
 struct QtCore_PackedList QTextCodec_QTextCodec_AvailableCodecs();
 char QTextCodec_CanEncode(void* ptr, void* ch);
 char QTextCodec_CanEncode2(void* ptr, char* s);
@@ -4412,6 +4417,7 @@ struct QtCore_PackedString QUrl_Url(void* ptr, long long options);
 struct QtCore_PackedString QUrl_UserInfo(void* ptr, long long options);
 struct QtCore_PackedString QUrl_UserName(void* ptr, long long options);
 void QUrl_DestroyQUrl(void* ptr);
+void* QUrl_allEncodedQueryItemValues_atList(void* ptr, int i);
 void* QUrl_fromStringList_atList(void* ptr, int i);
 void* QUrlQuery_NewQUrlQuery();
 void* QUrlQuery_NewQUrlQuery3(char* queryString);

dbus/dbus.cpp

@@ -168,6 +168,11 @@ void* QDBusAbstractInterface_AsyncCall(void* ptr, char* method, void* arg1, void
 	return new QDBusPendingCall(static_cast<QDBusAbstractInterface*>(ptr)->asyncCall(QString(method), *static_cast<QVariant*>(arg1), *static_cast<QVariant*>(arg2), *static_cast<QVariant*>(arg3), *static_cast<QVariant*>(arg4), *static_cast<QVariant*>(arg5), *static_cast<QVariant*>(arg6), *static_cast<QVariant*>(arg7), *static_cast<QVariant*>(arg8)));
 }
 
+void* QDBusAbstractInterface_Call2(void* ptr, long long mode, char* method, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6, void* arg7, void* arg8)
+{
+	return new QDBusMessage(static_cast<QDBusAbstractInterface*>(ptr)->call(static_cast<QDBus::CallMode>(mode), QString(method), *static_cast<QVariant*>(arg1), *static_cast<QVariant*>(arg2), *static_cast<QVariant*>(arg3), *static_cast<QVariant*>(arg4), *static_cast<QVariant*>(arg5), *static_cast<QVariant*>(arg6), *static_cast<QVariant*>(arg7), *static_cast<QVariant*>(arg8)));
+}
+
 void* QDBusAbstractInterface_Call(void* ptr, char* method, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6, void* arg7, void* arg8)
 {
 	return new QDBusMessage(static_cast<QDBusAbstractInterface*>(ptr)->call(QString(method), *static_cast<QVariant*>(arg1), *static_cast<QVariant*>(arg2), *static_cast<QVariant*>(arg3), *static_cast<QVariant*>(arg4), *static_cast<QVariant*>(arg5), *static_cast<QVariant*>(arg6), *static_cast<QVariant*>(arg7), *static_cast<QVariant*>(arg8)));
@@ -468,6 +473,11 @@ void* QDBusConnection_AsyncCall(void* ptr, void* message, int timeout)
 	return new QDBusPendingCall(static_cast<QDBusConnection*>(ptr)->asyncCall(*static_cast<QDBusMessage*>(message), timeout));
 }
 
+void* QDBusConnection_Call(void* ptr, void* message, long long mode, int timeout)
+{
+	return new QDBusMessage(static_cast<QDBusConnection*>(ptr)->call(*static_cast<QDBusMessage*>(message), static_cast<QDBus::CallMode>(mode), timeout));
+}
+
 char QDBusConnection_CallWithCallback(void* ptr, void* message, void* receiver, char* returnMethod, char* errorMethod, int timeout)
 {
 	return static_cast<QDBusConnection*>(ptr)->callWithCallback(*static_cast<QDBusMessage*>(message), static_cast<QObject*>(receiver), const_cast<const char*>(returnMethod), const_cast<const char*>(errorMethod), timeout);

dbus/dbus.go

@@ -22,6 +22,59 @@ func cGoUnpackString(s C.struct_QtDBus_PackedString) string {
 	return C.GoStringN(s.data, C.int(s.len))
 }
 
+//QDBus::CallMode
+type QDBus__CallMode int64
+
+const (
+	QDBus__NoBlock      = QDBus__CallMode(0)
+	QDBus__Block        = QDBus__CallMode(1)
+	QDBus__BlockWithGui = QDBus__CallMode(2)
+	QDBus__AutoDetect   = QDBus__CallMode(3)
+)
+
+type QDBus struct {
+	ptr unsafe.Pointer
+}
+
+type QDBus_ITF interface {
+	QDBus_PTR() *QDBus
+}
+
+func (p *QDBus) QDBus_PTR() *QDBus {
+	return p
+}
+
+func (p *QDBus) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QDBus) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQDBus(ptr QDBus_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QDBus_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQDBusFromPointer(ptr unsafe.Pointer) *QDBus {
+	var n = new(QDBus)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QDBus) DestroyQDBus() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QDBusAbstractAdaptor struct {
 	core.QObject
 }
@@ -471,6 +524,17 @@ func (ptr *QDBusAbstractInterface) AsyncCall(method string, arg1 core.QVariant_I
 	return nil
 }
 
+func (ptr *QDBusAbstractInterface) Call2(mode QDBus__CallMode, method string, arg1 core.QVariant_ITF, arg2 core.QVariant_ITF, arg3 core.QVariant_ITF, arg4 core.QVariant_ITF, arg5 core.QVariant_ITF, arg6 core.QVariant_ITF, arg7 core.QVariant_ITF, arg8 core.QVariant_ITF) *QDBusMessage {
+	if ptr.Pointer() != nil {
+		var methodC = C.CString(method)
+		defer C.free(unsafe.Pointer(methodC))
+		var tmpValue = NewQDBusMessageFromPointer(C.QDBusAbstractInterface_Call2(ptr.Pointer(), C.longlong(mode), methodC, core.PointerFromQVariant(arg1), core.PointerFromQVariant(arg2), core.PointerFromQVariant(arg3), core.PointerFromQVariant(arg4), core.PointerFromQVariant(arg5), core.PointerFromQVariant(arg6), core.PointerFromQVariant(arg7), core.PointerFromQVariant(arg8)))
+		runtime.SetFinalizer(tmpValue, (*QDBusMessage).DestroyQDBusMessage)
+		return tmpValue
+	}
+	return nil
+}
+
 func (ptr *QDBusAbstractInterface) Call(method string, arg1 core.QVariant_ITF, arg2 core.QVariant_ITF, arg3 core.QVariant_ITF, arg4 core.QVariant_ITF, arg5 core.QVariant_ITF, arg6 core.QVariant_ITF, arg7 core.QVariant_ITF, arg8 core.QVariant_ITF) *QDBusMessage {
 	if ptr.Pointer() != nil {
 		var methodC = C.CString(method)
@@ -1258,6 +1322,15 @@ func (ptr *QDBusConnection) AsyncCall(message QDBusMessage_ITF, timeout int) *QD
 	return nil
 }
 
+func (ptr *QDBusConnection) Call(message QDBusMessage_ITF, mode QDBus__CallMode, timeout int) *QDBusMessage {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQDBusMessageFromPointer(C.QDBusConnection_Call(ptr.Pointer(), PointerFromQDBusMessage(message), C.longlong(mode), C.int(int32(timeout))))
+		runtime.SetFinalizer(tmpValue, (*QDBusMessage).DestroyQDBusMessage)
+		return tmpValue
+	}
+	return nil
+}
+
 func (ptr *QDBusConnection) CallWithCallback(message QDBusMessage_ITF, receiver core.QObject_ITF, returnMethod string, errorMethod string, timeout int) bool {
 	if ptr.Pointer() != nil {
 		var returnMethodC = C.CString(returnMethod)
@@ -5018,6 +5091,57 @@ func (ptr *QDBusUnixFileDescriptor) DestroyQDBusUnixFileDescriptor() {
 	}
 }
 
+//QDBusUtil::AllowEmptyFlag
+type QDBusUtil__AllowEmptyFlag int64
+
+const (
+	QDBusUtil__EmptyAllowed    = QDBusUtil__AllowEmptyFlag(0)
+	QDBusUtil__EmptyNotAllowed = QDBusUtil__AllowEmptyFlag(1)
+)
+
+type QDBusUtil struct {
+	ptr unsafe.Pointer
+}
+
+type QDBusUtil_ITF interface {
+	QDBusUtil_PTR() *QDBusUtil
+}
+
+func (p *QDBusUtil) QDBusUtil_PTR() *QDBusUtil {
+	return p
+}
+
+func (p *QDBusUtil) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QDBusUtil) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQDBusUtil(ptr QDBusUtil_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QDBusUtil_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQDBusUtilFromPointer(ptr unsafe.Pointer) *QDBusUtil {
+	var n = new(QDBusUtil)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QDBusUtil) DestroyQDBusUtil() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QDBusVariant struct {
 	ptr unsafe.Pointer
 }

dbus/dbus.h

@@ -36,6 +36,7 @@ char QDBusAbstractAdaptor_EventFilterDefault(void* ptr, void* watched, void* eve
 void* QDBusAbstractAdaptor_MetaObject(void* ptr);
 void* QDBusAbstractAdaptor_MetaObjectDefault(void* ptr);
 void* QDBusAbstractInterface_AsyncCall(void* ptr, char* method, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6, void* arg7, void* arg8);
+void* QDBusAbstractInterface_Call2(void* ptr, long long mode, char* method, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6, void* arg7, void* arg8);
 void* QDBusAbstractInterface_Call(void* ptr, char* method, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6, void* arg7, void* arg8);
 void* QDBusAbstractInterface_Connection(void* ptr);
 struct QtDBus_PackedString QDBusAbstractInterface_Interface(void* ptr);
@@ -96,6 +97,7 @@ void* QDBusConnection_NewQDBusConnection2(void* other);
 void* QDBusConnection_NewQDBusConnection(char* name);
 struct QtDBus_PackedString QDBusConnection_BaseService(void* ptr);
 void* QDBusConnection_AsyncCall(void* ptr, void* message, int timeout);
+void* QDBusConnection_Call(void* ptr, void* message, long long mode, int timeout);
 char QDBusConnection_CallWithCallback(void* ptr, void* message, void* receiver, char* returnMethod, char* errorMethod, int timeout);
 char QDBusConnection_Connect(void* ptr, char* service, char* path, char* interfa, char* name, void* receiver, char* slot);
 char QDBusConnection_Connect2(void* ptr, char* service, char* path, char* interfa, char* name, char* signature, void* receiver, char* slot);

designer/designer.cpp

@@ -1250,6 +1250,11 @@ void QDesignerFormEditorInterface_DestroyQDesignerFormEditorInterfaceDefault(voi
 
 }
 
+void* QDesignerFormEditorInterface_pluginInstances_atList(void* ptr, int i)
+{
+	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
+}
+
 void QDesignerFormEditorInterface_TimerEvent(void* ptr, void* event)
 {
 	static_cast<QDesignerFormEditorInterface*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));

designer/designer.go

@@ -4297,6 +4297,17 @@ func (ptr *QDesignerFormEditorInterface) DestroyQDesignerFormEditorInterfaceDefa
 	}
 }
 
+func (ptr *QDesignerFormEditorInterface) pluginInstances_atList(i int) *core.QObject {
+	if ptr.Pointer() != nil {
+		var tmpValue = core.NewQObjectFromPointer(C.QDesignerFormEditorInterface_pluginInstances_atList(ptr.Pointer(), C.int(int32(i))))
+		if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
+			tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
+		}
+		return tmpValue
+	}
+	return nil
+}
+
 //export callbackQDesignerFormEditorInterface_TimerEvent
 func callbackQDesignerFormEditorInterface_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
 
@@ -20033,3 +20044,105 @@ func (ptr *QFormBuilder) SaveDefault(device core.QIODevice_ITF, widget widgets.Q
 		C.QFormBuilder_SaveDefault(ptr.Pointer(), core.PointerFromQIODevice(device), widgets.PointerFromQWidget(widget))
 	}
 }
+
+//qdesigner_internal::SpecialProperty
+type qdesigner_internal__SpecialProperty int64
+
+const (
+	qdesigner_internal__SP_None            = qdesigner_internal__SpecialProperty(0)
+	qdesigner_internal__SP_ObjectName      = qdesigner_internal__SpecialProperty(1)
+	qdesigner_internal__SP_LayoutName      = qdesigner_internal__SpecialProperty(2)
+	qdesigner_internal__SP_SpacerName      = qdesigner_internal__SpecialProperty(3)
+	qdesigner_internal__SP_WindowTitle     = qdesigner_internal__SpecialProperty(4)
+	qdesigner_internal__SP_MinimumSize     = qdesigner_internal__SpecialProperty(5)
+	qdesigner_internal__SP_MaximumSize     = qdesigner_internal__SpecialProperty(6)
+	qdesigner_internal__SP_Geometry        = qdesigner_internal__SpecialProperty(7)
+	qdesigner_internal__SP_Icon            = qdesigner_internal__SpecialProperty(8)
+	qdesigner_internal__SP_CurrentTabName  = qdesigner_internal__SpecialProperty(9)
+	qdesigner_internal__SP_CurrentItemName = qdesigner_internal__SpecialProperty(10)
+	qdesigner_internal__SP_CurrentPageName = qdesigner_internal__SpecialProperty(11)
+	qdesigner_internal__SP_AutoDefault     = qdesigner_internal__SpecialProperty(12)
+	qdesigner_internal__SP_Alignment       = qdesigner_internal__SpecialProperty(13)
+	qdesigner_internal__SP_Shortcut        = qdesigner_internal__SpecialProperty(14)
+	qdesigner_internal__SP_Orientation     = qdesigner_internal__SpecialProperty(15)
+)
+
+//qdesigner_internal::AuxiliaryItemDataRoles
+type qdesigner_internal__AuxiliaryItemDataRoles int64
+
+const (
+	qdesigner_internal__ItemFlagsShadowRole = qdesigner_internal__AuxiliaryItemDataRoles(0x13370551)
+)
+
+//qdesigner_internal::ContainerType
+type qdesigner_internal__ContainerType int64
+
+const (
+	qdesigner_internal__PageContainer   = qdesigner_internal__ContainerType(0)
+	qdesigner_internal__MdiContainer    = qdesigner_internal__ContainerType(1)
+	qdesigner_internal__WizardContainer = qdesigner_internal__ContainerType(2)
+)
+
+//qdesigner_internal::TextPropertyValidationMode
+type qdesigner_internal__TextPropertyValidationMode int64
+
+const (
+	qdesigner_internal__ValidationMultiLine       = qdesigner_internal__TextPropertyValidationMode(0)
+	qdesigner_internal__ValidationRichText        = qdesigner_internal__TextPropertyValidationMode(1)
+	qdesigner_internal__ValidationStyleSheet      = qdesigner_internal__TextPropertyValidationMode(2)
+	qdesigner_internal__ValidationSingleLine      = qdesigner_internal__TextPropertyValidationMode(3)
+	qdesigner_internal__ValidationObjectName      = qdesigner_internal__TextPropertyValidationMode(4)
+	qdesigner_internal__ValidationObjectNameScope = qdesigner_internal__TextPropertyValidationMode(5)
+	qdesigner_internal__ValidationURL             = qdesigner_internal__TextPropertyValidationMode(6)
+)
+
+//qdesigner_internal::IncludeType
+type qdesigner_internal__IncludeType int64
+
+const (
+	qdesigner_internal__IncludeLocal  = qdesigner_internal__IncludeType(0)
+	qdesigner_internal__IncludeGlobal = qdesigner_internal__IncludeType(1)
+)
+
+type qdesigner_internal struct {
+	ptr unsafe.Pointer
+}
+
+type qdesigner_internal_ITF interface {
+	qdesigner_internal_PTR() *qdesigner_internal
+}
+
+func (p *qdesigner_internal) qdesigner_internal_PTR() *qdesigner_internal {
+	return p
+}
+
+func (p *qdesigner_internal) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *qdesigner_internal) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQdesigner_internal(ptr qdesigner_internal_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.qdesigner_internal_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQdesigner_internalFromPointer(ptr unsafe.Pointer) *qdesigner_internal {
+	var n = new(qdesigner_internal)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *qdesigner_internal) Destroyqdesigner_internal() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}

designer/designer.h

@@ -216,6 +216,7 @@ void* QDesignerFormEditorInterface_TopLevel(void* ptr);
 void* QDesignerFormEditorInterface_WidgetBox(void* ptr);
 void QDesignerFormEditorInterface_DestroyQDesignerFormEditorInterface(void* ptr);
 void QDesignerFormEditorInterface_DestroyQDesignerFormEditorInterfaceDefault(void* ptr);
+void* QDesignerFormEditorInterface_pluginInstances_atList(void* ptr, int i);
 void QDesignerFormEditorInterface_TimerEvent(void* ptr, void* event);
 void QDesignerFormEditorInterface_TimerEventDefault(void* ptr, void* event);
 void QDesignerFormEditorInterface_ChildEvent(void* ptr, void* event);

gui/gui.cpp

@@ -5885,6 +5885,11 @@ void QIconEngine_AddPixmapDefault(void* ptr, void* pixmap, long long mode, long
 	static_cast<QIconEngine*>(ptr)->QIconEngine::addPixmap(*static_cast<QPixmap*>(pixmap), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
 }
 
+struct QtGui_PackedList QIconEngine_AvailableSizes(void* ptr, long long mode, long long state)
+{
+	return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QIconEngine*>(ptr)->availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 void* QIconEngine_Clone(void* ptr)
 {
 	return static_cast<QIconEngine*>(ptr)->clone();
@@ -12799,6 +12804,16 @@ void QPicture_DestroyQPicture(void* ptr)
 	static_cast<QPicture*>(ptr)->~QPicture();
 }
 
+void* QPicture_inputFormats_atList(void* ptr, int i)
+{
+	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
+}
+
+void* QPicture_outputFormats_atList(void* ptr, int i)
+{
+	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
+}
+
 int QPicture_Metric(void* ptr, long long metric)
 {
 	return static_cast<QPicture*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));

gui/gui.go

@@ -8791,6 +8791,49 @@ func (ptr *QContextMenuEvent) SetP(vqp core.QPoint_ITF) {
 	}
 }
 
+type QCss struct {
+	ptr unsafe.Pointer
+}
+
+type QCss_ITF interface {
+	QCss_PTR() *QCss
+}
+
+func (p *QCss) QCss_PTR() *QCss {
+	return p
+}
+
+func (p *QCss) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QCss) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQCss(ptr QCss_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QCss_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQCssFromPointer(ptr unsafe.Pointer) *QCss {
+	var n = new(QCss)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QCss) DestroyQCss() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QCursor struct {
 	ptr unsafe.Pointer
 }
@@ -15388,6 +15431,19 @@ func (ptr *QIconEngine) AddPixmapDefault(pixmap QPixmap_ITF, mode QIcon__Mode, s
 	}
 }
 
+func (ptr *QIconEngine) AvailableSizes(mode QIcon__Mode, state QIcon__State) []*core.QSize {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtGui_PackedList) []*core.QSize {
+			var out = make([]*core.QSize, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQIconEngineFromPointer(l.data).availableSizes_atList(i)
+			}
+			return out
+		}(C.QIconEngine_AvailableSizes(ptr.Pointer(), C.longlong(mode), C.longlong(state)))
+	}
+	return nil
+}
+
 //export callbackQIconEngine_Clone
 func callbackQIconEngine_Clone(ptr unsafe.Pointer) unsafe.Pointer {
 
@@ -32950,6 +33006,59 @@ func (ptr *QPalette) DestroyQPalette() {
 	}
 }
 
+//QPdf::PathFlags
+type QPdf__PathFlags int64
+
+const (
+	QPdf__ClipPath          = QPdf__PathFlags(0)
+	QPdf__FillPath          = QPdf__PathFlags(1)
+	QPdf__StrokePath        = QPdf__PathFlags(2)
+	QPdf__FillAndStrokePath = QPdf__PathFlags(3)
+)
+
+type QPdf struct {
+	ptr unsafe.Pointer
+}
+
+type QPdf_ITF interface {
+	QPdf_PTR() *QPdf
+}
+
+func (p *QPdf) QPdf_PTR() *QPdf {
+	return p
+}
+
+func (p *QPdf) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QPdf) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQPdf(ptr QPdf_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QPdf_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQPdfFromPointer(ptr unsafe.Pointer) *QPdf {
+	var n = new(QPdf)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QPdf) DestroyQPdf() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QPdfWriter struct {
 	core.QObject
 	QPagedPaintDevice
@@ -34033,6 +34142,24 @@ func (ptr *QPicture) DestroyQPicture() {
 	}
 }
 
+func (ptr *QPicture) inputFormats_atList(i int) *core.QByteArray {
+	if ptr.Pointer() != nil {
+		var tmpValue = core.NewQByteArrayFromPointer(C.QPicture_inputFormats_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
+		return tmpValue
+	}
+	return nil
+}
+
+func (ptr *QPicture) outputFormats_atList(i int) *core.QByteArray {
+	if ptr.Pointer() != nil {
+		var tmpValue = core.NewQByteArrayFromPointer(C.QPicture_outputFormats_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
+		return tmpValue
+	}
+	return nil
+}
+
 //export callbackQPicture_Metric
 func callbackQPicture_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
 

gui/gui.h

@@ -1092,6 +1092,7 @@ void QIconEngine_AddFile(void* ptr, char* fileName, void* size, long long mode,
 void QIconEngine_AddFileDefault(void* ptr, char* fileName, void* size, long long mode, long long state);
 void QIconEngine_AddPixmap(void* ptr, void* pixmap, long long mode, long long state);
 void QIconEngine_AddPixmapDefault(void* ptr, void* pixmap, long long mode, long long state);
+struct QtGui_PackedList QIconEngine_AvailableSizes(void* ptr, long long mode, long long state);
 void* QIconEngine_Clone(void* ptr);
 struct QtGui_PackedString QIconEngine_IconName(void* ptr);
 struct QtGui_PackedString QIconEngine_IconNameDefault(void* ptr);
@@ -2417,6 +2418,8 @@ void QPicture_SetData(void* ptr, char* data, unsigned int size);
 void QPicture_SetDataDefault(void* ptr, char* data, unsigned int size);
 void QPicture_Swap(void* ptr, void* other);
 void QPicture_DestroyQPicture(void* ptr);
+void* QPicture_inputFormats_atList(void* ptr, int i);
+void* QPicture_outputFormats_atList(void* ptr, int i);
 int QPicture_Metric(void* ptr, long long metric);
 int QPicture_MetricDefault(void* ptr, long long metric);
 void* QPicture_PaintEngine(void* ptr);

internal/binding/converter/body_input_cpp.go

@@ -46,7 +46,7 @@ func CppInputParametersForSlotArguments(function *parser.Function, parameter *pa
 			return fmt.Sprintf("%v*", CleanValue(parameter.Value))
 		}
 
-	case isEnum(function.Class(), parameter.Value):
+	case isEnum(function.ClassName(), parameter.Value):
 		{
 			if function.Meta == parser.SLOT && function.SignalMode == "" && CleanValue(parameter.Value) == "Qt::Alignment" {
 				return CleanValue(parameter.Value)
@@ -66,7 +66,7 @@ func CppInputParametersForSignalConnect(function *parser.Function) string {
 	var input = make([]string, len(function.Parameters))
 
 	for i, parameter := range function.Parameters {
-		if isEnum(function.Class(), parameter.Value) {
+		if isEnum(function.ClassName(), parameter.Value) {
 			input[i] = cppEnum(function, parameter.Value, true)
 		} else {
 			input[i] = parameter.Value
@@ -81,7 +81,7 @@ func CppInputParametersForCallbackHeader(function *parser.Function) string {
 	var input = make([]string, len(function.Parameters))
 
 	for i, parameter := range function.Parameters {
-		if isEnum(function.Class(), parameter.Value) {
+		if isEnum(function.ClassName(), parameter.Value) {
 			input[i] = fmt.Sprintf("%v %v", cppEnum(function, parameter.Value, true), cleanName(parameter.Name, parameter.Value))
 		} else {
 			input[i] = fmt.Sprintf("%v %v", parameter.Value, cleanName(parameter.Name, parameter.Value))
@@ -99,13 +99,13 @@ func CppInputParametersForCallbackBody(function *parser.Function) string {
 		input[0] = fmt.Sprintf("const_cast<%v%v*>(this)",
 
 			func() string {
-				if parser.ClassMap[function.Class()].Module == parser.MOC {
+				if parser.CurrentState.ClassMap[function.ClassName()].Module == parser.MOC {
 					return ""
 				}
 				return "My"
 			}(),
 
-			function.Class())
+			function.ClassName())
 
 	} else {
 		input[0] = "this"

internal/binding/converter/enum.go

@@ -28,7 +28,7 @@ func GoEnum(n string, v string, e *parser.Enum) string {
 
 	case err != nil:
 		{
-			if c, exists := parser.ClassMap[class(goEnum(e, v))]; exists && module(c.Module) != module(e) && module(c.Module) != "" {
+			if c, exists := parser.CurrentState.ClassMap[class(goEnum(e, v))]; exists && module(c.Module) != module(e) && module(c.Module) != "" {
 				return fmt.Sprintf("%v.%v", module(c.Module), goEnum(e, v))
 			}
 			return goEnum(e, v)

internal/binding/converter/header.go

@@ -11,7 +11,7 @@ import (
 func GoHeaderName(f *parser.Function) string {
 
 	if f.SignalMode == parser.CALLBACK {
-		return fmt.Sprintf("callback%v_%v%v", f.Class(), strings.Replace(strings.Title(f.Name), parser.TILDE, "Destroy", -1), f.OverloadNumber)
+		return fmt.Sprintf("callback%v_%v%v", f.ClassName(), strings.Replace(strings.Title(f.Name), parser.TILDE, "Destroy", -1), f.OverloadNumber)
 	}
 
 	var bb = new(bytes.Buffer)
@@ -80,7 +80,7 @@ func GoHeaderName(f *parser.Function) string {
 }
 
 func CppHeaderName(f *parser.Function) string {
-	return fmt.Sprintf("%v_%v", f.Class(), GoHeaderName(f))
+	return fmt.Sprintf("%v_%v", f.ClassName(), GoHeaderName(f))
 }
 
 func GoHeaderOutput(f *parser.Function) string {

internal/binding/converter/helper.go

@@ -16,7 +16,7 @@ func module(input interface{}) string {
 	switch input.(type) {
 	case *parser.Enum, *parser.Function:
 		{
-			return module(parser.ClassMap[class(input)].Module)
+			return module(parser.CurrentState.ClassMap[class(input)].Module)
 		}
 
 	case string:
@@ -96,7 +96,7 @@ func isClass(value string) bool {
 		return isClass(strings.Split(value, ".")[1])
 	}
 
-	var _, exists = parser.ClassMap[value]
+	var _, exists = parser.CurrentState.ClassMap[value]
 	return exists
 }
 
@@ -112,7 +112,7 @@ func isEnum(class, value string) bool {
 func findEnum(className, value string, byValue bool) (string, string) {
 
 	//look in given class
-	if c, exists := parser.ClassMap[class(value)]; exists {
+	if c, exists := parser.CurrentState.ClassMap[class(value)]; exists {
 		for _, e := range c.Enums {
 			if outE, outT := findEnumH(e, value, byValue); outE != "" {
 				return outE, outT
@@ -121,7 +121,7 @@ func findEnum(className, value string, byValue bool) (string, string) {
 	}
 
 	//look in same class
-	if c, exists := parser.ClassMap[className]; exists {
+	if c, exists := parser.CurrentState.ClassMap[className]; exists {
 		for _, e := range c.Enums {
 			if outE, outT := findEnumH(e, value, byValue); outE != "" {
 				return outE, outT
@@ -130,9 +130,9 @@ func findEnum(className, value string, byValue bool) (string, string) {
 	}
 
 	//look in super classes
-	if c, exists := parser.ClassMap[className]; exists {
+	if c, exists := parser.CurrentState.ClassMap[className]; exists {
 		for _, s := range c.GetAllBases() {
-			if sc, exists := parser.ClassMap[s]; exists {
+			if sc, exists := parser.CurrentState.ClassMap[s]; exists {
 				for _, e := range sc.Enums {
 					if outE, outT := findEnumH(e, value, byValue); outE != "" {
 						return outE, outT
@@ -143,8 +143,8 @@ func findEnum(className, value string, byValue bool) (string, string) {
 	}
 
 	//look in namespaces
-	for m := range parser.SubnamespaceMap {
-		if c, exists := parser.ClassMap[m]; exists {
+	for m := range parser.CurrentState.EnumMap {
+		if c, exists := parser.CurrentState.ClassMap[m]; exists {
 			for _, e := range c.Enums {
 				if outE, outT := findEnumH(e, value, byValue); outE != "" {
 					return outE, outT
@@ -266,7 +266,7 @@ func cppEnumExact(value, outE, outT string) string {
 
 func IsPrivateSignal(f *parser.Function) bool {
 
-	if parser.ClassMap[f.Class()].Module == "QtCore" {
+	if parser.CurrentState.ClassMap[f.ClassName()].Module == "QtCore" {
 
 		var (
 			fData string
@@ -281,24 +281,24 @@ func IsPrivateSignal(f *parser.Function) bool {
 		switch runtime.GOOS {
 		case "darwin":
 			{
-				fData = utils.Load(filepath.Join(utils.QT_DARWIN_DIR(), "lib", fmt.Sprintf("%v.framework", strings.Title(parser.ClassMap[f.Class()].DocModule)), "Versions", "5", "Headers", fPath))
+				fData = utils.Load(filepath.Join(utils.QT_DARWIN_DIR(), "lib", fmt.Sprintf("%v.framework", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].DocModule)), "Versions", "5", "Headers", fPath))
 			}
 
 		case "windows":
 			{
 				if utils.UseMsys2() {
-					fData = utils.Load(filepath.Join(utils.QT_MSYS2_DIR(), "include", strings.Title(parser.ClassMap[f.Class()].DocModule), fPath))
+					fData = utils.Load(filepath.Join(utils.QT_MSYS2_DIR(), "include", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].DocModule), fPath))
 				} else {
-					fData = utils.Load(filepath.Join(utils.QT_DIR(), "5.7", "mingw53_32", "include", strings.Title(parser.ClassMap[f.Class()].DocModule), fPath))
+					fData = utils.Load(filepath.Join(utils.QT_DIR(), "5.7", "mingw53_32", "include", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].DocModule), fPath))
 				}
 			}
 
 		case "linux":
 			{
 				if utils.UsePkgConfig() {
-					fData = utils.Load(filepath.Join(strings.TrimSpace(utils.RunCmd(exec.Command("pkg-config", "--variable=includedir", "Qt5Core"), "convert.IsPrivateSignal_includeDir")), strings.Title(parser.ClassMap[f.Class()].DocModule), fPath))
+					fData = utils.Load(filepath.Join(strings.TrimSpace(utils.RunCmd(exec.Command("pkg-config", "--variable=includedir", "Qt5Core"), "convert.IsPrivateSignal_includeDir")), strings.Title(parser.CurrentState.ClassMap[f.ClassName()].DocModule), fPath))
 				} else {
-					fData = utils.Load(filepath.Join(utils.QT_DIR(), "5.7", "gcc_64", "include", strings.Title(parser.ClassMap[f.Class()].DocModule), fPath))
+					fData = utils.Load(filepath.Join(utils.QT_DIR(), "5.7", "gcc_64", "include", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].DocModule), fPath))
 				}
 			}
 		}
@@ -314,7 +314,7 @@ func IsPrivateSignal(f *parser.Function) bool {
 			}
 		}
 
-		utils.Log.Debugln("converter.IsPrivateSignal", f.Class())
+		utils.Log.Debugln("converter.IsPrivateSignal", f.ClassName())
 	}
 
 	return false

internal/binding/converter/input.go

@@ -141,15 +141,15 @@ func goInput(name, value string, f *parser.Function) string {
 	}
 
 	switch {
-	case isEnum(f.Class(), value):
+	case isEnum(f.ClassName(), value):
 		{
 			return fmt.Sprintf("C.longlong(%v)", name)
 		}
 
 	case isClass(value):
 		{
-			if m := module(parser.ClassMap[value].Module); m != module(f) {
-				if parser.ClassMap[f.Class()].WeakLink[parser.ClassMap[value].Module] {
+			if m := module(parser.CurrentState.ClassMap[value].Module); m != module(f) {
+				if _, exists := parser.CurrentState.ClassMap[f.ClassName()].WeakLink[parser.CurrentState.ClassMap[value].Module]; exists {
 					return name
 				}
 				return fmt.Sprintf("%v.PointerFrom%v(%v)", m, strings.Title(value), name)
@@ -311,7 +311,7 @@ func cppInput(name, value string, f *parser.Function) string {
 	}
 
 	switch {
-	case isEnum(f.Class(), value):
+	case isEnum(f.ClassName(), value):
 		{
 			if !strings.Contains(vOld, "*") {
 				if f.Meta == parser.SLOT && f.SignalMode == "" && value == "Qt::Alignment" {
@@ -327,8 +327,8 @@ func cppInput(name, value string, f *parser.Function) string {
 				break
 			}
 
-			if parser.ClassMap[value].Fullname != "" {
-				value = parser.ClassMap[value].Fullname
+			if parser.CurrentState.ClassMap[value].Fullname != "" {
+				value = parser.CurrentState.ClassMap[value].Fullname
 			}
 
 			if strings.Contains(vOld, "*") {

internal/binding/converter/output.go

@@ -121,10 +121,10 @@ func goOutput(name, value string, f *parser.Function) string {
 	}
 
 	switch {
-	case isEnum(f.Class(), value):
+	case isEnum(f.ClassName(), value):
 		{
-			if c, exists := parser.ClassMap[class(cppEnum(f, value, false))]; exists && module(c.Module) != module(f) && module(c.Module) != "" {
-				if parser.ClassMap[f.Class()].WeakLink[c.Module] {
+			if c, exists := parser.CurrentState.ClassMap[class(cppEnum(f, value, false))]; exists && module(c.Module) != module(f) && module(c.Module) != "" {
+				if _, exists := parser.CurrentState.ClassMap[f.ClassName()].WeakLink[c.Module]; exists {
 					return fmt.Sprintf("int64(%v)", name)
 				}
 				return fmt.Sprintf("%v.%v(%v)", module(c.Module), goEnum(f, value), name)
@@ -134,8 +134,8 @@ func goOutput(name, value string, f *parser.Function) string {
 
 	case isClass(value):
 		{
-			if m := module(parser.ClassMap[value].Module); m != module(f) {
-				if parser.ClassMap[f.Class()].WeakLink[parser.ClassMap[value].Module] {
+			if m := module(parser.CurrentState.ClassMap[value].Module); m != module(f) {
+				if _, exists := parser.CurrentState.ClassMap[f.ClassName()].WeakLink[parser.CurrentState.ClassMap[value].Module]; exists {
 					return fmt.Sprintf("unsafe.Pointer(%v)", name)
 				}
 				return fmt.Sprintf("%v.New%vFromPointer(%v)", m, strings.Title(value), name)
@@ -146,7 +146,7 @@ func goOutput(name, value string, f *parser.Function) string {
 
 	case parser.IsPackedList(value):
 		{
-			return fmt.Sprintf("func(l C.struct_%v_PackedList)%v{var out = make(%v, int(l.len))\nfor i:=0;i<int(l.len);i++{ out[i] = New%vFromPointer(l.data).%v_atList(i) }\nreturn out}(%v)", strings.Title(parser.ClassMap[f.Class()].Module), goType(f, value), goType(f, value), f.Class(), f.Name, name)
+			return fmt.Sprintf("func(l C.struct_%v_PackedList)%v{var out = make(%v, int(l.len))\nfor i:=0;i<int(l.len);i++{ out[i] = New%vFromPointer(l.data).%v_atList(i) }\nreturn out}(%v)", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), goType(f, value), goType(f, value), f.ClassName(), f.Name, name)
 		}
 	}
 
@@ -231,7 +231,7 @@ func goOutputFailed(value string, f *parser.Function) string {
 	}
 
 	switch {
-	case isEnum(f.Class(), value):
+	case isEnum(f.ClassName(), value):
 		{
 			return "0"
 		}
@@ -344,10 +344,10 @@ func cgoOutput(name, value string, f *parser.Function) string {
 	}
 
 	switch {
-	case isEnum(f.Class(), value):
+	case isEnum(f.ClassName(), value):
 		{
-			if c, exists := parser.ClassMap[class(cppEnum(f, value, false))]; exists && module(c.Module) != module(f) && module(c.Module) != "" {
-				if parser.ClassMap[f.Class()].WeakLink[c.Module] {
+			if c, exists := parser.CurrentState.ClassMap[class(cppEnum(f, value, false))]; exists && module(c.Module) != module(f) && module(c.Module) != "" {
+				if _, exists := parser.CurrentState.ClassMap[f.ClassName()].WeakLink[c.Module]; exists {
 					return fmt.Sprintf("int64%v)", name)
 				}
 				return fmt.Sprintf("%v.%v(%v)", module(c.Module), goEnum(f, value), name)
@@ -357,8 +357,8 @@ func cgoOutput(name, value string, f *parser.Function) string {
 
 	case isClass(value):
 		{
-			if m := module(parser.ClassMap[value].Module); m != module(f) {
-				if parser.ClassMap[f.Class()].WeakLink[parser.ClassMap[value].Module] {
+			if m := module(parser.CurrentState.ClassMap[value].Module); m != module(f) {
+				if _, exists := parser.CurrentState.ClassMap[f.ClassName()].WeakLink[parser.CurrentState.ClassMap[value].Module]; exists {
 					return fmt.Sprintf("unsafe.Pointer(%v)", name)
 				}
 				return fmt.Sprintf("%v.New%vFromPointer(%v)", m, strings.Title(value), name)
@@ -426,52 +426,52 @@ func cppOutput(name, value string, f *parser.Function) string {
 					}
 				}
 
-				if fSizeVariable == "" && strings.Contains(strings.ToLower(f.Name), "data") && parser.ClassMap[f.Class()].HasFunctionWithName("size") {
-					fSizeVariable = fmt.Sprintf("static_cast<%v*>(ptr)->size()", f.Class())
+				if fSizeVariable == "" && strings.Contains(strings.ToLower(f.Name), "data") && parser.CurrentState.ClassMap[f.ClassName()].HasFunctionWithName("size") {
+					fSizeVariable = fmt.Sprintf("static_cast<%v*>(ptr)->size()", f.ClassName())
 				}
 
 				if strings.Contains(vOld, "const") {
 					if fSizeVariable != "" {
-						return fmt.Sprintf("%v_PackedString { const_cast<char*>(%v), %v }", strings.Title(parser.ClassMap[f.Class()].Module), name, fSizeVariable)
+						return fmt.Sprintf("%v_PackedString { const_cast<char*>(%v), %v }", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), name, fSizeVariable)
 					}
-					return fmt.Sprintf("%v_PackedString { const_cast<char*>(%v), -1 }", strings.Title(parser.ClassMap[f.Class()].Module), name)
+					return fmt.Sprintf("%v_PackedString { const_cast<char*>(%v), -1 }", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), name)
 				} else {
 					if fSizeVariable != "" {
-						return fmt.Sprintf("%v_PackedString { %v, %v }", strings.Title(parser.ClassMap[f.Class()].Module), name, fSizeVariable)
+						return fmt.Sprintf("%v_PackedString { %v, %v }", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), name, fSizeVariable)
 					}
-					return fmt.Sprintf("%v_PackedString { %v, -1 }", strings.Title(parser.ClassMap[f.Class()].Module), name)
+					return fmt.Sprintf("%v_PackedString { %v, -1 }", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), name)
 				}
 			}
 
-			return fmt.Sprintf("({ char t%v = %v; %v_PackedString { &t%v, -1 }; })", tHashName, name, strings.Title(parser.ClassMap[f.Class()].Module), tHashName)
+			return fmt.Sprintf("({ char t%v = %v; %v_PackedString { &t%v, -1 }; })", tHashName, name, strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), tHashName)
 		}
 
 	case "uchar", "quint8":
 		{
 			if strings.Contains(vOld, "*") {
 				if strings.Contains(vOld, "const") {
-					return fmt.Sprintf("({ char* t%v = static_cast<char*>(static_cast<void*>(const_cast<%v*>(%v))); %v_PackedString { t%v, -1 }; })", tHashName, value, name, strings.Title(parser.ClassMap[f.Class()].Module), tHashName)
+					return fmt.Sprintf("({ char* t%v = static_cast<char*>(static_cast<void*>(const_cast<%v*>(%v))); %v_PackedString { t%v, -1 }; })", tHashName, value, name, strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), tHashName)
 				}
-				return fmt.Sprintf("({ char* t%v = static_cast<char*>(static_cast<void*>(%v)); %v_PackedString { t%v, -1 }; })", tHashName, name, strings.Title(parser.ClassMap[f.Class()].Module), tHashName)
+				return fmt.Sprintf("({ char* t%v = static_cast<char*>(static_cast<void*>(%v)); %v_PackedString { t%v, -1 }; })", tHashName, name, strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), tHashName)
 			}
 
-			return fmt.Sprintf("({ %v pret%v = %v; char* t%v = static_cast<char*>(static_cast<void*>(&pret%v)); %v_PackedString { t%v, -1 }; })", vOld, tHashName, name, tHashName, tHashName, strings.Title(parser.ClassMap[f.Class()].Module), tHashName)
+			return fmt.Sprintf("({ %v pret%v = %v; char* t%v = static_cast<char*>(static_cast<void*>(&pret%v)); %v_PackedString { t%v, -1 }; })", vOld, tHashName, name, tHashName, tHashName, strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), tHashName)
 		}
 
 	case "QString":
 		{
 			if strings.Contains(vOld, "*") {
-				return fmt.Sprintf("({ QByteArray t%v = %v->toUtf8(); %v_PackedString { const_cast<char*>(t%v.prepend(\"WHITESPACE\").constData()+10), t%v.size()-10 }; })", tHashName, name, strings.Title(parser.ClassMap[f.Class()].Module), tHashName, tHashName)
+				return fmt.Sprintf("({ QByteArray t%v = %v->toUtf8(); %v_PackedString { const_cast<char*>(t%v.prepend(\"WHITESPACE\").constData()+10), t%v.size()-10 }; })", tHashName, name, strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), tHashName, tHashName)
 			}
-			return fmt.Sprintf("({ QByteArray t%v = %v.toUtf8(); %v_PackedString { const_cast<char*>(t%v.prepend(\"WHITESPACE\").constData()+10), t%v.size()-10 }; })", tHashName, name, strings.Title(parser.ClassMap[f.Class()].Module), tHashName, tHashName)
+			return fmt.Sprintf("({ QByteArray t%v = %v.toUtf8(); %v_PackedString { const_cast<char*>(t%v.prepend(\"WHITESPACE\").constData()+10), t%v.size()-10 }; })", tHashName, name, strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), tHashName, tHashName)
 		}
 
 	case "QStringList":
 		{
 			if strings.Contains(vOld, "*") {
-				return fmt.Sprintf("({ QByteArray t%v = %v->join(\"|\").toUtf8(); %v_PackedString { const_cast<char*>(t%v.prepend(\"WHITESPACE\").constData()+10), t%v.size()-10 }; })", tHashName, name, strings.Title(parser.ClassMap[f.Class()].Module), tHashName, tHashName)
+				return fmt.Sprintf("({ QByteArray t%v = %v->join(\"|\").toUtf8(); %v_PackedString { const_cast<char*>(t%v.prepend(\"WHITESPACE\").constData()+10), t%v.size()-10 }; })", tHashName, name, strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), tHashName, tHashName)
 			}
-			return fmt.Sprintf("({ QByteArray t%v = %v.join(\"|\").toUtf8(); %v_PackedString { const_cast<char*>(t%v.prepend(\"WHITESPACE\").constData()+10), t%v.size()-10 }; })", tHashName, name, strings.Title(parser.ClassMap[f.Class()].Module), tHashName, tHashName)
+			return fmt.Sprintf("({ QByteArray t%v = %v.join(\"|\").toUtf8(); %v_PackedString { const_cast<char*>(t%v.prepend(\"WHITESPACE\").constData()+10), t%v.size()-10 }; })", tHashName, name, strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module), tHashName, tHashName)
 		}
 
 	case
@@ -516,7 +516,7 @@ func cppOutput(name, value string, f *parser.Function) string {
 	}
 
 	switch {
-	case isEnum(f.Class(), value):
+	case isEnum(f.ClassName(), value):
 		{
 			return name
 		}
@@ -588,7 +588,7 @@ func cppOutput(name, value string, f *parser.Function) string {
 				}
 			}
 
-			for _, f := range parser.ClassMap[value].Functions {
+			for _, f := range parser.CurrentState.ClassMap[value].Functions {
 				if f.Meta == parser.CONSTRUCTOR {
 					switch len(f.Parameters) {
 					case 0:
@@ -614,10 +614,10 @@ func cppOutput(name, value string, f *parser.Function) string {
 	case parser.IsPackedList(value):
 		{
 			vOld = strings.Replace(vOld, " &", "", -1)
-			if con := parser.UnpackedList(value); parser.ClassMap[con] != nil && parser.ClassMap[con].Fullname != "" {
-				vOld = strings.Replace(value, con, parser.ClassMap[con].Fullname, -1)
+			if con := parser.UnpackedList(value); parser.CurrentState.ClassMap[con] != nil && parser.CurrentState.ClassMap[con].Fullname != "" {
+				vOld = strings.Replace(value, con, parser.CurrentState.ClassMap[con].Fullname, -1)
 			}
-			return fmt.Sprintf("({ %v* tmpValue = new %v(%v); %v_PackedList { tmpValue, tmpValue->size() }; })", vOld, vOld, name, strings.Title(parser.ClassMap[f.Class()].Module))
+			return fmt.Sprintf("({ %v* tmpValue = new %v(%v); %v_PackedList { tmpValue, tmpValue->size() }; })", vOld, vOld, name, strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module))
 		}
 	}
 

internal/binding/converter/type.go

@@ -126,17 +126,17 @@ func goType(f *parser.Function, value string) string {
 
 	case "...":
 		{
-			if parser.ClassMap[f.Class()].Module == "QtAndroidExtras" {
+			if parser.CurrentState.ClassMap[f.ClassName()].Module == "QtAndroidExtras" {
 				return "...interface{}"
 			}
 		}
 	}
 
 	switch {
-	case isEnum(f.Class(), value):
+	case isEnum(f.ClassName(), value):
 		{
-			if c, exists := parser.ClassMap[class(cppEnum(f, value, false))]; exists && module(c.Module) != module(f) && module(c.Module) != "" {
-				if parser.ClassMap[f.Class()].WeakLink[c.Module] {
+			if c, exists := parser.CurrentState.ClassMap[class(cppEnum(f, value, false))]; exists && module(c.Module) != module(f) && module(c.Module) != "" {
+				if _, exists := parser.CurrentState.ClassMap[f.ClassName()].WeakLink[c.Module]; exists {
 					return "int64"
 				}
 				return fmt.Sprintf("%v.%v", module(c.Module), goEnum(f, value))
@@ -146,8 +146,8 @@ func goType(f *parser.Function, value string) string {
 
 	case isClass(value):
 		{
-			if m := module(parser.ClassMap[value].Module); m != module(f) {
-				if parser.ClassMap[f.Class()].WeakLink[parser.ClassMap[value].Module] {
+			if m := module(parser.CurrentState.ClassMap[value].Module); m != module(f) {
+				if _, exists := parser.CurrentState.ClassMap[f.ClassName()].WeakLink[parser.CurrentState.ClassMap[value].Module]; exists {
 					return "unsafe.Pointer"
 				}
 				return fmt.Sprintf("%v.%v", m, value)
@@ -163,8 +163,8 @@ func goType(f *parser.Function, value string) string {
 	case parser.IsPackedList(value):
 		{
 			value = parser.UnpackedList(value)
-			if m := module(parser.ClassMap[value].Module); m != module(f) {
-				if parser.ClassMap[f.Class()].WeakLink[parser.ClassMap[value].Module] {
+			if m := module(parser.CurrentState.ClassMap[value].Module); m != module(f) {
+				if _, exists := parser.CurrentState.ClassMap[f.ClassName()].WeakLink[parser.CurrentState.ClassMap[value].Module]; exists {
 					return "[]unsafe.Pointer"
 				}
 				return fmt.Sprintf("[]*%v.%v", m, value)
@@ -200,7 +200,7 @@ func cgoType(f *parser.Function, value string) string {
 	switch value {
 	case "char", "qint8", "uchar", "quint8", "QString", "QStringList":
 		{
-			return fmt.Sprintf("C.struct_%v_PackedString", strings.Title(parser.ClassMap[f.Class()].Module))
+			return fmt.Sprintf("C.struct_%v_PackedString", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module))
 		}
 
 	case "void", "":
@@ -274,7 +274,7 @@ func cgoType(f *parser.Function, value string) string {
 	}
 
 	switch {
-	case isEnum(f.Class(), value):
+	case isEnum(f.ClassName(), value):
 		{
 			return "C.longlong"
 		}
@@ -311,7 +311,7 @@ func cppType(f *parser.Function, value string) string {
 	switch value {
 	case "char", "qint8", "uchar", "quint8", "QString", "QStringList":
 		{
-			return fmt.Sprintf("struct %v_PackedString", strings.Title(parser.ClassMap[f.Class()].Module))
+			return fmt.Sprintf("struct %v_PackedString", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module))
 		}
 
 	case "void", "":
@@ -427,7 +427,7 @@ func cppType(f *parser.Function, value string) string {
 	}
 
 	switch {
-	case isEnum(f.Class(), value):
+	case isEnum(f.ClassName(), value):
 		{
 			return "long long"
 		}
@@ -439,7 +439,7 @@ func cppType(f *parser.Function, value string) string {
 
 	case parser.IsPackedList(value):
 		{
-			return fmt.Sprintf("struct %v_PackedList", strings.Title(parser.ClassMap[f.Class()].Module))
+			return fmt.Sprintf("struct %v_PackedList", strings.Title(parser.CurrentState.ClassMap[f.ClassName()].Module))
 		}
 	}
 

internal/binding/parser/class.go

@@ -1,14 +1,8 @@
 package parser
 
 import (
-	"bytes"
 	"fmt"
-	"os/exec"
-	"path/filepath"
-	"runtime"
 	"strings"
-
-	"github.com/therecipe/qt/internal/utils"
 )
 
 type Class struct {
@@ -27,94 +21,26 @@ type Class struct {
 
 	DocModule string
 	Stub      bool
-	WeakLink  map[string]bool
+	WeakLink  map[string]struct{}
 	Export    bool
 	Fullname  string
 }
 
-func (c *Class) register(module string) {
+func (c *Class) register(m string) {
+
 	c.DocModule = c.Module
-	c.Module = module
-	ClassMap[c.Name] = c
+	c.Module = m
+	CurrentState.ClassMap[c.Name] = c
 
 	for _, sc := range c.Classes {
-		if sc.Name == "PaintContext" {
-			var hasConstructor bool
+		if sc.Name != "PaintContext" { //TODO: remove
+			continue
+		}
 
 		sc.Fullname = fmt.Sprintf("%v::%v", c.Name, sc.Name)
-			for _, scf := range sc.Functions {
-				if scf.Meta == COPY_CONSTRUCTOR || scf.Meta == MOVE_CONSTRUCTOR || scf.Meta == CONSTRUCTOR {
-					scf.Status = "active"
-					scf.Access = "public"
-					hasConstructor = true
+		sc.register(m)
 	}
 }
-			if !hasConstructor {
-				sc.Functions = append(sc.Functions, &Function{
-					Name:       sc.Name,
-					Fullname:   fmt.Sprintf("%v::%v", sc.Fullname, sc.Name),
-					Access:     "public",
-					Virtual:    "non",
-					Meta:       CONSTRUCTOR,
-					Output:     "",
-					Parameters: []*Parameter{},
-					Signature:  "()",
-				})
-			}
-			sc.register(module)
-		}
-	}
-}
-
-func (c *Class) registerVarsAndProps() {
-	for _, v := range c.Variables {
-		if !c.HasFunctionWithName(v.Name) && !IsPackedList(v.Output) {
-			c.Functions = append(c.Functions, v.variableToFunction(GETTER))
-			if !strings.Contains(v.Output, "const") {
-				c.Functions = append(c.Functions, v.variableToFunction(SETTER))
-			}
-		}
-	}
-	for _, p := range c.Properties {
-		c.Functions = append(c.Functions, p.propertyToFunctions(c)...)
-	}
-}
-
-func (c *Class) removeFunctions() {
-	for i := len(c.Functions) - 1; i >= 0; i-- {
-		var f = c.Functions[i]
-		if (f.Status == "obsolete" || f.Status == "compat") || !(f.Access == "public" || f.Access == "protected") || strings.ContainsAny(f.Name, "&<>=/!()[]{}^|*+-") || strings.Contains(f.Name, "Operator") {
-			c.Functions = append(c.Functions[:i], c.Functions[i+1:]...)
-		}
-	}
-}
-
-func (c *Class) removeEnums() {
-	for i := len(c.Enums) - 1; i >= 0; i-- {
-		var e = c.Enums[i]
-		if (e.Status == "obsolete" || e.Status == "compat") || !(e.Access == "public" || e.Access == "protected") {
-			c.Enums = append(c.Enums[:i], c.Enums[i+1:]...)
-		}
-	}
-}
-
-func (c *Class) Dump() {
-	var bb = new(bytes.Buffer)
-	defer bb.Reset()
-
-	fmt.Fprintln(bb, "########################################\t\t\tFUNCTIONS\t\t\t########################################")
-	for _, f := range c.Functions {
-		fmt.Fprintln(bb, f)
-	}
-
-	fmt.Fprintln(bb, "########################################\t\t\tENUMS\t\t\t########################################")
-	for _, e := range c.Enums {
-		fmt.Fprintln(bb, e)
-	}
-
-	utils.MakeFolder(utils.GoQtPkgPath("internal", "binding", "dump", c.Module))
-	utils.SaveBytes(utils.GoQtPkgPath("internal", "binding", "dump", c.Module, fmt.Sprintf("%v.txt", c.Name)), bb.Bytes())
-}
 
 func (c *Class) GetBases() []string {
 
@@ -129,573 +55,55 @@ func (c *Class) GetBases() []string {
 	return []string{c.Bases}
 }
 
-func (c *Class) GetAllBases() []string { return c.getAllBases(make([]string, 0)) }
+func (c *Class) GetAllBases() []string {
 
-func (c *Class) getAllBases(input []string) []string {
+	var input = make([]string, 0)
 
-	var bases = c.GetBases()
-
-	switch len(bases) {
-	case 0:
-		{
-			return input
+	for _, b := range c.GetBases() {
+		var bc, exists = CurrentState.ClassMap[b]
+		if !exists {
+			continue
 		}
 
-	case 1:
-		{
-			if sb, exists := ClassMap[bases[0]]; exists {
-				input = append(input, bases[0])
-				return sb.getAllBases(input)
-			}
-			return input
-		}
-	}
-
-	for _, b := range bases {
 		input = append(input, b)
-		if bs, exists := ClassMap[b]; exists {
-			for _, sb := range bs.GetAllBases() {
-				input = append(input, sb)
-			}
+		for _, sbc := range bc.GetAllBases() {
+			input = append(input, sbc)
 		}
 	}
+
 	return input
 }
 
-func (c *Class) IsQObjectSubClass() bool { return c.IsSubClass("QObject") }
+func (c *Class) IsSubClassOfQObject() bool {
+	return c.IsSubClassOf("QObject")
+}
 
-func (c *Class) IsSubClass(class string) bool {
-	if c != nil {
-		if c.Name == class {
-			return true
-		}
-		for _, b := range c.GetAllBases() {
-			if b == class {
-				return true
-			}
-		}
-	}
+func (c *Class) IsSubClassOf(class string) bool {
+	if c == nil {
 		return false
 	}
 
-func (c *Class) add() {
-
-	//TODO: needed until input + cgo support for generic Containers<T> to ignore virtuals with moc
-	if c.Module == MOC {
-		for _, sbc := range c.GetBases() {
-			if _, exists := ClassMap[sbc]; exists {
-				for _, sbcf := range ClassMap[sbc].Functions {
-					if IsPackedList(sbcf.Output) {
-						sbcf.Virtual = "non"
-						sbcf.Meta = PLAIN
-					}
-				}
-			}
-		}
-
-		//add generic qRegisterMetaType functions
-		if !c.HasFunctionWithName("qRegisterMetaType") {
-			var tmpF = &Function{
-				Name:           "qRegisterMetaType",
-				Fullname:       fmt.Sprintf("%v::qRegisterMetaType", c.Name),
-				Access:         "public",
-				Virtual:        "non",
-				Meta:           PLAIN,
-				NonMember:      true,
-				NoMocDeduce:    true,
-				Static:         true,
-				Output:         fmt.Sprintf("int"),
-				Parameters:     []*Parameter{},
-				Signature:      "()",
-				TemplateModeGo: fmt.Sprintf("%v*", c.Name),
-			}
-			c.Functions = append(c.Functions, tmpF)
-
-			var f = *tmpF
-			f.Overload = true
-			f.OverloadNumber = "2"
-			f.Parameters = []*Parameter{{Name: "typeName", Value: "const char *"}}
-			f.Signature = "(const char *typeName)"
-			c.Functions = append(c.Functions, &f)
-		}
-	}
-
-	switch c.Name {
-	case "QColor", "QFont", "QImage":
-		{
-			c.Functions = append(c.Functions, &Function{
-				Name:       "toVariant",
-				Fullname:   fmt.Sprintf("%v::toVariant", c.Name),
-				Access:     "public",
-				Virtual:    "non",
-				Meta:       PLAIN,
-				Output:     "QVariant",
-				Parameters: []*Parameter{},
-				Signature:  "()",
-			})
-		}
-
-	case "QVariant":
-		{
-			for _, name := range []string{"toColor", "toFont", "toImage"} {
-				c.Functions = append(c.Functions, &Function{
-					Name:       name,
-					Fullname:   fmt.Sprintf("%v::%v", c.Name, name),
-					Access:     "public",
-					Virtual:    "non",
-					Meta:       PLAIN,
-					Output:     strings.Replace(name, "to", "Q", -1),
-					Parameters: []*Parameter{},
-					Signature:  "()",
-				})
-			}
-		}
-	}
-
-	for _, f := range c.Functions {
-		switch f.Output {
-		case "QModelIndexList":
-			{
-				f.Output = "QList<QModelIndex>"
-			}
-
-		case "QVariantList":
-			{
-				f.Output = "QList<QVariant>"
-			}
-
-		case "QObjectList":
-			{
-				f.Output = "QList<QObject *>"
-			}
-
-		case "QMediaResourceList":
-			{
-				f.Output = "QList<QMediaResource>"
-			}
-
-		case "QFileInfoList":
-			{
-				f.Output = "QList<QFileInfo>"
-			}
-
-		case "QWidgetList":
-			{
-				f.Output = "QList<QWidget *>"
-			}
-
-		/* TODO:
-		case "QCameraFocusZoneList":
-		{
-			f.Output = "QList<QCameraFocusZone *>"
-		}
-		*/
-
-		//generics
-
-		case "QList<T>":
-			{
-				f.TemplateModeGo = "QObject*"
-				f.Output = "QList<QObject*>"
-			}
-
-		case "T":
-			{
-				if f.Class() == "QObject" || f.Class() == "QMediaService" {
-					f.TemplateModeGo = fmt.Sprintf("%v*", f.Class())
-					f.Output = fmt.Sprintf("%v*", f.Class())
-				}
-			}
-		}
-
-		if IsPackedList(f.Output) {
-			var b bool
-			for _, p := range f.Parameters {
-				if strings.ContainsAny(p.Value, "<>") {
-					b = true
-					break
-				}
-			}
-
-			if !b && !c.HasFunctionWithName(fmt.Sprintf("%v_atList", f.Name)) {
-				var newF = &Function{
-					Name:       fmt.Sprintf("%v_atList", f.Name),
-					Fullname:   fmt.Sprintf("%v::%v_atList", c.Name, f.Name),
-					Access:     "public",
-					Virtual:    "non",
-					Meta:       PLAIN,
-					Output:     fmt.Sprintf("const %v", strings.Split(strings.Split(f.Output, "<")[1], ">")[0]),
-					Parameters: []*Parameter{{Name: "i", Value: "int"}},
-					Signature:  "()",
-					Container:  strings.Split(f.Output, "<")[0],
-				}
-				c.Functions = append(c.Functions, newF)
-				f.Child = newF
-			}
-		}
-	}
-}
-
-func IsPackedList(value string) bool {
-	return (strings.HasPrefix(value, "QList<") || strings.HasPrefix(value, "QVector<") || strings.HasPrefix(value, "QStack<") || strings.HasPrefix(value, "QQueue<")) && strings.Count(value, "<") == 1 && !strings.Contains(value, ":") && ClassMap[UnpackedList(value)] != nil
-}
-
-func UnpackedList(value string) string {
-	var CleanValue = func(value string) string {
-		for _, b := range []string{"*", "const", "&amp", "&", ";"} {
-			value = strings.Replace(value, b, "", -1)
-		}
-		return strings.TrimSpace(value)
-	}
-	return CleanValue(strings.Split(strings.Split(value, "<")[1], ">")[0])
-}
-
-func (c *Class) fix() {
-	if c.Name == "QStyle" {
-
-		var defFunction Function
-
-		for _, f := range c.Functions {
-			if f.Name == "standardIcon" {
-				defFunction = *f
-				break
-			}
-		}
-
-		defFunction.Name = "standardPixmap"
-		defFunction.Output = "QPixmap"
-		defFunction.Fullname = fmt.Sprintf("%v::%v", c.Name, defFunction.Name)
-
-		c.Functions = append(c.Functions, &defFunction)
-	}
-
-	if c.Name == "QScxmlCppDataModel" {
-		for _, s := range []struct{ Name, Output string }{
-			{"evaluateToString", "QString"},
-			{"evaluateToBool", "bool"},
-			{"evaluateToVariant", "QVariant"},
-			{"evaluateToVoid", "void"},
-			{"evaluateAssignment", "void"},
-			{"evaluateInitialization", "void"},
-		} {
-			c.Functions = append(c.Functions, &Function{
-				Name:     s.Name,
-				Fullname: fmt.Sprintf("%v::%v", c.Name, s.Name),
-				Access:   "public",
-				Virtual:  PURE,
-				Meta:     PLAIN,
-				Output:   s.Output,
-				Parameters: []*Parameter{
-					{
-						Name:  "id",
-						Value: "QScxmlExecutableContent::EvaluatorId",
-					},
-					{
-						Name:  "ok",
-						Value: "bool*",
-					}},
-				Signature: "()",
-			})
-		}
-
-		c.Functions = append(c.Functions, &Function{
-			Name:     "evaluateForeach",
-			Fullname: fmt.Sprintf("%v::evaluateForeach", c.Name),
-			Access:   "public",
-			Virtual:  PURE,
-			Meta:     PLAIN,
-			Output:   "void",
-			Parameters: []*Parameter{
-				{
-					Name:  "id",
-					Value: "QScxmlExecutableContent::EvaluatorId",
-				},
-				{
-					Name:  "ok",
-					Value: "bool*",
-				},
-				{
-					Name:  "body",
-					Value: "ForeachLoopBody*",
-				}},
-			Signature: "()",
-		})
-	}
-}
-
-func (c *Class) fixBases() {
-	if c.Module != MOC {
-
-		var (
-			prefixPath string
-			infixPath  = "include"
-			suffixPath = string(filepath.Separator)
-		)
-
-		switch runtime.GOOS {
-		case "windows":
-			{
-				if utils.UseMsys2() {
-					prefixPath = utils.QT_MSYS2_DIR()
-				} else {
-					prefixPath = filepath.Join(utils.QT_DIR(), "5.7", "mingw53_32")
-				}
-			}
-
-		case "darwin":
-			{
-				prefixPath = utils.QT_DARWIN_DIR()
-				infixPath = "lib"
-				suffixPath = ".framework/Versions/5/Headers/"
-			}
-
-		case "linux":
-			{
-				if utils.UsePkgConfig() {
-					prefixPath = strings.TrimSpace(utils.RunCmd(exec.Command("pkg-config", "--variable=includedir", "Qt5Core"), "parser.class_includedir"))
-				} else {
-					prefixPath = filepath.Join(utils.QT_DIR(), "5.7", "gcc_64")
-				}
-			}
-		}
-
-		switch c.Name {
-		case "Qt", "QtGlobalStatic", "QUnicodeTools", "QHooks", "QModulesPrivate", "QtMetaTypePrivate", "QUnicodeTables", "QAndroidJniEnvironment", "QAndroidJniObject", "QAndroidActivityResultReceiver", "QSupportedWritingSystems", "QAbstractOpenGLFunctions":
-			{
-				c.Bases = ""
-				return
-			}
-
-		case "QUiLoader", "QEGLNativeContext", "QWGLNativeContext", "QGLXNativeContext", "QEglFSFunctions", "QWindowsWindowFunctions", "QCocoaNativeContext", "QXcbWindowFunctions", "QCocoaWindowFunctions":
-			{
-				if utils.UsePkgConfig() {
-					c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, c.Module, fmt.Sprintf("%v.h", strings.ToLower(c.Name)))), c.Name, c.Module)
-				} else {
-					c.Bases = getBasesFromHeader(utils.Load(fmt.Sprintf(filepath.Join("%v", "include", "%v", "%v.h"), prefixPath, c.Module, strings.ToLower(c.Name))), c.Name, c.Module)
-				}
-				return
-			}
-
-		case "QPlatformSystemTrayIcon", "QPlatformGraphicsBuffer":
-			{
-				if utils.UsePkgConfig() {
-					c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, c.Module, "5.7.0", c.Module, "qpa", fmt.Sprintf("%v.h", strings.ToLower(c.Name)))), c.Name, c.Module)
-				} else {
-					c.Bases = getBasesFromHeader(utils.Load(fmt.Sprintf(filepath.Join("%v", "%v", "%v%v5.7.0", "QtGui", "qpa", "%v.h"), prefixPath, infixPath, c.Module, suffixPath, strings.ToLower(c.Name))), c.Name, c.Module)
-				}
-				return
-			}
-
-		case "QColumnView", "QLCDNumber", "QWebEngineUrlSchemeHandler", "QWebEngineUrlRequestInterceptor", "QWebEngineCookieStore", "QWebEngineUrlRequestInfo", "QWebEngineUrlRequestJob":
-			{
-				for _, m := range append(LibDeps[strings.TrimPrefix(c.Module, "Qt")], strings.TrimPrefix(c.Module, "Qt")) {
-					m = fmt.Sprintf("Qt%v", m)
-					if utils.UsePkgConfig() {
-						if utils.Exists(filepath.Join(prefixPath, m, fmt.Sprintf("%v.h", strings.ToLower(c.Name)))) {
-							c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, m, fmt.Sprintf("%v.h", strings.ToLower(c.Name)))), c.Name, c.Module)
-							return
-						}
-					} else {
-						if utils.Exists(fmt.Sprintf(filepath.Join("%v", "%v", "%v%v%v"), prefixPath, infixPath, m, suffixPath, c.Name)) {
-							c.Bases = getBasesFromHeader(utils.Load(fmt.Sprintf(filepath.Join("%v", "%v", "%v%v%v.h"), prefixPath, infixPath, m, suffixPath, strings.ToLower(c.Name))), c.Name, c.Module)
-							return
-						}
-					}
-				}
-			}
-
-		case "QFutureWatcher", "QDBusAbstractInterface":
-			{
-				c.Bases = "QObject"
-				return
-			}
-
-		case "QDBusPendingReply":
-			{
-				c.Bases = "QDBusPendingCall"
-				return
-			}
-
-		case "QRasterPaintEngine":
-			{
-				c.Bases = "QPaintEngine"
-				return
-			}
-		}
-
-		var libs = append(LibDeps[strings.TrimPrefix(c.Module, "Qt")], strings.TrimPrefix(c.Module, "Qt"))
-		for i, v := range libs {
-			if v == "TestLib" {
-				libs[i] = "Test"
-			}
-		}
-
-		var found bool
-		for _, m := range libs {
-			m = fmt.Sprintf("Qt%v", m)
-			if utils.UsePkgConfig() {
-				if utils.Exists(filepath.Join(prefixPath, m, c.Name)) {
-
-					var f = utils.Load(filepath.Join(prefixPath, m, c.Name))
-					if f != "" {
-						found = true
-						c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, m, strings.Split(f, "\"")[1])), c.Name, m)
-					}
-					break
-				}
-			} else {
-				if utils.Exists(fmt.Sprintf(filepath.Join("%v", "%v", "%v%v%v"), prefixPath, infixPath, m, suffixPath, c.Name)) {
-
-					var f = utils.Load(fmt.Sprintf(filepath.Join("%v", "%v", "%v%v%v"), prefixPath, infixPath, m, suffixPath, c.Name))
-					if f != "" {
-						found = true
-						c.Bases = getBasesFromHeader(utils.Load(filepath.Join(fmt.Sprintf(filepath.Join("%v", "%v", "%v%v"), prefixPath, infixPath, m, suffixPath), strings.Split(f, "\"")[1])), c.Name, m)
-					}
-					break
-				}
-			}
-		}
-
-		if !found && c.Name != "SailfishApp" && c.Fullname == "" {
-			utils.Log.Errorln("failed to find header file for:", c.Name, c.Module)
-		}
-
-		var bases = c.GetBases()
-		for i := len(bases) - 1; i >= 0; i-- {
-			if _, exists := ClassMap[bases[i]]; !exists {
-				bases = append(bases[:i], bases[i+1:]...)
-			}
-		}
-		c.Bases = strings.Join(bases, ",")
-
-	}
-}
-
-func getBasesFromHeader(f string, n string, m string) string {
-
-	f = strings.Replace(f, "\r", "", -1)
-
-	if strings.HasSuffix(n, "Iterator") {
-		return ""
-	}
-
-	for i, l := range strings.Split(f, "\n") {
-
-		//TODO:
-		if strings.Contains(l, "class "+n) || strings.Contains(l, "class Q_"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT "+n) || strings.Contains(l, "class Q"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT "+n) || strings.Contains(l, "class QDESIGNER_SDK_EXPORT "+n) || strings.Contains(l, "class QDESIGNER_EXTENSION_EXPORT "+n) || strings.Contains(l, "class QDESIGNER_UILIB_EXPORT "+n) || strings.Contains(l, "class  "+n) || strings.Contains(l, "class Q_"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT  "+n) || strings.Contains(l, "class Q"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT  "+n) || strings.Contains(l, "class QDESIGNER_SDK_EXPORT  "+n) || strings.Contains(l, "class QDESIGNER_EXTENSION_EXPORT  "+n) || strings.Contains(l, "class QDESIGNER_UILIB_EXPORT  "+n) {
-
-			if strings.Contains(l, n+" ") || strings.Contains(l, n+":") || strings.HasSuffix(l, n) {
-
-				l = normalizedClassDeclaration(f, i)
-
-				if !strings.Contains(l, ":") {
-					return ""
-				}
-
-				if strings.Contains(l, "<") {
-					l = strings.Split(l, "<")[0]
-				}
-
-				if strings.Contains(l, "/") {
-					l = strings.Split(l, "/")[0]
-				}
-
-				var tmp = strings.Split(l, ":")[1]
-
-				for _, s := range []string{"{", "}", "#ifndef", "QT_NO_QOBJECT", "#else", "#endif", "class", "Q_" + strings.ToUpper(strings.TrimPrefix(m, "Qt")) + "_EXPORT " + n, "public", "protected", "private", "  ", " "} {
-					tmp = strings.Replace(tmp, s, "", -1)
-				}
-
-				return strings.TrimSpace(tmp)
-			}
-		}
-	}
-
-	for _, l := range strings.Split(f, "\n") {
-		if strings.Contains(l, "struct "+n) || strings.Contains(l, "struct Q_"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT "+n) {
-			return ""
-		}
-	}
-
-	for _, l := range strings.Split(f, "\n") {
-		if strings.Contains(l, "namespace "+n) {
-			return ""
-		}
-	}
-
-	utils.Log.Errorln("failed to parse header for:", m, n)
-	return ""
-}
-
-func normalizedClassDeclaration(f string, is int) string {
-	var bb = new(bytes.Buffer)
-	defer bb.Reset()
-
-	for i, l := range strings.Split(f, "\n") {
-		if i >= is {
-			fmt.Fprint(bb, l)
-			if strings.Contains(l, "{") {
-				break
-			}
-		}
-	}
-	return bb.String()
-}
-
-var LibDeps = map[string][]string{
-	"Core":          {"Widgets", "Gui"}, //Widgets, Gui
-	"AndroidExtras": {"Core"},
-	"Gui":           {"Widgets", "Core"}, //Widgets
-	"Network":       {"Core"},
-	"Xml":           {"XmlPatterns", "Core"}, //XmlPatterns
-	"DBus":          {"Core"},
-	"Nfc":           {"Core"},
-	"Script":        {"Core"},
-	"Sensors":       {"Core"},
-	"Positioning":   {"Core"},
-	"Widgets":       {"Gui", "Core"},
-	"Sql":           {"Widgets", "Gui", "Core"}, //Widgets, Gui
-	"MacExtras":     {"Gui", "Core"},
-	"Qml":           {"Network", "Core"},
-	"WebSockets":    {"Network", "Core"},
-	"XmlPatterns":   {"Network", "Core"},
-	"Bluetooth":     {"Core"},
-	"WebChannel":    {"Network", "Qml", "Core"}, //Network (needed for static linking ios)
-	"Svg":           {"Widgets", "Gui", "Core"},
-	"Multimedia":    {"MultimediaWidgets", "Widgets", "Network", "Gui", "Core"},   //MultimediaWidgets, Widgets
-	"Quick":         {"QuickWidgets", "Widgets", "Network", "Qml", "Gui", "Core"}, //QuickWidgets, Widgets, Network (needed for static linking ios)
-	"Help":          {"Sql", "CLucene", "Network", "Widgets", "Gui", "Core"},      //Sql + CLucene + Network (needed for static linking ios)
-	"Location":      {"Positioning", "Quick", "Gui", "Core"},
-	"ScriptTools":   {"Script", "Widgets", "Core"}, //Script, Widgets
-	"UiTools":       {"Widgets", "Gui", "Core"},
-	"X11Extras":     {"Gui", "Core"},
-	"WinExtras":     {"Gui", "Core"},
-	"WebEngine":     {"Widgets", "WebEngineWidgets", "WebChannel", "Network", "WebEngineCore", "Quick", "Gui", "Qml", "Core"}, //Widgets, WebEngineWidgets, WebChannel, Network
-	"TestLib":       {"Widgets", "Gui", "Core"},                                                                               //Widgets, Gui
-	"SerialPort":    {"Core"},
-	"SerialBus":     {"Core"},
-	"PrintSupport":  {"Widgets", "Gui", "Core"},
-	//"PlatformHeaders": []string{}, //TODO:
-	"Designer": {"UiPlugin", "Widgets", "Gui", "Xml", "Core"},
-	"Scxml":    {"Network", "Qml", "Core"}, //Network (needed for static linking ios)
-	"Gamepad":  {"Gui", "Core"},
-
-	"Purchasing": {"Core"},
-	//"DataVisualization": []string{"Gui", "Core"},
-	//"Charts":            []string{"Widgets", "Gui", "Core"},
-	//"Quick2DRenderer":   []string{}, //TODO:
-
-	"Sailfish": {"Core"},
-
-	MOC:         make([]string, 0),
-	"build_ios": {"Core", "Gui", "Network", "Sql", "Xml", "DBus", "Nfc", "Script", "Sensors", "Positioning", "Widgets", "Qml", "WebSockets", "XmlPatterns", "Bluetooth", "WebChannel", "Svg", "Multimedia", "Quick", "Help", "Location", "ScriptTools", "MultimediaWidgets", "UiTools", "PrintSupport"},
+	for _, b := range append([]string{c.Name}, c.GetAllBases()...) {
+		if b != class {
+			continue
 		}
 
-func (c *Class) HasFunctionWithName(name string) bool {
-	for _, f := range c.Functions {
-		if strings.ToLower(f.Name) == strings.ToLower(name) {
 		return true
 	}
-	}
+
+	return false
+}
+
+func (c *Class) isSubClass() bool { return c.Fullname != "" }
+
+func (c *Class) HasFunctionWithName(n string) bool {
+	for _, f := range c.Functions {
+		if strings.ToLower(f.Name) != strings.ToLower(n) {
+			continue
+		}
+
+		return true
+	}
+
 	return false
 }

internal/binding/parser/class_add.go

@@ -0,0 +1,91 @@
+package parser
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *Class) add() {
+	c.addGeneralFuncs()
+
+	c.addVarAndPropFuncs()
+
+	c.addMocFuncs()
+}
+
+func (c *Class) addGeneralFuncs() {
+	switch c.Name {
+	case "QColor", "QFont", "QImage":
+		{
+			c.Functions = append(c.Functions, &Function{
+				Name:       "toVariant",
+				Fullname:   fmt.Sprintf("%v::toVariant", c.Name),
+				Access:     "public",
+				Virtual:    "non",
+				Meta:       PLAIN,
+				Output:     "QVariant",
+				Parameters: []*Parameter{},
+				Signature:  "()",
+			})
+		}
+
+	case "QVariant":
+		{
+			for _, name := range []string{"toColor", "toFont", "toImage"} {
+				c.Functions = append(c.Functions, &Function{
+					Name:       name,
+					Fullname:   fmt.Sprintf("%v::%v", c.Name, name),
+					Access:     "public",
+					Virtual:    "non",
+					Meta:       PLAIN,
+					Output:     strings.Replace(name, "to", "Q", -1),
+					Parameters: []*Parameter{},
+					Signature:  "()",
+				})
+			}
+		}
+	}
+}
+
+func (c *Class) addVarAndPropFuncs() {
+	for _, v := range c.Variables {
+		c.Functions = append(c.Functions, v.varToFunc()...)
+	}
+	for _, p := range c.Properties {
+		c.Functions = append(c.Functions, p.propToFunc(c)...)
+	}
+}
+
+func (c *Class) addMocFuncs() {
+	if c.Module != MOC {
+		return
+	}
+
+	//add generic qRegisterMetaType functions
+	if c.HasFunctionWithName("qRegisterMetaType") {
+		return
+	}
+
+	var tmpF = &Function{
+		Name:           "qRegisterMetaType",
+		Fullname:       fmt.Sprintf("%v::qRegisterMetaType", c.Name),
+		Access:         "public",
+		Virtual:        "non",
+		Meta:           PLAIN,
+		NonMember:      true,
+		NoMocDeduce:    true,
+		Static:         true,
+		Output:         fmt.Sprintf("int"),
+		Parameters:     []*Parameter{},
+		Signature:      "()",
+		TemplateModeGo: fmt.Sprintf("%v*", c.Name),
+	}
+	c.Functions = append(c.Functions, tmpF)
+
+	var tmpF2 = *tmpF
+	tmpF2.Overload = true
+	tmpF2.OverloadNumber = "2"
+	tmpF2.Parameters = []*Parameter{{Name: "typeName", Value: "const char *"}}
+	tmpF2.Signature = "(const char *typeName)"
+	c.Functions = append(c.Functions, &tmpF2)
+}

internal/binding/parser/class_fix.go

@@ -0,0 +1,338 @@
+package parser
+
+import (
+	"bytes"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/therecipe/qt/internal/utils"
+)
+
+func (c *Class) fix() {
+	c.fixFunctions()
+
+	//c.fixGeneral()
+	c.fixGeneral_Version()
+
+	c.fixLinkage()
+
+	c.fixBases()
+}
+
+func (c *Class) fixFunctions() {
+	for _, f := range c.Functions {
+		f.fix()
+	}
+}
+
+func (c *Class) fixGeneral_Version() {
+	switch c.Name {
+	case "QStyle":
+		{
+			for _, f := range c.Functions {
+				if f.Name != "standardIcon" {
+					continue
+				}
+
+				var tmpF = *f
+				tmpF.Name = "standardPixmap"
+				tmpF.Output = "QPixmap"
+				tmpF.Fullname = fmt.Sprintf("%v::%v", c.Name, tmpF.Name)
+
+				c.Functions = append(c.Functions, &tmpF)
+			}
+		}
+
+	case "QScxmlCppDataModel":
+		{
+			for _, s := range []struct{ Name, Output string }{
+				{"evaluateToString", "QString"},
+				{"evaluateToBool", "bool"},
+				{"evaluateToVariant", "QVariant"},
+				{"evaluateToVoid", "void"},
+				{"evaluateAssignment", "void"},
+				{"evaluateInitialization", "void"},
+			} {
+				c.Functions = append(c.Functions, &Function{
+					Name:     s.Name,
+					Fullname: fmt.Sprintf("%v::%v", c.Name, s.Name),
+					Access:   "public",
+					Virtual:  PURE,
+					Meta:     PLAIN,
+					Output:   s.Output,
+					Parameters: []*Parameter{
+						{
+							Name:  "id",
+							Value: "QScxmlExecutableContent::EvaluatorId",
+						},
+						{
+							Name:  "ok",
+							Value: "bool*",
+						},
+					},
+					Signature: "()",
+				})
+			}
+
+			c.Functions = append(c.Functions, &Function{
+				Name:     "evaluateForeach",
+				Fullname: fmt.Sprintf("%v::evaluateForeach", c.Name),
+				Access:   "public",
+				Virtual:  PURE,
+				Meta:     PLAIN,
+				Output:   "void",
+				Parameters: []*Parameter{
+					{
+						Name:  "id",
+						Value: "QScxmlExecutableContent::EvaluatorId",
+					},
+					{
+						Name:  "ok",
+						Value: "bool*",
+					},
+					{
+						Name:  "body",
+						Value: "ForeachLoopBody*",
+					},
+				},
+				Signature: "()",
+			})
+		}
+	}
+}
+
+func (c *Class) fixLinkage() {
+	switch c.Module {
+	case "QtCore":
+		{
+			c.WeakLink = map[string]struct{}{
+				"QtGui":     struct{}{},
+				"QtWidgets": struct{}{},
+			}
+		}
+
+	case "QtGui":
+		{
+			c.WeakLink = map[string]struct{}{
+				"QtWidgets":    struct{}{},
+				"QtMultimedia": struct{}{},
+			}
+		}
+	}
+}
+
+func (c *Class) fixBases() {
+	if c.Module == MOC {
+		return
+	}
+
+	var (
+		prefixPath string
+		infixPath  = "include"
+		suffixPath = string(filepath.Separator)
+	)
+
+	switch runtime.GOOS {
+	case "windows":
+		{
+			if utils.UseMsys2() {
+				prefixPath = utils.QT_MSYS2_DIR()
+			} else {
+				prefixPath = filepath.Join(utils.QT_DIR(), "5.7", "mingw53_32")
+			}
+		}
+
+	case "darwin":
+		{
+			prefixPath = utils.QT_DARWIN_DIR()
+			infixPath = "lib"
+			suffixPath = ".framework/Versions/5/Headers/"
+		}
+
+	case "linux":
+		{
+			if utils.UsePkgConfig() {
+				prefixPath = strings.TrimSpace(utils.RunCmd(exec.Command("pkg-config", "--variable=includedir", "Qt5Core"), "parser.class_includedir"))
+			} else {
+				prefixPath = filepath.Join(utils.QT_DIR(), "5.7", "gcc_64")
+			}
+		}
+	}
+
+	//TODO: remove
+	switch c.Name {
+	case "Qt", "QtGlobalStatic", "QUnicodeTools", "QHooks", "QModulesPrivate", "QtMetaTypePrivate", "QUnicodeTables", "QAndroidJniEnvironment", "QAndroidJniObject", "QAndroidActivityResultReceiver", "QSupportedWritingSystems", "QAbstractOpenGLFunctions":
+		{
+			c.Bases = ""
+			return
+		}
+
+	case "QFutureWatcher", "QDBusAbstractInterface":
+		{
+			c.Bases = "QObject"
+			return
+		}
+
+	case "QDBusPendingReply":
+		{
+			c.Bases = "QDBusPendingCall"
+			return
+		}
+
+	case "QRasterPaintEngine":
+		{
+			c.Bases = "QPaintEngine"
+			return
+		}
+
+	case "QUiLoader", "QEGLNativeContext", "QWGLNativeContext", "QGLXNativeContext", "QEglFSFunctions", "QWindowsWindowFunctions", "QCocoaNativeContext", "QXcbWindowFunctions", "QCocoaWindowFunctions":
+		{
+			if utils.UsePkgConfig() {
+				c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, c.Module, strings.ToLower(c.Name)+".h")), c.Name, c.Module)
+			} else {
+				c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, "include", c.Module, strings.ToLower(c.Name)+".h")), c.Name, c.Module)
+			}
+			return
+		}
+
+	case "QPlatformSystemTrayIcon", "QPlatformGraphicsBuffer":
+		{
+			if utils.UsePkgConfig() {
+				c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, c.Module, "5.7.0", c.Module, "qpa", strings.ToLower(c.Name)+".h")), c.Name, c.Module)
+			} else {
+				c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, infixPath, c.Module+suffixPath+"5.7.0", "QtGui", "qpa", strings.ToLower(c.Name)+".h")), c.Name, c.Module)
+			}
+			return
+		}
+
+	case "QColumnView", "QLCDNumber", "QWebEngineUrlSchemeHandler", "QWebEngineUrlRequestInterceptor", "QWebEngineCookieStore", "QWebEngineUrlRequestInfo", "QWebEngineUrlRequestJob":
+		{
+			for _, m := range append(LibDeps[strings.TrimPrefix(c.Module, "Qt")], strings.TrimPrefix(c.Module, "Qt")) {
+				m = fmt.Sprintf("Qt%v", m)
+				if utils.UsePkgConfig() {
+					if utils.ExistsFile(filepath.Join(prefixPath, m, strings.ToLower(c.Name)+".h")) {
+						c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, m, strings.ToLower(c.Name)+".h")), c.Name, c.Module)
+						return
+					}
+				} else {
+					if utils.ExistsFile(filepath.Join(prefixPath, infixPath, m+suffixPath+c.Name)) {
+						c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, infixPath, m+suffixPath+strings.ToLower(c.Name)+".h")), c.Name, c.Module)
+						return
+					}
+				}
+			}
+		}
+	}
+
+	//TODO:
+	var libs = append(LibDeps[strings.TrimPrefix(c.Module, "Qt")], strings.TrimPrefix(c.Module, "Qt"))
+	for i, v := range libs {
+		if v == "TestLib" {
+			libs[i] = "Test"
+		}
+	}
+
+	var found bool
+	for _, m := range libs {
+		m = fmt.Sprintf("Qt%v", m)
+		if utils.UsePkgConfig() {
+			if utils.ExistsFile(filepath.Join(prefixPath, m, c.Name)) {
+
+				var f = utils.Load(filepath.Join(prefixPath, m, c.Name))
+				if f != "" {
+					found = true
+					c.Bases = getBasesFromHeader(utils.Load(filepath.Join(prefixPath, m, strings.Split(f, "\"")[1])), c.Name, m)
+				}
+				break
+			}
+		} else {
+			if utils.ExistsFile(filepath.Join(prefixPath, infixPath, m+suffixPath+c.Name)) {
+
+				var f = utils.Load(filepath.Join(prefixPath, infixPath, m+suffixPath+c.Name))
+				if f != "" {
+					found = true
+					c.Bases = getBasesFromHeader(utils.Load(filepath.Join(filepath.Join(prefixPath, infixPath, m+suffixPath), strings.Split(f, "\"")[1])), c.Name, m)
+				}
+				break
+			}
+		}
+	}
+
+	if !found && c.Name != "SailfishApp" && c.Fullname == "" {
+		utils.Log.WithField("0_module", strings.TrimPrefix(c.Module, "Qt")).WithField("class", c.Name).Debugln("failed to find header file")
+	}
+}
+
+func getBasesFromHeader(f string, n string, m string) string {
+
+	f = strings.Replace(f, "\r", "", -1)
+
+	if strings.HasSuffix(n, "Iterator") {
+		return ""
+	}
+
+	for i, l := range strings.Split(f, "\n") {
+
+		//TODO: reduce
+		if strings.Contains(l, "class "+n) || strings.Contains(l, "class Q_"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT "+n) || strings.Contains(l, "class Q"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT "+n) || strings.Contains(l, "class QDESIGNER_SDK_EXPORT "+n) || strings.Contains(l, "class QDESIGNER_EXTENSION_EXPORT "+n) || strings.Contains(l, "class QDESIGNER_UILIB_EXPORT "+n) || strings.Contains(l, "class  "+n) || strings.Contains(l, "class Q_"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT  "+n) || strings.Contains(l, "class Q"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT  "+n) || strings.Contains(l, "class QDESIGNER_SDK_EXPORT  "+n) || strings.Contains(l, "class QDESIGNER_EXTENSION_EXPORT  "+n) || strings.Contains(l, "class QDESIGNER_UILIB_EXPORT  "+n) {
+
+			if strings.Contains(l, n+" ") || strings.Contains(l, n+":") || strings.HasSuffix(l, n) {
+
+				l = normalizedClassDeclaration(f, i)
+
+				if !strings.Contains(l, ":") {
+					return ""
+				}
+
+				if strings.Contains(l, "<") {
+					l = strings.Split(l, "<")[0]
+				}
+
+				if strings.Contains(l, "/") {
+					l = strings.Split(l, "/")[0]
+				}
+
+				var tmp = strings.Split(l, ":")[1]
+
+				for _, s := range []string{"{", "}", "#ifndef", "QT_NO_QOBJECT", "#else", "#endif", "class", "Q_" + strings.ToUpper(strings.TrimPrefix(m, "Qt")) + "_EXPORT " + n, "public", "protected", "private", "  ", " "} {
+					tmp = strings.Replace(tmp, s, "", -1)
+				}
+
+				return strings.TrimSpace(tmp)
+			}
+		}
+	}
+
+	for _, l := range strings.Split(f, "\n") {
+		if strings.Contains(l, "struct "+n) || strings.Contains(l, "struct Q_"+strings.ToUpper(strings.TrimPrefix(m, "Qt"))+"_EXPORT "+n) {
+			return ""
+		}
+	}
+
+	for _, l := range strings.Split(f, "\n") {
+		if strings.Contains(l, "namespace "+n) {
+			return ""
+		}
+	}
+
+	utils.Log.WithField("0_module", strings.TrimPrefix(m, "Qt")).WithField("class", n).Debugln("failed to parse header")
+	return ""
+}
+
+func normalizedClassDeclaration(f string, is int) string {
+	var bb = new(bytes.Buffer)
+	defer bb.Reset()
+
+	for i, l := range strings.Split(f, "\n") {
+		if i >= is {
+			fmt.Fprint(bb, l)
+			if strings.Contains(l, "{") {
+				break
+			}
+		}
+	}
+	return bb.String()
+}

internal/binding/parser/class_remove.go

@@ -0,0 +1,67 @@
+package parser
+
+import "strings"
+
+func (c *Class) remove() {
+	c.removeFunctions()
+	c.removeFunctions_Version()
+
+	c.removeEnums()
+	c.removeEnums_Version()
+
+	c.removeBases()
+}
+
+func (c *Class) removeFunctions() {
+	for i := len(c.Functions) - 1; i >= 0; i-- {
+		if f := c.Functions[i]; (f.Status == "obsolete" || f.Status == "compat") ||
+			!(f.Access == "public" || f.Access == "protected") ||
+			strings.ContainsAny(f.Name, "&<>=/!()[]{}^|*+-") ||
+			strings.Contains(f.Name, "Operator") {
+
+			c.Functions = append(c.Functions[:i], c.Functions[i+1:]...)
+		}
+	}
+}
+
+func (c *Class) removeFunctions_Version() {
+	for i := len(c.Functions) - 1; i >= 0; i-- {
+		switch c.Functions[i].Fullname {
+		case "QTextBrowser::isModified", "QTextBrowser::setModified":
+			{
+				c.Functions = append(c.Functions[:i], c.Functions[i+1:]...)
+			}
+		}
+	}
+}
+
+func (c *Class) removeEnums() {
+	for i := len(c.Enums) - 1; i >= 0; i-- {
+		if e := c.Enums[i]; (e.Status == "obsolete" || e.Status == "compat") ||
+			!(e.Access == "public" || e.Access == "protected") {
+
+			c.Enums = append(c.Enums[:i], c.Enums[i+1:]...)
+		}
+	}
+}
+
+func (c *Class) removeEnums_Version() {
+	for i := len(c.Enums) - 1; i >= 0; i-- {
+		switch c.Enums[i].ClassName() {
+		case "QCss", "QScript":
+			{
+				c.Enums = append(c.Enums[:i], c.Enums[i+1:]...)
+			}
+		}
+	}
+}
+
+func (c *Class) removeBases() {
+	var bases = c.GetBases()
+	for i := len(bases) - 1; i >= 0; i-- {
+		if _, exists := CurrentState.ClassMap[bases[i]]; !exists {
+			bases = append(bases[:i], bases[i+1:]...)
+		}
+	}
+	c.Bases = strings.Join(bases, ",")
+}

internal/binding/parser/enum.go

@@ -17,26 +17,28 @@ type Value struct {
 	Value string `xml:"value,attr"`
 }
 
-func (e *Enum) Class() string { return strings.Split(e.Fullname, "::")[0] }
+func (e *Enum) Class() (*Class, bool) {
+	var class, exists = CurrentState.ClassMap[e.ClassName()]
+	return class, exists
+}
 
-func (e *Enum) register(module string) {
-	SubnamespaceMap[e.Class()] = true
-	if c, exists := ClassMap[e.Class()]; !exists {
-		ClassMap[e.Class()] = &Class{Name: e.Class(), Status: "commendable", Module: module, Access: "public", Enums: []*Enum{e}}
+func (e *Enum) ClassName() string {
+	return strings.Split(e.Fullname, "::")[0]
+}
+
+func (e *Enum) register(m string) {
+
+	CurrentState.EnumMap[e.ClassName()] = struct{}{}
+
+	if c, exists := e.Class(); !exists {
+		CurrentState.ClassMap[e.ClassName()] = &Class{
+			Name:   e.ClassName(),
+			Status: "commendable",
+			Module: m,
+			Access: "public",
+			Enums:  []*Enum{e},
+		}
 	} else {
-		if !e.isRegistered() {
 		c.Enums = append(c.Enums, e)
 	}
 }
-}
-
-func (e *Enum) isRegistered() bool {
-	for _, c := range ClassMap {
-		for _, ce := range c.Enums {
-			if e.Fullname == ce.Fullname {
-				return true
-			}
-		}
-	}
-	return false
-}

internal/binding/parser/function.go

@@ -1,9 +1,6 @@
 package parser
 
-import (
-	"strconv"
-	"strings"
-)
+import "strings"
 
 type Function struct {
 	Name             string       `xml:"name,attr"`
@@ -32,6 +29,7 @@ type Function struct {
 	Child            *Function
 	NonMember        bool
 	NoMocDeduce      bool
+	PureBaseFunction bool
 }
 
 type Parameter struct {
@@ -39,75 +37,14 @@ type Parameter struct {
 	Value string `xml:"left,attr"`
 }
 
-func (f *Function) Class() string {
+func (f *Function) Class() (*Class, bool) {
+	var class, exist = CurrentState.ClassMap[f.ClassName()]
+	return class, exist
+}
+func (f *Function) ClassName() string {
 	var s = strings.Split(f.Fullname, "::")
 	if len(s) == 3 {
 		return s[1]
 	}
 	return s[0]
 }
-
-func (f *Function) register(module string) {
-	if c, exists := ClassMap[f.Class()]; !exists {
-		ClassMap[f.Class()] = &Class{Name: f.Class(), Module: module, Access: "public", Functions: []*Function{f}}
-	} else {
-		c.Functions = append(c.Functions, f)
-	}
-}
-
-func (f *Function) fix() {
-	if f.Fullname == "QThread::start" {
-		f.Parameters = make([]*Parameter, 0)
-	}
-
-	if f.Fullname == "QScxmlCppDataModel::setScxmlEvent" {
-		f.Virtual = "non"
-	}
-
-	if f.Virtual == IMPURE || f.Virtual == PURE || f.Meta == SIGNAL || f.Meta == SLOT {
-		f.Static = false
-	}
-}
-
-func (f *Function) fixOverload() {
-
-	if strings.Contains(f.Href, "-") {
-		var tmp, err = strconv.Atoi(strings.Split(f.Href, "-")[1])
-		if err == nil && tmp > 0 {
-			f.Overload = true
-			tmp++
-			f.OverloadNumber = strconv.Itoa(tmp)
-		}
-	}
-
-	if f.OverloadNumber == "0" {
-		f.Overload = false
-		f.OverloadNumber = ""
-	}
-
-	switch f.Fullname {
-	case
-		"QGraphicsDropShadowEffect::setOffset", "QGraphicsScene::setSceneRect",
-		"QGraphicsView::setSceneRect", "QQuickItem::setFocus",
-		"QAccessibleWidget::setText", "QSvgGenerator::setViewBox",
-		"QSvgRenderer::setViewBox":
-		{
-			var count int
-			for _, sf := range ClassMap[f.Class()].Functions {
-				if f.Fullname == sf.Fullname {
-					if f.Signature == sf.Signature {
-						if count == 0 {
-							return
-						}
-						break
-					} else {
-						count++
-					}
-				}
-			}
-
-			f.Overload = true
-			f.OverloadNumber = strconv.Itoa(count + 1)
-		}
-	}
-}

internal/binding/parser/function_fix.go

@@ -0,0 +1,235 @@
+package parser
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func (f *Function) fix() {
+	f.fixGeneral()
+	f.fixGeneral_Version()
+
+	f.fixOverload()
+	f.fixOverload_Version()
+
+	f.fixGeneric()
+
+	f.fixTemporary()
+}
+
+func (f *Function) fixGeneral() {
+
+	//linux fixes
+
+	if f.Fullname == "QThread::start" {
+		f.Parameters = make([]*Parameter, 0)
+	}
+
+	//virtual fixes
+
+	if f.Virtual == "virtual" {
+		f.Virtual = IMPURE
+	}
+
+	if f.Virtual == IMPURE || f.Virtual == PURE ||
+		f.Meta == SIGNAL || f.Meta == SLOT {
+
+		f.Static = false
+	}
+
+	//constructor fixes
+
+	if f.Meta == COPY_CONSTRUCTOR || f.Meta == MOVE_CONSTRUCTOR {
+		f.Meta = CONSTRUCTOR
+	}
+
+	var class, exist = f.Class()
+	if !exist || !class.isSubClass() {
+		return
+	}
+
+	if f.Meta == CONSTRUCTOR {
+		f.Status = "active"
+		f.Access = "public"
+	}
+}
+
+func (f *Function) fixGeneral_Version() {
+	switch f.Fullname {
+	case "QScxmlCppDataModel::setScxmlEvent":
+		{
+			f.Virtual = "non"
+		}
+
+	case "QGraphicsObject::z", "QGraphicsObject::setZ":
+		{
+			f.Name = func() string {
+				if f.Name == "setZ" {
+					return "setZValue"
+				}
+				return "zValue"
+			}()
+			f.Fullname = fmt.Sprintf("%v::%v", f.ClassName(), f.Name)
+		}
+
+	case "QGraphicsObject::effect", "QGraphicsObject::setEffect":
+		{
+			f.Name = func() string {
+				if f.Name == "setEffect" {
+					return "setGraphicsEffect"
+				}
+				return "graphicsEffect"
+			}()
+			f.Fullname = fmt.Sprintf("%v::%v", f.ClassName(), f.Name)
+		}
+	}
+}
+
+func (f *Function) fixOverload() {
+
+	if strings.Contains(f.Href, "-") {
+		var tmp, err = strconv.Atoi(strings.Split(f.Href, "-")[1])
+		if err == nil && tmp > 0 {
+			f.Overload = true
+			tmp++
+			f.OverloadNumber = strconv.Itoa(tmp)
+		}
+	}
+
+	if f.OverloadNumber != "0" {
+		return
+	}
+
+	f.Overload = false
+	f.OverloadNumber = ""
+}
+
+func (f *Function) fixOverload_Version() {
+	switch f.Fullname {
+	case "QGraphicsDropShadowEffect::setOffset", "QGraphicsScene::setSceneRect",
+		"QGraphicsView::setSceneRect", "QQuickItem::setFocus",
+		"QAccessibleWidget::setText", "QSvgGenerator::setViewBox",
+		"QSvgRenderer::setViewBox":
+		{
+			var class, exist = f.Class()
+			if !exist {
+				return
+			}
+
+			var count int
+			for _, sf := range class.Functions {
+				if sf.Fullname != f.Fullname {
+					continue
+				}
+
+				if sf.Signature != f.Signature {
+					count++
+					continue
+				}
+
+				break
+			}
+			if count == 0 {
+				return
+			}
+
+			f.Overload = true
+			f.OverloadNumber = strconv.Itoa(count + 1)
+		}
+	}
+}
+
+func (f *Function) fixGeneric() {
+
+	switch f.Output {
+	case "QModelIndexList":
+		{
+			f.Output = "QList<QModelIndex>"
+		}
+
+	case "QVariantList":
+		{
+			f.Output = "QList<QVariant>"
+		}
+
+	case "QObjectList":
+		{
+			f.Output = "QList<QObject *>"
+		}
+
+	case "QMediaResourceList":
+		{
+			f.Output = "QList<QMediaResource>"
+		}
+
+	case "QFileInfoList":
+		{
+			f.Output = "QList<QFileInfo>"
+		}
+
+	case "QWidgetList":
+		{
+			f.Output = "QList<QWidget *>"
+		}
+
+	case "QCameraFocusZoneList":
+		{
+			//f.Output = "QList<QCameraFocusZone *>" //TODO: uncomment
+		}
+
+	case "QList<T>":
+		{
+			f.TemplateModeGo = "QObject*"
+			f.Output = "QList<QObject*>"
+		}
+
+	case "T":
+		{
+			switch className := f.ClassName(); className {
+			case "QObject", "QMediaService":
+				{
+					f.TemplateModeGo = fmt.Sprintf("%v*", className)
+					f.Output = fmt.Sprintf("%v*", className)
+				}
+			}
+		}
+	}
+
+	if !IsPackedList(f.Output) {
+		return
+	}
+
+	var class, exist = f.Class()
+	if !exist || class.HasFunctionWithName(fmt.Sprintf("%v_atList", f.Name)) {
+		return
+	}
+
+	for _, p := range f.Parameters {
+		if strings.ContainsAny(p.Value, "<>") {
+			return
+		}
+	}
+
+	class.Functions = append(class.Functions, &Function{
+		Name:       fmt.Sprintf("%v_atList", f.Name),
+		Fullname:   fmt.Sprintf("%v::%v_atList", class.Name, f.Name),
+		Access:     "public",
+		Virtual:    "non",
+		Meta:       PLAIN,
+		Output:     fmt.Sprintf("const %v", strings.Split(strings.Split(f.Output, "<")[1], ">")[0]),
+		Parameters: []*Parameter{{Name: "i", Value: "int"}},
+		Signature:  "()",
+		Container:  strings.Split(f.Output, "<")[0],
+	})
+}
+
+func (f *Function) fixTemporary() {
+
+	//TODO: needed until input + cgo support for generic Lists/Containers<T>
+	if !IsPackedList(f.Output) || f.Virtual == PURE {
+		return
+	}
+	f.Virtual = "non"
+	f.Meta = PLAIN
+}

internal/binding/parser/helper.go

@@ -0,0 +1,189 @@
+package parser
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strings"
+
+	"github.com/therecipe/qt/internal/utils"
+)
+
+const (
+	SIGNAL = "signal"
+	SLOT   = "slot"
+
+	IMPURE = "impure"
+	PURE   = "pure"
+
+	MOC              = "main"
+	PLAIN            = "plain"
+	CONSTRUCTOR      = "constructor"
+	COPY_CONSTRUCTOR = "copy-constructor"
+	MOVE_CONSTRUCTOR = "move-constructor"
+	DESTRUCTOR       = "destructor"
+
+	CONNECT    = "Connect"
+	DISCONNECT = "Disconnect"
+	CALLBACK   = "callback"
+
+	GETTER = "getter"
+	SETTER = "setter"
+
+	VOID = "void"
+
+	TILDE = "~"
+)
+
+func IsPackedList(v string) bool {
+	return (strings.HasPrefix(v, "QList<") ||
+		strings.HasPrefix(v, "QVector<") ||
+		strings.HasPrefix(v, "QStack<") ||
+		strings.HasPrefix(v, "QQueue<")) &&
+
+		strings.Count(v, "<") == 1 &&
+		!strings.Contains(v, ":") &&
+		CurrentState.ClassMap[UnpackedList(v)] != nil
+}
+
+func UnpackedList(v string) string {
+	var CleanValue = func(v string) string {
+		for _, b := range []string{"*", "const", "&amp", "&", ";"} {
+			v = strings.Replace(v, b, "", -1)
+		}
+		return strings.TrimSpace(v)
+	}
+	return CleanValue(strings.Split(strings.Split(v, "<")[1], ">")[0])
+}
+
+var LibDeps = map[string][]string{
+	"Core":          {"Widgets", "Gui"}, //Widgets, Gui
+	"AndroidExtras": {"Core"},
+	"Gui":           {"Widgets", "Core"}, //Widgets
+	"Network":       {"Core"},
+	"Xml":           {"XmlPatterns", "Core"}, //XmlPatterns
+	"DBus":          {"Core"},
+	"Nfc":           {"Core"},
+	"Script":        {"Core"},
+	"Sensors":       {"Core"},
+	"Positioning":   {"Core"},
+	"Widgets":       {"Gui", "Core"},
+	"Sql":           {"Widgets", "Gui", "Core"}, //Widgets, Gui
+	"MacExtras":     {"Gui", "Core"},
+	"Qml":           {"Network", "Core"},
+	"WebSockets":    {"Network", "Core"},
+	"XmlPatterns":   {"Network", "Core"},
+	"Bluetooth":     {"Core"},
+	"WebChannel":    {"Network", "Qml", "Core"}, //Network (needed for static linking ios)
+	"Svg":           {"Widgets", "Gui", "Core"},
+	"Multimedia":    {"MultimediaWidgets", "Widgets", "Network", "Gui", "Core"},   //MultimediaWidgets, Widgets
+	"Quick":         {"QuickWidgets", "Widgets", "Network", "Qml", "Gui", "Core"}, //QuickWidgets, Widgets, Network (needed for static linking ios)
+	"Help":          {"Sql", "CLucene", "Network", "Widgets", "Gui", "Core"},      //Sql + CLucene + Network (needed for static linking ios)
+	"Location":      {"Positioning", "Quick", "Gui", "Core"},
+	"ScriptTools":   {"Script", "Widgets", "Core"}, //Script, Widgets
+	"UiTools":       {"Widgets", "Gui", "Core"},
+	"X11Extras":     {"Gui", "Core"},
+	"WinExtras":     {"Gui", "Core"},
+	"WebEngine":     {"Widgets", "WebEngineWidgets", "WebChannel", "Network", "WebEngineCore", "Quick", "Gui", "Qml", "Core"}, //Widgets, WebEngineWidgets, WebChannel, Network
+	"TestLib":       {"Widgets", "Gui", "Core"},                                                                               //Widgets, Gui
+	"SerialPort":    {"Core"},
+	"SerialBus":     {"Core"},
+	"PrintSupport":  {"Widgets", "Gui", "Core"},
+	//"PlatformHeaders": []string{}, //TODO: uncomment
+	"Designer": {"UiPlugin", "Widgets", "Gui", "Xml", "Core"},
+	"Scxml":    {"Network", "Qml", "Core"}, //Network (needed for static linking ios)
+	"Gamepad":  {"Gui", "Core"},
+
+	"Purchasing": {"Core"},
+	//"DataVisualization": []string{"Gui", "Core"},            //TODO: uncomment
+	//"Charts":            []string{"Widgets", "Gui", "Core"}, //TODO: uncomment
+	//"Quick2DRenderer":   []string{},                         //TODO: uncomment
+
+	"Sailfish": {"Core"},
+
+	MOC:         make([]string, 0),
+	"build_ios": {"Core", "Gui", "Network", "Sql", "Xml", "DBus", "Nfc", "Script", "Sensors", "Positioning", "Widgets", "Qml", "WebSockets", "XmlPatterns", "Bluetooth", "WebChannel", "Svg", "Multimedia", "Quick", "Help", "Location", "ScriptTools", "MultimediaWidgets", "UiTools", "PrintSupport"},
+}
+
+var Libs = []string{
+	"Core",
+	"AndroidExtras",
+	"Gui",
+	"Network",
+	"Xml",
+	"DBus",
+	"Nfc",
+	"Script", //depreached (planned) in 5.6
+	"Sensors",
+	"Positioning",
+	"Widgets",
+	"Sql",
+	"MacExtras",
+	"Qml",
+	"WebSockets",
+	"XmlPatterns",
+	"Bluetooth",
+	"WebChannel",
+	"Svg",
+	"Multimedia",
+	"Quick",
+	"Help",
+	"Location",
+	"ScriptTools", //depreached (planned) in 5.6
+	"UiTools",
+	"X11Extras",
+	"WinExtras",
+	"WebEngine",
+	"TestLib",
+	"SerialPort",
+	"SerialBus",
+	"PrintSupport",
+	//"PlatformHeaders", //missing imports/guards
+	"Designer",
+	"Scxml",
+	"Gamepad",
+
+	"Purchasing", //GPLv3 & LGPLv3
+	//"DataVisualization", //GPLv3
+	//"Charts",            //GPLv3
+	//"Quick2DRenderer",   //GPLv3
+
+	"Sailfish",
+}
+
+func GetLibs() []string {
+	for i := len(Libs) - 1; i >= 0; i-- {
+		switch {
+		case
+			!(runtime.GOOS == "darwin" || runtime.GOOS == "linux") && Libs[i] == "WebEngine",
+			runtime.GOOS != "windows" && Libs[i] == "WinExtras",
+			runtime.GOOS != "darwin" && Libs[i] == "MacExtras",
+			runtime.GOOS != "linux" && Libs[i] == "X11Extras":
+			{
+				Libs = append(Libs[:i], Libs[i+1:]...)
+			}
+		}
+	}
+
+	return Libs
+}
+
+func Dump() {
+	for _, c := range CurrentState.ClassMap {
+		var bb = new(bytes.Buffer)
+		defer bb.Reset()
+
+		fmt.Fprint(bb, "funcs\n\n")
+		for _, f := range c.Functions {
+			fmt.Fprintln(bb, f)
+		}
+
+		fmt.Fprint(bb, "\n\nenums\n\n")
+		for _, e := range c.Enums {
+			fmt.Fprintln(bb, e)
+		}
+
+		utils.MkdirAll(utils.GoQtPkgPath("internal", "binding", "dump", c.Module))
+		utils.SaveBytes(utils.GoQtPkgPath("internal", "binding", "dump", c.Module, fmt.Sprintf("%v.txt", c.Name)), bb.Bytes())
+	}
+}

internal/binding/parser/module.go

@@ -7,145 +7,43 @@ type Module struct {
 
 type Namespace struct {
 	Classes []*Class `xml:"class"`
-	//Functions    []*Function   `xml:"function"`
+	//Functions    []*Function   `xml:"function"` //TODO: uncomment
 	SubNamespace *SubNamespace `xml:"namespace"`
 }
 
 type SubNamespace struct {
-	//Classes   []*Class    `xml:"class"`
-	//Functions []*Function `xml:"function"`
+	//Classes   []*Class    `xml:"class"`    //TODO: uncomment
+	//Functions []*Function `xml:"function"` //TODO: uncomment
 	Enums []*Enum `xml:"enum"`
 }
 
-func (m *Module) Prepare() {
+func (m *Module) Prepare() error {
 
-	//register namespace
-	if m.Namespace != nil {
+	//register classes from namespace
 	for _, c := range m.Namespace.Classes {
 		c.register(m.Project)
-			c.registerVarsAndProps()
-			for _, sc := range c.Classes {
-				sc.registerVarsAndProps()
-			}
-		}
 	}
 
-	//register subnamespace
-	if m.Project == "QtCore" || m.Project == "QtMultimedia" {
+	//register enums from subnamespace
 	if m.Namespace.SubNamespace != nil {
 		for _, e := range m.Namespace.SubNamespace.Enums {
 			e.register(m.Project)
 		}
 	}
+
+	//mutate classmap
+	m.remove()
+
+	//mutate classes
+	for _, c := range CurrentState.ClassMap {
+		if c.Module != m.Project {
+			continue
 		}
 
-	//remove obsolete and private
-	m.removeClasses()
-	for _, c := range ClassMap {
-		if c.Module == m.Project {
-			c.fix()
-			c.removeFunctions()
-			c.removeEnums()
 		c.add()
-		}
+		c.fix()
+		c.remove()
 	}
 
-	for _, c := range ClassMap {
-		if c.Module == m.Project {
-			c.fixBases()
-
-			for _, f := range c.Functions {
-				f.fix()
-				f.fixOverload()
-
-				if f.Virtual == "virtual" {
-					f.Virtual = IMPURE
-				}
-				if f.Meta == COPY_CONSTRUCTOR || f.Meta == MOVE_CONSTRUCTOR {
-					f.Meta = CONSTRUCTOR
-				}
-			}
-		}
-	}
-}
-
-func (m *Module) removeClasses() {
-	for _, c := range ClassMap {
-		if (c.Status == "obsolete" || c.Status == "compat") || !(c.Access == "public" || c.Access == "protected") || c.Name == "qoutputrange" {
-			delete(ClassMap, c.Name)
-		}
-	}
-}
-
-func sailfishModule() *Module {
-	//TODO: should be in Namespace.Functions
-	return &Module{Project: "QtSailfish", Namespace: &Namespace{Classes: []*Class{{
-		Name:   "SailfishApp",
-		Access: "public",
-		Module: "QtSailfish",
-		Functions: []*Function{
-			{
-				Name:      "application",
-				Fullname:  "SailfishApp::application",
-				Access:    "public",
-				Virtual:   "non",
-				Meta:      PLAIN,
-				Static:    true,
-				Output:    "QGuiApplication*",
-				Signature: "()",
-				Parameters: []*Parameter{
-					{
-						Name:  "argc",
-						Value: "int &",
-					},
-					{
-						Name:  "argv",
-						Value: "char **",
-					},
-				}},
-			{
-				Name:      "main",
-				Fullname:  "SailfishApp::main",
-				Access:    "public",
-				Virtual:   "non",
-				Meta:      PLAIN,
-				Static:    true,
-				Output:    "int",
-				Signature: "()",
-				Parameters: []*Parameter{
-					{
-						Name:  "argc",
-						Value: "int &",
-					},
-					{
-						Name:  "argv",
-						Value: "char **",
-					},
-				}},
-			{
-				Name:      "createView",
-				Fullname:  "SailfishApp::createView",
-				Access:    "public",
-				Virtual:   "non",
-				Meta:      PLAIN,
-				Static:    true,
-				Output:    "QQuickView*",
-				Signature: "()",
-			},
-			{
-				Name:      "pathTo",
-				Fullname:  "SailfishApp::pathTo",
-				Access:    "public",
-				Virtual:   "non",
-				Meta:      PLAIN,
-				Static:    true,
-				Output:    "QUrl",
-				Signature: "pathTo(const QString &filename)",
-				Parameters: []*Parameter{
-					{
-						Name:  "filename",
-						Value: "QString &",
-					},
-				}},
-		}}}}}
+	return nil
 }

internal/binding/parser/module_remove.go

@@ -0,0 +1,21 @@
+package parser
+
+func (m *Module) remove() {
+	m.removeClasses()
+}
+
+func (m *Module) removeClasses() {
+	for _, c := range CurrentState.ClassMap {
+		if c.Module != m.Project {
+			continue
+		}
+
+		switch {
+		case c.Status == "obsolete", c.Status == "compat",
+			!(c.Access == "public" || c.Access == "protected"),
+			c.Name == "qoutputrange":
+
+			delete(CurrentState.ClassMap, c.Name)
+		}
+	}
+}

internal/binding/parser/parser.go

@@ -6,78 +6,67 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/therecipe/qt/internal/utils"
 	"github.com/Sirupsen/logrus"
+	"github.com/therecipe/qt/internal/utils"
 )
 
-const (
-	SIGNAL = "signal"
-	SLOT   = "slot"
+type State struct {
+	ClassMap map[string]*Class
+	EnumMap  map[string]struct{}
 
-	IMPURE = "impure"
-	PURE   = "pure"
+	Moc     bool
+	Minimal bool
 
-	MOC              = "main"
-	PLAIN            = "plain"
-	CONSTRUCTOR      = "constructor"
-	COPY_CONSTRUCTOR = "copy-constructor"
-	MOVE_CONSTRUCTOR = "move-constructor"
-	DESTRUCTOR       = "destructor"
+	MocModule     string
+	CurrentModule string
+}
 
-	CONNECT    = "Connect"
-	DISCONNECT = "Disconnect"
-	CALLBACK   = "callback"
+var CurrentState = &State{
+	ClassMap: make(map[string]*Class),
+	EnumMap:  make(map[string]struct{}),
+}
 
-	GETTER = "getter"
-	SETTER = "setter"
+func LoadModules() {
+	for _, m := range GetLibs() {
+		_ = LoadModule(m)
+	}
+}
 
-	VOID = "void"
-
-	TILDE = "~"
+func LoadModule(m string) error {
+	var (
+		logName   = "parser.LoadModule"
+		logFields = logrus.Fields{"0_module": m}
 	)
+	utils.Log.WithFields(logFields).Debug(logName)
+
+	if m == "Sailfish" {
+		return sailfishModule().Prepare()
+	}
 
 	var (
-	ClassMap        = make(map[string]*Class)
-	SubnamespaceMap = make(map[string]bool)
+		module = new(Module)
+		err    error
 	)
-
-func GetModule(s string) (m *Module, err error) {
-	s = strings.ToLower(s)
-	fields := logrus.Fields{
-		"module": fmt.Sprintf("qt/%v", s),
-		"func": "GetModule",
-	}
-	utils.Log.WithFields(fields).Debug("loading module")
-
-	var goPath = utils.MustGoPath()
-
-	if s == "sailfish" {
-		m = sailfishModule()
-		m.Prepare()
-		return m, nil
-	}
-
-	m = new(Module)
 	switch {
 	case utils.UseHomeBrew(), utils.UseMsys2():
 		{
-			err = xml.Unmarshal([]byte(utils.Load(filepath.Join(goPath, "src", "github.com", "therecipe", "qt", "internal", "binding", "files", "docs", "5.7.0", fmt.Sprintf("qt%v.index", s)))), &m)
+			err = xml.Unmarshal([]byte(utils.Load(filepath.Join(utils.MustGoPath(), "src", "github.com", "therecipe", "qt", "internal", "binding", "files", "docs", "5.7.0", fmt.Sprintf("qt%v.index", strings.ToLower(m))))), &module)
 		}
 
 	case utils.UsePkgConfig():
 		{
-			err = xml.Unmarshal([]byte(utils.Load(filepath.Join(utils.QT_DOC_DIR(), fmt.Sprintf("qt%v", s), fmt.Sprintf("qt%v.index", s)))), &m)
+			err = xml.Unmarshal([]byte(utils.Load(filepath.Join(utils.QT_DOC_DIR(), fmt.Sprintf("qt%v", strings.ToLower(m)), fmt.Sprintf("qt%v.index", strings.ToLower(m))))), &module)
 		}
 
 	default:
 		{
-			err = xml.Unmarshal([]byte(utils.Load(filepath.Join(utils.QT_DIR(), "Docs", "Qt-5.7", fmt.Sprintf("qt%v", s), fmt.Sprintf("qt%v.index", s)))), &m)
+			err = xml.Unmarshal([]byte(utils.Load(filepath.Join(utils.QT_DIR(), "Docs", "Qt-5.7", fmt.Sprintf("qt%v", strings.ToLower(m)), fmt.Sprintf("qt%v.index", strings.ToLower(m))))), &module)
 		}
 	}
 	if err != nil {
-		return nil, err
+		utils.Log.WithFields(logFields).WithError(err).Warn(logName)
+		return err
 	}
 
-	m.Prepare()
-	return m, nil
+	return module.Prepare()
 }

internal/binding/parser/sailfish.go

@@ -0,0 +1,84 @@
+package parser
+
+func sailfishModule() *Module {
+	return &Module{
+		Project: "QtSailfish",
+		Namespace: &Namespace{
+			Classes: []*Class{
+				{
+					Name:   "SailfishApp",
+					Access: "public",
+					Module: "QtSailfish",
+					Functions: []*Function{ //TODO: should be in Namespace.Functions
+						{
+							Name:      "application",
+							Fullname:  "SailfishApp::application",
+							Access:    "public",
+							Virtual:   "non",
+							Meta:      PLAIN,
+							Static:    true,
+							Output:    "QGuiApplication*",
+							Signature: "()",
+							Parameters: []*Parameter{
+								{
+									Name:  "argc",
+									Value: "int &",
+								},
+								{
+									Name:  "argv",
+									Value: "char **",
+								},
+							},
+						},
+						{
+							Name:      "main",
+							Fullname:  "SailfishApp::main",
+							Access:    "public",
+							Virtual:   "non",
+							Meta:      PLAIN,
+							Static:    true,
+							Output:    "int",
+							Signature: "()",
+							Parameters: []*Parameter{
+								{
+									Name:  "argc",
+									Value: "int &",
+								},
+								{
+									Name:  "argv",
+									Value: "char **",
+								},
+							},
+						},
+						{
+							Name:      "createView",
+							Fullname:  "SailfishApp::createView",
+							Access:    "public",
+							Virtual:   "non",
+							Meta:      PLAIN,
+							Static:    true,
+							Output:    "QQuickView*",
+							Signature: "()",
+						},
+						{
+							Name:      "pathTo",
+							Fullname:  "SailfishApp::pathTo",
+							Access:    "public",
+							Virtual:   "non",
+							Meta:      PLAIN,
+							Static:    true,
+							Output:    "QUrl",
+							Signature: "pathTo(const QString &filename)",
+							Parameters: []*Parameter{
+								{
+									Name:  "filename",
+									Value: "QString &",
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}

internal/binding/parser/variable.go

@@ -15,13 +15,15 @@ type Variable struct {
 	Static   bool       `xml:"static,attr"`
 	Output   string     `xml:"type,attr"`
 	Brief    string     `xml:"brief,attr"`
-	Getter   []*getter `xml:"getter"`
-	Setter   []*setter `xml:"setter"`
+	Getter   []struct{} `xml:"getter"`
+	Setter   []struct{} `xml:"setter"`
 }
-type getter struct{}
-type setter struct{}
 
-func (v *Variable) Class() string {
+func (v *Variable) Class() (*Class, bool) {
+	var class, exists = CurrentState.ClassMap[v.ClassName()]
+	return class, exists
+}
+func (v *Variable) ClassName() string {
 	var s = strings.Split(v.Fullname, "::")
 	if len(s) == 3 {
 		return s[1]
@@ -29,9 +31,15 @@ func (v *Variable) Class() string {
 	return s[0]
 }
 
-func (v *Variable) variableToFunction(meta string) *Function {
-	if meta == GETTER {
-		return &Function{
+func (v *Variable) varToFunc() []*Function {
+	var funcs = make([]*Function, 0)
+
+	var class, exist = v.Class()
+	if !exist || class.HasFunctionWithName(v.Name) {
+		return funcs
+	}
+
+	funcs = append(funcs, &Function{
 		Name:     v.Name,
 		Fullname: v.Fullname,
 		Href:     v.Href,
@@ -40,93 +48,71 @@ func (v *Variable) variableToFunction(meta string) *Function {
 		Filepath: v.Filepath,
 		Static:   v.Static,
 		Output:   v.Output,
-			Meta:     meta,
+		Meta:     GETTER,
 		Brief:    v.Brief,
-		}
-	}
-	return &Function{
-		Name:       fmt.Sprintf("set%v", strings.Title(v.Name)),
-		Fullname:   fmt.Sprintf("%v::set%v", v.Class(), strings.Title(v.Name)),
-		Href:       v.Href,
-		Status:     v.Status,
-		Access:     v.Access,
-		Filepath:   v.Filepath,
-		Static:     v.Static,
-		Output:     "void",
-		Meta:       meta,
-		Parameters: []*Parameter{{Value: v.Output}},
-		TmpName:    v.Name,
-		Brief:      v.Brief,
-	}
-}
+	})
 
-func (v *Variable) propertyToFunctions(c *Class) []*Function {
-	var funcs []*Function
-
-	if v.Fullname == "QTextBrowser::modified" {
+	if strings.Contains(v.Output, "const") {
 		return funcs
 	}
 
-	if !(c.HasFunctionWithName(v.Name) || c.HasFunctionWithName(fmt.Sprintf("is%v", strings.Title(v.Name))) || c.HasFunctionWithName(fmt.Sprintf("has%v", strings.Title(v.Name)))) && len(v.Getter) == 0 {
-
-		var tmpV = *v
-
-		switch tmpV.Fullname {
-		case "QGraphicsObject::z":
-			{
-				tmpV.Name = "zValue"
-				tmpV.Fullname = fmt.Sprintf("%v::%v", tmpV.Class(), tmpV.Name)
-			}
-
-		case "QGraphicsObject::effect":
-			{
-				tmpV.Name = "graphicsEffect"
-				tmpV.Fullname = fmt.Sprintf("%v::%v", tmpV.Class(), tmpV.Name)
-			}
-
-		default:
-			{
-				if tmpV.Output == "bool" {
-					tmpV.Name = fmt.Sprintf("is%v", strings.Title(tmpV.Name))
-					tmpV.Fullname = fmt.Sprintf("%v::%v", tmpV.Class(), tmpV.Name)
-				}
-			}
-		}
-
 	funcs = append(funcs, &Function{
-			Name:     tmpV.Name,
-			Fullname: tmpV.Fullname,
-			Href:     tmpV.Href,
-			Status:   tmpV.Status,
-			Access:   tmpV.Access,
-			Filepath: tmpV.Filepath,
-			Static:   tmpV.Static,
-			Output:   tmpV.Output,
-			Meta:     PLAIN,
-			Brief:    tmpV.Brief,
-		})
-	}
-
-	if !c.HasFunctionWithName(fmt.Sprintf("set%v", strings.Title(v.Name))) && len(v.Getter) == 0 && len(v.Setter) == 0 {
-
-		switch v.Fullname {
-		case "QGraphicsObject::z":
-			{
-				v.Name = "zValue"
-				v.Fullname = fmt.Sprintf("%v::%v", v.Class(), v.Name)
-			}
-
-		case "QGraphicsObject::effect":
-			{
-				v.Name = "graphicsEffect"
-				v.Fullname = fmt.Sprintf("%v::%v", v.Class(), v.Name)
-			}
-		}
-
-		funcs = append(funcs,
-			&Function{
 		Name:       fmt.Sprintf("set%v", strings.Title(v.Name)),
-				Fullname:   fmt.Sprintf("%v::set%v", v.Class(), strings.Title(v.Name)),
+		Fullname:   fmt.Sprintf("%v::set%v", v.ClassName(), strings.Title(v.Name)),
+		Href:       v.Href,
+		Status:     v.Status,
+		Access:     v.Access,
+		Filepath:   v.Filepath,
+		Static:     v.Static,
+		Output:     "void",
+		Meta:       SETTER,
+		Parameters: []*Parameter{{Value: v.Output}},
+		TmpName:    v.Name,
+		Brief:      v.Brief,
+	})
+
+	return funcs
+}
+
+func (v *Variable) propToFunc(c *Class) []*Function {
+	var funcs = make([]*Function, 0)
+
+	if len(v.Getter) != 0 {
+		return funcs
+	}
+
+	if !(c.HasFunctionWithName(v.Name) ||
+		c.HasFunctionWithName(fmt.Sprintf("is%v", strings.Title(v.Name))) ||
+		c.HasFunctionWithName(fmt.Sprintf("has%v", strings.Title(v.Name)))) {
+
+		var tmpF = &Function{
+			Name:      v.Name,
+			Fullname:  v.Fullname,
+			Href:      v.Href,
+			Status:    v.Status,
+			Access:    v.Access,
+			Filepath:  v.Filepath,
+			Static:    v.Static,
+			Output:    v.Output,
+			Meta:      PLAIN,
+			Signature: "()",
+		}
+
+		if tmpF.Output == "bool" {
+			tmpF.Name = fmt.Sprintf("is%v", strings.Title(tmpF.Name))
+			tmpF.Fullname = fmt.Sprintf("%v::%v", tmpF.ClassName(), tmpF.Name)
+		}
+
+		funcs = append(funcs, tmpF)
+	}
+
+	if len(v.Setter) != 0 || c.HasFunctionWithName(fmt.Sprintf("set%v", strings.Title(v.Name))) {
+		return funcs
+	}
+
+	funcs = append(funcs, &Function{
+		Name:       fmt.Sprintf("set%v", strings.Title(v.Name)),
+		Fullname:   fmt.Sprintf("%v::set%v", v.ClassName(), strings.Title(v.Name)),
 		Href:       v.Href,
 		Status:     v.Status,
 		Access:     v.Access,
@@ -135,30 +121,28 @@ func (v *Variable) propertyToFunctions(c *Class) []*Function {
 		Output:     "void",
 		Meta:       PLAIN,
 		Parameters: []*Parameter{{Value: v.Output}},
-				Brief:      v.Brief,
+		Signature:  "()",
 	})
 
+	//add all overloaded property functions from base classes
+
 	for _, bc := range c.GetAllBases() {
-			for _, bcf := range ClassMap[bc].Functions {
-				if bcf.Name == fmt.Sprintf("set%v", strings.Title(v.Name)) && bcf.Overload {
-					funcs = append(funcs,
-						&Function{
-							Name:           fmt.Sprintf("set%v", strings.Title(v.Name)),
-							Fullname:       fmt.Sprintf("%v::set%v", v.Class(), strings.Title(v.Name)),
-							Href:           bcf.Href,
-							Status:         bcf.Status,
-							Access:         bcf.Access,
-							Filepath:       bcf.Filepath,
-							Static:         bcf.Static,
-							Output:         "void",
-							Meta:           PLAIN,
-							Parameters:     bcf.Parameters,
-							Brief:          bcf.Brief,
-							Overload:       true,
-							OverloadNumber: bcf.OverloadNumber,
-						})
+		var bclass, exist = CurrentState.ClassMap[bc]
+		if !exist {
+			continue
 		}
+
+		for _, bcf := range bclass.Functions {
+			if bcf.Name != fmt.Sprintf("set%v", strings.Title(v.Name)) || !bcf.Overload {
+				continue
 			}
+
+			var tmpF = *bcf
+
+			tmpF.Name = fmt.Sprintf("set%v", strings.Title(v.Name))
+			tmpF.Fullname = fmt.Sprintf("%v::%v", v.ClassName(), tmpF.Name)
+
+			funcs = append(funcs, &tmpF)
 		}
 	}
 

internal/binding/templater/cgo.go

@@ -12,52 +12,42 @@ import (
 	"github.com/therecipe/qt/internal/utils"
 )
 
-var (
-	mocAppPath string
-	MocModule  string
-)
-
-func CopyCgoForMoc(module, appPath string) {
-	mocAppPath = appPath
-	CopyCgo(module)
-}
-
-func CopyCgo(module string) {
+func CopyCgo(module, mocPath string) {
 
 	if !(strings.Contains(module, "droid") || strings.Contains(module, "fish")) {
-		cgoDarwin(module)
+		cgoDarwin(module, mocPath)
 		if runtime.GOOS == "windows" {
 			if utils.UseMsys2() {
-				cgoWindowsMsys2(module)
+				cgoWindowsMsys2(module, mocPath)
 			} else {
-				cgoWindows(module)
+				cgoWindows(module, mocPath)
 			}
 		} else {
-			cgoWindowsForLinux(module)
+			cgoWindowsForLinux(module, mocPath)
 		}
 		if utils.UsePkgConfig() {
-			cgoLinuxPkgConfig(module)
+			cgoLinuxPkgConfig(module, mocPath)
 		} else {
-			cgoLinux(module)
+			cgoLinux(module, mocPath)
 		}
-		cgoSailfish(module)
-		cgoRaspberryPi1(module)
-		cgoRaspberryPi2(module)
-		cgoRaspberryPi3(module)
+		cgoSailfish(module, mocPath)
+		cgoRaspberryPi1(module, mocPath)
+		cgoRaspberryPi2(module, mocPath)
+		cgoRaspberryPi3(module, mocPath)
 
 		if runtime.GOOS == "darwin" {
-			cgoIos(module)
+			cgoIos(module, mocPath)
 		}
 	}
 
 	if strings.Contains(module, "fish") {
-		cgoSailfish(module)
+		cgoSailfish(module, mocPath)
 	} else {
-		cgoAndroid(module)
+		cgoAndroid(module, mocPath)
 	}
 }
 
-func cgoDarwin(module string) {
+func cgoDarwin(module, mocPath string) {
 	var (
 		bb   = new(bytes.Buffer)
 		libs = cleanLibs(module)
@@ -65,7 +55,7 @@ func cgoDarwin(module string) {
 	defer bb.Reset()
 
 	fmt.Fprintf(bb, "// +build !ios%v\n\n", func() string {
-		if Minimal {
+		if parser.CurrentState.Minimal {
 			return ",minimal"
 		}
 		if module == parser.MOC {
@@ -75,8 +65,8 @@ func cgoDarwin(module string) {
 	}())
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -128,10 +118,10 @@ func cgoDarwin(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.SaveBytes(filepath.Join(mocAppPath, "moc_cgo_desktop_darwin_amd64.go"), bb.Bytes())
+			utils.SaveBytes(filepath.Join(mocPath, "moc_cgo_desktop_darwin_amd64.go"), bb.Bytes())
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.SaveBytes(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_desktop_darwin_amd64.go"), bb.Bytes())
 		}
@@ -143,7 +133,7 @@ func cgoDarwin(module string) {
 	}
 }
 
-func cgoWindows(module string) {
+func cgoWindows(module, mocPath string) {
 	var (
 		bb     = new(bytes.Buffer)
 		libs   = cleanLibs(module)
@@ -151,7 +141,7 @@ func cgoWindows(module string) {
 	)
 	defer bb.Reset()
 
-	if Minimal {
+	if parser.CurrentState.Minimal {
 		fmt.Fprint(bb, "// +build minimal\n\n")
 	} else if module == parser.MOC {
 	} else {
@@ -159,8 +149,8 @@ func cgoWindows(module string) {
 	}
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -201,10 +191,10 @@ func cgoWindows(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.SaveBytes(filepath.Join(mocAppPath, "moc_cgo_desktop_windows_386.go"), bb.Bytes())
+			utils.SaveBytes(filepath.Join(mocPath, "moc_cgo_desktop_windows_386.go"), bb.Bytes())
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.SaveBytes(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_desktop_windows_386.go"), bb.Bytes())
 		}
@@ -216,7 +206,7 @@ func cgoWindows(module string) {
 	}
 }
 
-func cgoWindowsForLinux(module string) {
+func cgoWindowsForLinux(module, mocPath string) {
 	var (
 		bb     = new(bytes.Buffer)
 		libs   = cleanLibs(module)
@@ -224,7 +214,7 @@ func cgoWindowsForLinux(module string) {
 	)
 	defer bb.Reset()
 
-	if Minimal {
+	if parser.CurrentState.Minimal {
 		fmt.Fprint(bb, "// +build minimal\n\n")
 	} else if module == parser.MOC {
 	} else {
@@ -232,8 +222,8 @@ func cgoWindowsForLinux(module string) {
 	}
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -277,11 +267,11 @@ func cgoWindowsForLinux(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.Save(filepath.Join(mocAppPath, "moc_cgo_desktop_windows_amd64.go"), tmp64)
-			utils.SaveBytes(filepath.Join(mocAppPath, "moc_cgo_desktop_windows_386.go"), bb.Bytes())
+			utils.Save(filepath.Join(mocPath, "moc_cgo_desktop_windows_amd64.go"), tmp64)
+			utils.SaveBytes(filepath.Join(mocPath, "moc_cgo_desktop_windows_386.go"), bb.Bytes())
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.Save(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_desktop_windows_amd64.go"), tmp64)
 			utils.SaveBytes(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_desktop_windows_386.go"), bb.Bytes())
@@ -295,7 +285,7 @@ func cgoWindowsForLinux(module string) {
 	}
 }
 
-func cgoWindowsMsys2(module string) {
+func cgoWindowsMsys2(module, mocPath string) {
 	var (
 		bb        = new(bytes.Buffer)
 		libs      = cleanLibs(module)
@@ -303,7 +293,7 @@ func cgoWindowsMsys2(module string) {
 	)
 	defer bb.Reset()
 
-	if Minimal {
+	if parser.CurrentState.Minimal {
 		fmt.Fprint(bb, "// +build minimal\n\n")
 	} else if module == parser.MOC {
 	} else {
@@ -311,8 +301,8 @@ func cgoWindowsMsys2(module string) {
 	}
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -357,11 +347,11 @@ func cgoWindowsMsys2(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.Save(filepath.Join(mocAppPath, "moc_cgo_desktop_windows_amd64.go"), tmp64)
-			utils.SaveBytes(filepath.Join(mocAppPath, "moc_cgo_desktop_windows_386.go"), bb.Bytes())
+			utils.Save(filepath.Join(mocPath, "moc_cgo_desktop_windows_amd64.go"), tmp64)
+			utils.SaveBytes(filepath.Join(mocPath, "moc_cgo_desktop_windows_386.go"), bb.Bytes())
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.Save(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_desktop_windows_amd64.go"), tmp64)
 			utils.SaveBytes(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_desktop_windows_386.go"), bb.Bytes())
@@ -375,14 +365,14 @@ func cgoWindowsMsys2(module string) {
 	}
 }
 
-func cgoLinux(module string) {
+func cgoLinux(module, mocPath string) {
 	var (
 		bb   = new(bytes.Buffer)
 		libs = cleanLibs(module)
 	)
 	defer bb.Reset()
 
-	if Minimal {
+	if parser.CurrentState.Minimal {
 		fmt.Fprint(bb, "// +build minimal\n\n")
 	} else if module == parser.MOC {
 	} else {
@@ -390,8 +380,8 @@ func cgoLinux(module string) {
 	}
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -431,10 +421,10 @@ func cgoLinux(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.SaveBytes(filepath.Join(mocAppPath, "moc_cgo_desktop_linux_amd64.go"), bb.Bytes())
+			utils.SaveBytes(filepath.Join(mocPath, "moc_cgo_desktop_linux_amd64.go"), bb.Bytes())
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.SaveBytes(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_desktop_linux_amd64.go"), bb.Bytes())
 		}
@@ -446,14 +436,14 @@ func cgoLinux(module string) {
 	}
 }
 
-func cgoLinuxPkgConfig(module string) {
+func cgoLinuxPkgConfig(module, mocPath string) {
 	var (
 		bb   = new(bytes.Buffer)
 		libs = cleanLibs(module)
 	)
 	defer bb.Reset()
 
-	if Minimal {
+	if parser.CurrentState.Minimal {
 		fmt.Fprint(bb, "// +build minimal\n\n")
 	} else if module == parser.MOC {
 	} else {
@@ -461,8 +451,8 @@ func cgoLinuxPkgConfig(module string) {
 	}
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -508,10 +498,10 @@ func cgoLinuxPkgConfig(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.SaveBytes(filepath.Join(mocAppPath, "moc_cgo_desktop_linux_amd64.go"), bb.Bytes())
+			utils.SaveBytes(filepath.Join(mocPath, "moc_cgo_desktop_linux_amd64.go"), bb.Bytes())
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.SaveBytes(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_desktop_linux_amd64.go"), bb.Bytes())
 		}
@@ -523,7 +513,7 @@ func cgoLinuxPkgConfig(module string) {
 	}
 }
 
-func cgoAndroid(module string) {
+func cgoAndroid(module, mocPath string) {
 	var (
 		bb              = new(bytes.Buffer)
 		libs            = cleanLibs(module)
@@ -533,7 +523,7 @@ func cgoAndroid(module string) {
 	defer bb.Reset()
 
 	fmt.Fprintf(bb, "// +build android%v\n\n", func() string {
-		if Minimal {
+		if parser.CurrentState.Minimal {
 			return ",minimal"
 		}
 		if module == parser.MOC {
@@ -543,8 +533,8 @@ func cgoAndroid(module string) {
 	}())
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -585,10 +575,10 @@ func cgoAndroid(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.SaveBytes(filepath.Join(mocAppPath, "moc_cgo_android_linux_arm.go"), bb.Bytes())
+			utils.SaveBytes(filepath.Join(mocPath, "moc_cgo_android_linux_arm.go"), bb.Bytes())
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.SaveBytes(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_android_linux_arm.go"), bb.Bytes())
 		}
@@ -600,7 +590,7 @@ func cgoAndroid(module string) {
 	}
 }
 
-func cgoIos(module string) string {
+func cgoIos(module, mocPath string) string {
 	var (
 		bb   = new(bytes.Buffer)
 		libs = cleanLibs(module)
@@ -608,7 +598,7 @@ func cgoIos(module string) string {
 	defer bb.Reset()
 
 	fmt.Fprintf(bb, "// +build ${BUILDTARGET}%v\n\n", func() string {
-		if Minimal {
+		if parser.CurrentState.Minimal {
 			return ",minimal"
 		}
 		if module == parser.MOC {
@@ -618,8 +608,8 @@ func cgoIos(module string) string {
 	}())
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -706,10 +696,10 @@ func cgoIos(module string) string {
 		switch {
 		case module == parser.MOC:
 			{
-				return mocAppPath, "moc_"
+				return mocPath, "moc_"
 			}
 
-		case Minimal:
+		case parser.CurrentState.Minimal:
 			{
 				return utils.GoQtPkgPath(strings.ToLower(module)), "minimal_"
 			}
@@ -743,7 +733,7 @@ func cgoIos(module string) string {
 	return ""
 }
 
-func cgoSailfish(module string) {
+func cgoSailfish(module, mocPath string) {
 	var (
 		bb   = new(bytes.Buffer)
 		libs = cleanLibs(module)
@@ -751,7 +741,7 @@ func cgoSailfish(module string) {
 	defer bb.Reset()
 
 	fmt.Fprintf(bb, "// +build ${BUILDTARGET}%v\n\n", func() string {
-		if Minimal {
+		if parser.CurrentState.Minimal {
 			return ",minimal"
 		}
 		if module == parser.MOC {
@@ -761,8 +751,8 @@ func cgoSailfish(module string) {
 	}())
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -806,10 +796,10 @@ func cgoSailfish(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.Save(filepath.Join(mocAppPath, "moc_cgo_sailfish_emulator_linux_386.go"), tmp)
+			utils.Save(filepath.Join(mocPath, "moc_cgo_sailfish_emulator_linux_386.go"), tmp)
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.Save(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_sailfish_emulator_linux_386.go"), tmp)
 		}
@@ -827,10 +817,10 @@ func cgoSailfish(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.Save(filepath.Join(mocAppPath, "moc_cgo_sailfish_linux_arm.go"), tmp)
+			utils.Save(filepath.Join(mocPath, "moc_cgo_sailfish_linux_arm.go"), tmp)
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.Save(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_sailfish_linux_arm.go"), tmp)
 		}
@@ -842,7 +832,7 @@ func cgoSailfish(module string) {
 	}
 }
 
-func cgoRaspberryPi1(module string) {
+func cgoRaspberryPi1(module, mocPath string) {
 	var (
 		bb   = new(bytes.Buffer)
 		libs = cleanLibs(module)
@@ -850,7 +840,7 @@ func cgoRaspberryPi1(module string) {
 	defer bb.Reset()
 
 	fmt.Fprintf(bb, "// +build rpi1%v\n\n", func() string {
-		if Minimal {
+		if parser.CurrentState.Minimal {
 			return ",minimal"
 		}
 		if module == parser.MOC {
@@ -860,8 +850,8 @@ func cgoRaspberryPi1(module string) {
 	}())
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -903,10 +893,10 @@ func cgoRaspberryPi1(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.Save(filepath.Join(mocAppPath, "moc_cgo_rpi1_linux_arm.go"), tmp)
+			utils.Save(filepath.Join(mocPath, "moc_cgo_rpi1_linux_arm.go"), tmp)
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.Save(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_rpi1_linux_arm.go"), tmp)
 		}
@@ -918,7 +908,7 @@ func cgoRaspberryPi1(module string) {
 	}
 }
 
-func cgoRaspberryPi2(module string) {
+func cgoRaspberryPi2(module, mocPath string) {
 	var (
 		bb   = new(bytes.Buffer)
 		libs = cleanLibs(module)
@@ -926,7 +916,7 @@ func cgoRaspberryPi2(module string) {
 	defer bb.Reset()
 
 	fmt.Fprintf(bb, "// +build rpi2%v\n\n", func() string {
-		if Minimal {
+		if parser.CurrentState.Minimal {
 			return ",minimal"
 		}
 		if module == parser.MOC {
@@ -936,8 +926,8 @@ func cgoRaspberryPi2(module string) {
 	}())
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -979,10 +969,10 @@ func cgoRaspberryPi2(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.Save(filepath.Join(mocAppPath, "moc_cgo_rpi2_linux_arm.go"), tmp)
+			utils.Save(filepath.Join(mocPath, "moc_cgo_rpi2_linux_arm.go"), tmp)
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.Save(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_rpi2_linux_arm.go"), tmp)
 		}
@@ -994,7 +984,7 @@ func cgoRaspberryPi2(module string) {
 	}
 }
 
-func cgoRaspberryPi3(module string) {
+func cgoRaspberryPi3(module, mocPath string) {
 	var (
 		bb   = new(bytes.Buffer)
 		libs = cleanLibs(module)
@@ -1002,7 +992,7 @@ func cgoRaspberryPi3(module string) {
 	defer bb.Reset()
 
 	fmt.Fprintf(bb, "// +build rpi3%v\n\n", func() string {
-		if Minimal {
+		if parser.CurrentState.Minimal {
 			return ",minimal"
 		}
 		if module == parser.MOC {
@@ -1012,8 +1002,8 @@ func cgoRaspberryPi3(module string) {
 	}())
 
 	fmt.Fprintf(bb, "package %v\n\n", func() string {
-		if MocModule != "" {
-			return MocModule
+		if parser.CurrentState.MocModule != "" {
+			return parser.CurrentState.MocModule
 		}
 		return strings.ToLower(module)
 	}())
@@ -1055,10 +1045,10 @@ func cgoRaspberryPi3(module string) {
 	switch {
 	case module == parser.MOC:
 		{
-			utils.Save(filepath.Join(mocAppPath, "moc_cgo_rpi3_linux_arm.go"), tmp)
+			utils.Save(filepath.Join(mocPath, "moc_cgo_rpi3_linux_arm.go"), tmp)
 		}
 
-	case Minimal:
+	case parser.CurrentState.Minimal:
 		{
 			utils.Save(utils.GoQtPkgPath(strings.ToLower(module), "minimal_cgo_rpi3_linux_arm.go"), tmp)
 		}
@@ -1073,10 +1063,10 @@ func cgoRaspberryPi3(module string) {
 func cleanLibs(module string) []string {
 
 	if module == parser.MOC || module == "build_ios" {
-		return LibDeps[module]
+		return parser.LibDeps[module]
 	}
 
-	var out = append([]string{module}, LibDeps[module]...)
+	var out = append([]string{module}, parser.LibDeps[module]...)
 	for i, v := range out {
 		if v == "TestLib" {
 			out[i] = "Test"
@@ -1086,7 +1076,7 @@ func cleanLibs(module string) []string {
 }
 
 func GetiOSClang(buildTarget, buildARM string) []string {
-	var tmp = cgoIos("build_ios")
+	var tmp = cgoIos("build_ios", "")
 
 	tmp = strings.Split(tmp, "/*")[1]
 	tmp = strings.Split(tmp, "*/")[0]

internal/binding/templater/enum_cpp.go

@@ -12,7 +12,7 @@ func cppEnum(enum *parser.Enum, value *parser.Value) string {
 }
 
 func cppEnumHeader(enum *parser.Enum, value *parser.Value) string {
-	return fmt.Sprintf("int %v_%v_Type()", enum.Class(), value.Name)
+	return fmt.Sprintf("int %v_%v_Type()", enum.ClassName(), value.Name)
 }
 
 func cppEnumBody(enum *parser.Enum, value *parser.Value) string {
@@ -22,7 +22,7 @@ func cppEnumBody(enum *parser.Enum, value *parser.Value) string {
 		return %v::%v;
 	#else
 		return 0;
-	#endif`, enum.Class(), value.Name)
+	#endif`, enum.ClassName(), value.Name)
 	}
 
 	//needed for msys2 with 5.7 docs
@@ -31,8 +31,8 @@ func cppEnumBody(enum *parser.Enum, value *parser.Value) string {
 		return %v::%v;
 	#else
 		return 0;
-	#endif`, enum.Class(), value.Name)
+	#endif`, enum.ClassName(), value.Name)
 	}
 
-	return fmt.Sprintf("return %v::%v;", enum.Class(), value.Name)
+	return fmt.Sprintf("return %v::%v;", enum.ClassName(), value.Name)
 }

internal/binding/templater/function_cpp.go

@@ -11,7 +11,7 @@ import (
 
 func cppFunctionCallback(function *parser.Function) string {
 	var output = fmt.Sprintf("%v { %v };", cppFunctionCallbackHeader(function), cppFunctionCallbackBody(function))
-	if functionIsSupported(parser.ClassMap[function.Class()], function) {
+	if functionIsSupported(parser.CurrentState.ClassMap[function.ClassName()], function) {
 		return cppFunctionCallbackWithGuards(function, output)
 	}
 	return ""
@@ -45,7 +45,7 @@ func cppFunctionCallbackHeader(function *parser.Function) string {
 			if function.Meta == parser.SIGNAL {
 				return fmt.Sprintf("Signal_%v", strings.Title(function.Name))
 			}
-			if strings.HasPrefix(function.Name, parser.TILDE) && parser.ClassMap[function.Class()].Module != parser.MOC {
+			if strings.HasPrefix(function.Name, parser.TILDE) && parser.CurrentState.ClassMap[function.ClassName()].Module != parser.MOC {
 				return strings.Replace(function.Name, parser.TILDE, fmt.Sprintf("%vMy", parser.TILDE), -1)
 			}
 			return function.Name
@@ -82,7 +82,7 @@ func cppFunctionCallbackBody(function *parser.Function) string {
 		}(),
 
 		func() string {
-			var output = fmt.Sprintf("callback%v_%v%v(%v)", function.Class(), strings.Replace(strings.Title(function.Name), parser.TILDE, "Destroy", -1), function.OverloadNumber, converter.CppInputParametersForCallbackBody(function))
+			var output = fmt.Sprintf("callback%v_%v%v(%v)", function.ClassName(), strings.Replace(strings.Title(function.Name), parser.TILDE, "Destroy", -1), function.OverloadNumber, converter.CppInputParametersForCallbackBody(function))
 
 			if converter.CppHeaderOutput(function) != parser.VOID {
 				output = converter.CppInput(output, function.Output, function)
@@ -114,7 +114,7 @@ func cppFunctionBodyWithGuards(function *parser.Function) string {
 	if function.Default {
 		switch {
 		case
-			strings.HasPrefix(function.Class(), "QMac") && !strings.HasPrefix(parser.ClassMap[function.Class()].Module, "QMac"):
+			strings.HasPrefix(function.ClassName(), "QMac") && !strings.HasPrefix(parser.CurrentState.ClassMap[function.ClassName()].Module, "QMac"):
 			{
 				return fmt.Sprintf("#ifdef Q_OS_OSX\n%v%v\n#endif", cppFunctionBody(function), cppFunctionBodyFailed(function))
 			}
@@ -178,7 +178,7 @@ func cppFunctionBody(function *parser.Function) string {
 		{
 			return fmt.Sprintf("%v\treturn new %v%v(%v);",
 				func() string {
-					if parser.ClassMap[function.Class()].IsSubClass("QCoreApplication") {
+					if parser.CurrentState.ClassMap[function.ClassName()].IsSubClassOf("QCoreApplication") {
 						return `	static int argcs = argc;
 	static char** argvs = static_cast<char**>(malloc(argcs * sizeof(char*)));
 
@@ -192,7 +192,7 @@ func cppFunctionBody(function *parser.Function) string {
 				}(),
 
 				func() string {
-					var class = parser.ClassMap[function.Class()]
+					var class = parser.CurrentState.ClassMap[function.ClassName()]
 					if class.Module != parser.MOC {
 						if classNeedsCallbackFunctions(class) {
 							return "My"
@@ -202,10 +202,10 @@ func cppFunctionBody(function *parser.Function) string {
 				}(),
 
 				func() string {
-					if c := parser.ClassMap[function.Class()]; c != nil && c.Fullname != "" {
+					if c := parser.CurrentState.ClassMap[function.ClassName()]; c != nil && c.Fullname != "" {
 						return c.Fullname
 					}
-					return function.Class()
+					return function.ClassName()
 				}(),
 
 				converter.CppInputParameters(function),
@@ -224,7 +224,7 @@ func cppFunctionBody(function *parser.Function) string {
 
 			if converter.CppHeaderOutput(function) != parser.VOID {
 				functionOutputType = converter.CppInputParametersForSlotArguments(function, &parser.Parameter{Name: "returnArg", Value: function.Output})
-				if function.Output != "void*" && !parser.ClassMap[strings.TrimSuffix(functionOutputType, "*")].IsQObjectSubClass() {
+				if function.Output != "void*" && !parser.CurrentState.ClassMap[strings.TrimSuffix(functionOutputType, "*")].IsSubClassOfQObject() {
 					functionOutputType = strings.TrimSuffix(functionOutputType, "*")
 				}
 				fmt.Fprintf(bb, "%v returnArg;\n\t", functionOutputType)
@@ -232,7 +232,7 @@ func cppFunctionBody(function *parser.Function) string {
 
 			fmt.Fprintf(bb, "QMetaObject::invokeMethod(static_cast<%v*>(ptr), \"%v\"%v%v);",
 
-				function.Class(),
+				function.ClassName(),
 
 				function.Name,
 
@@ -291,27 +291,27 @@ func cppFunctionBody(function *parser.Function) string {
 							return ""
 						}
 						if function.Static {
-							return fmt.Sprintf("%v::", function.Class())
+							return fmt.Sprintf("%v::", function.ClassName())
 						}
 						return fmt.Sprintf("static_cast<%v*>(ptr)->",
 							func() string {
-								if c := parser.ClassMap[function.Class()]; c != nil && c.Fullname != "" {
+								if c := parser.CurrentState.ClassMap[function.ClassName()]; c != nil && c.Fullname != "" {
 									return c.Fullname
 								}
 								if strings.HasSuffix(function.Name, "_atList") {
 									return fmt.Sprintf("%v<%v>", function.Container, strings.TrimPrefix(function.Output, "const "))
 								}
-								return function.Class()
+								return function.ClassName()
 							}(),
 						)
 					}(),
 
 					func() string {
 						if function.Default {
-							if parser.ClassMap[function.Class()].Module == parser.MOC {
-								return fmt.Sprintf("%v::%v", parser.ClassMap[function.Class()].GetBases()[0], function.Name)
+							if parser.CurrentState.ClassMap[function.ClassName()].Module == parser.MOC {
+								return fmt.Sprintf("%v::%v", parser.CurrentState.ClassMap[function.ClassName()].GetBases()[0], function.Name)
 							} else {
-								return fmt.Sprintf("%v::%v", function.Class(), function.Name)
+								return fmt.Sprintf("%v::%v", function.ClassName(), function.Name)
 							}
 						}
 						return function.Name
@@ -328,10 +328,10 @@ func cppFunctionBody(function *parser.Function) string {
 						return function.Fullname
 					}
 					return fmt.Sprintf("static_cast<%v*>(ptr)->%v", func() string {
-						if c := parser.ClassMap[function.Class()]; c != nil && c.Fullname != "" {
+						if c := parser.CurrentState.ClassMap[function.ClassName()]; c != nil && c.Fullname != "" {
 							return c.Fullname
 						}
-						return function.Class()
+						return function.ClassName()
 					}(), function.Name)
 				}()))
 		}
@@ -340,7 +340,7 @@ func cppFunctionBody(function *parser.Function) string {
 		{
 			var function = *function
 			function.Name = function.TmpName
-			function.Fullname = fmt.Sprintf("%v::%v", function.Class(), function.Name)
+			function.Fullname = fmt.Sprintf("%v::%v", function.ClassName(), function.Name)
 
 			return fmt.Sprintf("\t%v = %v;", converter.CppOutputParameters(&function,
 				func() string {
@@ -348,10 +348,10 @@ func cppFunctionBody(function *parser.Function) string {
 						return function.Fullname
 					}
 					return fmt.Sprintf("static_cast<%v*>(ptr)->%v", func() string {
-						if c := parser.ClassMap[function.Class()]; c != nil && c.Fullname != "" {
+						if c := parser.CurrentState.ClassMap[function.ClassName()]; c != nil && c.Fullname != "" {
 							return c.Fullname
 						}
-						return function.Class()
+						return function.ClassName()
 					}(), function.Name)
 				}()),
 
@@ -362,18 +362,18 @@ func cppFunctionBody(function *parser.Function) string {
 	case parser.SIGNAL:
 		{
 			var my string
-			if parser.ClassMap[function.Class()].Module != parser.MOC {
+			if parser.CurrentState.ClassMap[function.ClassName()].Module != parser.MOC {
 				my = "My"
 			}
 			if converter.IsPrivateSignal(function) {
-				return fmt.Sprintf("\tQObject::%v(static_cast<%v*>(ptr), &%v::%v, static_cast<%v%v*>(ptr), static_cast<%v (%v%v::*)(%v)>(&%v%v::Signal_%v%v));", strings.ToLower(function.SignalMode), function.Class(), function.Class(), function.Name, my, function.Class(), function.Output, my, function.Class(), converter.CppInputParametersForSignalConnect(function), my, function.Class(), strings.Title(function.Name), function.OverloadNumber)
+				return fmt.Sprintf("\tQObject::%v(static_cast<%v*>(ptr), &%v::%v, static_cast<%v%v*>(ptr), static_cast<%v (%v%v::*)(%v)>(&%v%v::Signal_%v%v));", strings.ToLower(function.SignalMode), function.ClassName(), function.ClassName(), function.Name, my, function.ClassName(), function.Output, my, function.ClassName(), converter.CppInputParametersForSignalConnect(function), my, function.ClassName(), strings.Title(function.Name), function.OverloadNumber)
 			}
 			return fmt.Sprintf("\tQObject::%v(static_cast<%v*>(ptr), static_cast<%v (%v::*)(%v)>(&%v::%v), static_cast<%v%v*>(ptr), static_cast<%v (%v%v::*)(%v)>(&%v%v::Signal_%v%v));",
 				strings.ToLower(function.SignalMode),
 
-				function.Class(), function.Output, function.Class(), converter.CppInputParametersForSignalConnect(function), function.Class(), function.Name,
+				function.ClassName(), function.Output, function.ClassName(), converter.CppInputParametersForSignalConnect(function), function.ClassName(), function.Name,
 
-				my, function.Class(), function.Output, my, function.Class(), converter.CppInputParametersForSignalConnect(function), my, function.Class(), strings.Title(function.Name), function.OverloadNumber)
+				my, function.ClassName(), function.Output, my, function.ClassName(), converter.CppInputParametersForSignalConnect(function), my, function.ClassName(), strings.Title(function.Name), function.OverloadNumber)
 		}
 	}
 

internal/binding/templater/function_go.go

@@ -12,7 +12,7 @@ import (
 
 func goFunction(function *parser.Function) string {
 	var output = fmt.Sprintf("%v{\n%v\n}", goFunctionHeader(function), goFunctionBody(function))
-	if functionIsSupported(parser.ClassMap[function.Class()], function) {
+	if functionIsSupported(parser.CurrentState.ClassMap[function.ClassName()], function) {
 		if UseStub() {
 			if function.SignalMode != parser.CALLBACK {
 				return output
@@ -30,7 +30,7 @@ func goFunctionHeader(function *parser.Function) string {
 			if function.Static || function.Meta == parser.CONSTRUCTOR || function.SignalMode == parser.CALLBACK {
 				return ""
 			}
-			return fmt.Sprintf("(ptr *%v)", function.Class())
+			return fmt.Sprintf("(ptr *%v)", function.ClassName())
 		}(),
 
 		converter.GoHeaderName(function),
@@ -47,26 +47,26 @@ func goFunctionBody(function *parser.Function) string {
 
 	if strings.ToLower(os.Getenv("QT_DEBUG")) == "true" {
 		fmt.Fprintf(bb, "defer qt.Recover(\"\t%v%v%v(%v) %v\")\n",
-			function.Class(),
+			function.ClassName(),
 
 			func() string {
-				return strings.Repeat(" ", 45-len(function.Class()))
+				return strings.Repeat(" ", 45-len(function.ClassName()))
 			}(),
 
 			converter.GoHeaderName(function), converter.GoHeaderInput(function), converter.GoHeaderOutput(function))
 
 		fmt.Fprintf(bb, "qt.Debug(\"\t%v%v%v(%v) %v\")\n",
 
-			function.Class(),
+			function.ClassName(),
 
 			func() string {
-				return strings.Repeat(" ", 45-len(function.Class()))
+				return strings.Repeat(" ", 45-len(function.ClassName()))
 			}(),
 
 			converter.GoHeaderName(function), converter.GoHeaderInput(function), converter.GoHeaderOutput(function))
 	}
 
-	if parser.ClassMap[function.Class()].Stub {
+	if parser.CurrentState.ClassMap[function.ClassName()].Stub {
 		if converter.GoHeaderOutput(function) != "" {
 			return fmt.Sprintf("\nreturn %v", converter.GoOutputParametersFromCFailed(function))
 		}
@@ -78,7 +78,7 @@ func goFunctionBody(function *parser.Function) string {
 	}
 
 	for _, parameter := range function.Parameters {
-		if parameter.Value == "..." || (parameter.Value == "T" && parser.ClassMap[function.Class()].Module == "QtAndroidExtras" && function.TemplateModeJNI == "") {
+		if parameter.Value == "..." || (parameter.Value == "T" && parser.CurrentState.ClassMap[function.ClassName()].Module == "QtAndroidExtras" && function.TemplateModeJNI == "") {
 			for i := 0; i < 10; i++ {
 				if parameter.Value == "T" {
 					fmt.Fprintf(bb, "var p%v, d%v = assertion(%v, %v)\n", i, i, i, parameter.Name)
@@ -101,9 +101,9 @@ func goFunctionBody(function *parser.Function) string {
 		(function.Meta == parser.GETTER || function.Meta == parser.SETTER) {
 
 		//TODO:
-		if functionIsSupported(parser.ClassMap[function.Class()], function) {
+		if functionIsSupported(parser.CurrentState.ClassMap[function.ClassName()], function) {
 			cppFunction(function)
-			if functionIsSupported(parser.ClassMap[function.Class()], function) {
+			if functionIsSupported(parser.CurrentState.ClassMap[function.ClassName()], function) {
 
 				for _, alloc := range converter.GoInputParametersForCAlloc(function) {
 					fmt.Fprint(bb, alloc)
@@ -113,7 +113,7 @@ func goFunctionBody(function *parser.Function) string {
 				fmt.Fprint(bb, func() string {
 					if converter.GoHeaderOutput(function) != "" {
 						switch {
-						case function.NeedsFinalizer && classIsSupported(parser.ClassMap[converter.CleanValue(function.Output)]) || function.Meta == parser.CONSTRUCTOR && !(classNeedsCallbackFunctions(parser.ClassMap[function.Name]) || parser.ClassMap[function.Name].IsQObjectSubClass()):
+						case function.NeedsFinalizer && classIsSupported(parser.CurrentState.ClassMap[converter.CleanValue(function.Output)]) || function.Meta == parser.CONSTRUCTOR && !(classNeedsCallbackFunctions(parser.CurrentState.ClassMap[function.Name]) || parser.CurrentState.ClassMap[function.Name].IsSubClassOfQObject()):
 							{
 								return fmt.Sprintf("var tmpValue = %v\nruntime.SetFinalizer(tmpValue, (%v).Destroy%v)\nreturn tmpValue%v",
 
@@ -141,14 +141,14 @@ func goFunctionBody(function *parser.Function) string {
 									}())
 							}
 
-						case parser.ClassMap[converter.CleanValue(function.Output)].IsQObjectSubClass() && converter.GoHeaderOutput(function) != "unsafe.Pointer" || function.Meta == parser.CONSTRUCTOR && parser.ClassMap[converter.CleanValue(function.Name)].IsQObjectSubClass():
+						case parser.CurrentState.ClassMap[converter.CleanValue(function.Output)].IsSubClassOfQObject() && converter.GoHeaderOutput(function) != "unsafe.Pointer" || function.Meta == parser.CONSTRUCTOR && parser.CurrentState.ClassMap[converter.CleanValue(function.Name)].IsSubClassOfQObject():
 							{
 								return fmt.Sprintf("var tmpValue = %v\nif !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), \"QObject::destroyed\") {\ntmpValue.ConnectDestroyed(func(%v){ tmpValue.SetPointer(nil) })\n}\nreturn tmpValue",
 
 									body,
 
 									func() string {
-										if parser.ClassMap[function.Class()].Module == "QtCore" {
+										if parser.CurrentState.ClassMap[function.ClassName()].Module == "QtCore" {
 											return "*QObject"
 										}
 										return "*core.QObject"
@@ -179,7 +179,7 @@ func goFunctionBody(function *parser.Function) string {
 						return "\n"
 					}
 					return ""
-				}(), function.Class(), function.Name, function.OverloadNumber)
+				}(), function.ClassName(), function.Name, function.OverloadNumber)
 
 			if converter.GoHeaderOutput(function) == "" {
 				fmt.Fprintf(bb, "signal.(%v)(%v)", converter.GoHeaderInputSignalFunction(function), converter.GoInputParametersForCallback(function))
@@ -199,16 +199,26 @@ func goFunctionBody(function *parser.Function) string {
 			)
 
 			if converter.GoHeaderOutput(function) == "" {
+				var class, _ = function.Class()
+				if class.Module == parser.MOC && function.PureBaseFunction {
+
+				} else {
 					if function.Virtual == parser.IMPURE && functionIsSupportedDefault(function) {
-					fmt.Fprintf(bb, "New%vFromPointer(ptr).%v%vDefault(%v)", strings.Title(function.Class()), strings.Replace(strings.Title(function.Name), parser.TILDE, "Destroy", -1), function.OverloadNumber, converter.GoInputParametersForCallback(function))
+						fmt.Fprintf(bb, "New%vFromPointer(ptr).%v%vDefault(%v)", strings.Title(function.ClassName()), strings.Replace(strings.Title(function.Name), parser.TILDE, "Destroy", -1), function.OverloadNumber, converter.GoInputParametersForCallback(function))
+					}
 				}
+			} else {
+				var class, _ = function.Class()
+				if class.Module == parser.MOC && function.PureBaseFunction {
+					fmt.Fprintf(bb, "\nreturn %v", converter.GoInput(converter.GoOutputParametersFromCFailed(function), function.Output, function))
 				} else {
 					if function.Virtual == parser.IMPURE && functionIsSupportedDefault(function) {
-					fmt.Fprintf(bb, "\nreturn %v", converter.GoInput(fmt.Sprintf("New%vFromPointer(ptr).%v%vDefault(%v)", strings.Title(function.Class()), strings.Replace(strings.Title(function.Name), parser.TILDE, "Destroy", -1), function.OverloadNumber, converter.GoInputParametersForCallback(function)), function.Output, function))
+						fmt.Fprintf(bb, "\nreturn %v", converter.GoInput(fmt.Sprintf("New%vFromPointer(ptr).%v%vDefault(%v)", strings.Title(function.ClassName()), strings.Replace(strings.Title(function.Name), parser.TILDE, "Destroy", -1), function.OverloadNumber, converter.GoInputParametersForCallback(function)), function.Output, function))
 					} else {
 						fmt.Fprintf(bb, "\nreturn %v", converter.GoInput(converter.GoOutputParametersFromCFailed(function), function.Output, function))
 					}
 				}
+			}
 
 			fmt.Fprintf(bb, "%v",
 				func() string {
@@ -228,7 +238,7 @@ func goFunctionBody(function *parser.Function) string {
 			fmt.Fprintf(bb, "\nqt.%vSignal(fmt.Sprint(ptr.Pointer()), \"%v::%v%v\"%v)",
 				function.SignalMode,
 
-				function.Class(),
+				function.ClassName(),
 
 				function.Name,
 
@@ -245,7 +255,7 @@ func goFunctionBody(function *parser.Function) string {
 	}
 
 	if (function.Meta == parser.DESTRUCTOR || strings.Contains(function.Name, "deleteLater") || strings.HasPrefix(function.Name, parser.TILDE)) && function.SignalMode == "" {
-		if classNeedsCallbackFunctions(parser.ClassMap[function.Class()]) || parser.ClassMap[function.Class()].IsQObjectSubClass() {
+		if classNeedsCallbackFunctions(parser.CurrentState.ClassMap[function.ClassName()]) || parser.CurrentState.ClassMap[function.ClassName()].IsSubClassOfQObject() {
 			fmt.Fprint(bb, "\nqt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))")
 		}
 		fmt.Fprint(bb, "\nptr.SetPointer(nil)")

internal/binding/templater/helper.go

@@ -1,7 +1,6 @@
 package templater
 
 import (
-	"runtime"
 	"sort"
 	"strings"
 
@@ -13,8 +12,8 @@ func functionIsSupported(_ *parser.Class, f *parser.Function) bool {
 
 	switch {
 	case
-		(f.Class() == "QAccessibleObject" || f.Class() == "QAccessibleInterface" || f.Class() == "QAccessibleWidget" || //QAccessible::State -> quint64
-			f.Class() == "QAccessibleStateChangeEvent") && (f.Name == "state" || f.Name == "changedStates" || f.Name == "m_changedStates" || f.Name == "setM_changedStates" || f.Meta == parser.CONSTRUCTOR),
+		(f.ClassName() == "QAccessibleObject" || f.ClassName() == "QAccessibleInterface" || f.ClassName() == "QAccessibleWidget" || //QAccessible::State -> quint64
+			f.ClassName() == "QAccessibleStateChangeEvent") && (f.Name == "state" || f.Name == "changedStates" || f.Name == "m_changedStates" || f.Name == "setM_changedStates" || f.Meta == parser.CONSTRUCTOR),
 
 		f.Fullname == "QPixmapCache::find" && f.OverloadNumber == "4", //Qt::Key -> int
 		(f.Fullname == "QPixmapCache::remove" || f.Fullname == "QPixmapCache::insert") && f.OverloadNumber == "2",
@@ -22,26 +21,26 @@ func functionIsSupported(_ *parser.Class, f *parser.Function) bool {
 
 		f.Fullname == "QNdefFilter::appendRecord" && !f.Overload, //QNdefRecord::TypeNameFormat -> uint
 
-		f.Class() == "QSimpleXmlNodeModel" && f.Meta == parser.CONSTRUCTOR,
+		f.ClassName() == "QSimpleXmlNodeModel" && f.Meta == parser.CONSTRUCTOR,
 
 		f.Fullname == "QSGMaterialShader::attributeNames",
 
-		f.Class() == "QVariant" && (f.Name == "value" || f.Name == "canConvert"), //needs template
+		f.ClassName() == "QVariant" && (f.Name == "value" || f.Name == "canConvert"), //needs template
 
 		f.Fullname == "QNdefRecord::isRecordType", f.Fullname == "QScriptEngine::scriptValueFromQMetaObject", //needs template
 		f.Fullname == "QScriptEngine::fromScriptValue", f.Fullname == "QJSEngine::fromScriptValue",
 
-		f.Class() == "QMetaType" && //needs template
+		f.ClassName() == "QMetaType" && //needs template
 			(f.Name == "hasRegisteredComparators" || f.Name == "registerComparators" ||
 				f.Name == "hasRegisteredConverterFunction" || f.Name == "registerConverter" ||
 				f.Name == "registerEqualsComparator"),
 
-		parser.ClassMap[f.Class()].Module == parser.MOC && f.Name == "metaObject", //needed for qtmoc
+		parser.CurrentState.ClassMap[f.ClassName()].Module == parser.MOC && f.Name == "metaObject", //needed for qtmoc
 
 		f.Fullname == "QSignalBlocker::QSignalBlocker" && f.OverloadNumber == "3", //undefined symbol
 
-		(parser.ClassMap[f.Class()].IsSubClass("QCoreApplication") ||
-			f.Class() == "QAudioInput" || f.Class() == "QAudioOutput") && f.Name == "notify", //redeclared (name collision with QObject)
+		(parser.CurrentState.ClassMap[f.ClassName()].IsSubClassOf("QCoreApplication") ||
+			f.ClassName() == "QAudioInput" || f.ClassName() == "QAudioOutput") && f.Name == "notify", //redeclared (name collision with QObject)
 
 		f.Fullname == "QGraphicsItem::isBlockedByModalPanel", //** problem
 
@@ -87,7 +86,7 @@ func functionIsSupported(_ *parser.Class, f *parser.Function) bool {
 		return functionIsSupportedDefault(f)
 	}
 
-	if Minimal {
+	if parser.CurrentState.Minimal {
 		return f.Export || f.Meta == parser.DESTRUCTOR || f.Fullname == "QObject::destroyed" || strings.HasPrefix(f.Name, parser.TILDE)
 	}
 
@@ -132,11 +131,11 @@ func functionIsSupportedDefault(f *parser.Function) bool {
 	}
 
 	//needed for moc
-	if parser.ClassMap[f.Class()].IsSubClass("QCoreApplication") && (f.Name == "autoMaximizeThreshold" || f.Name == "setAutoMaximizeThreshold") {
+	if parser.CurrentState.ClassMap[f.ClassName()].IsSubClassOf("QCoreApplication") && (f.Name == "autoMaximizeThreshold" || f.Name == "setAutoMaximizeThreshold") {
 		return false
 	}
 
-	if Minimal {
+	if parser.CurrentState.Minimal {
 		return f.Export
 	}
 
@@ -185,7 +184,7 @@ func classIsSupported(c *parser.Class) bool {
 		}
 	}
 
-	if Minimal {
+	if parser.CurrentState.Minimal {
 		return c.Export
 	}
 
@@ -193,11 +192,11 @@ func classIsSupported(c *parser.Class) bool {
 }
 
 func hasUnimplementedPureVirtualFunctions(className string) bool {
-	for _, f := range parser.ClassMap[className].Functions {
+	for _, f := range parser.CurrentState.ClassMap[className].Functions {
 		var f = *f
 		cppFunction(&f)
 
-		if f.Virtual == parser.PURE && !functionIsSupported(parser.ClassMap[className], &f) {
+		if f.Virtual == parser.PURE && !functionIsSupported(parser.CurrentState.ClassMap[className], &f) {
 			return true
 		}
 	}
@@ -254,121 +253,9 @@ var Build = map[string]bool{
 	"Sailfish": false,
 }
 
-var Libs = []string{
-	"Core",
-	"AndroidExtras",
-	"Gui",
-	"Network",
-	"Xml",
-	"DBus",
-	"Nfc",
-	"Script", //depreached (planned) in 5.6
-	"Sensors",
-	"Positioning",
-	"Widgets",
-	"Sql",
-	"MacExtras",
-	"Qml",
-	"WebSockets",
-	"XmlPatterns",
-	"Bluetooth",
-	"WebChannel",
-	"Svg",
-	"Multimedia",
-	"Quick",
-	"Help",
-	"Location",
-	"ScriptTools", //depreached (planned) in 5.6
-	"UiTools",
-	"X11Extras",
-	"WinExtras",
-	"WebEngine",
-	"TestLib",
-	"SerialPort",
-	"SerialBus",
-	"PrintSupport",
-	//"PlatformHeaders", //missing imports/guards
-	"Designer",
-	"Scxml",
-	"Gamepad",
-
-	"Purchasing", //GPLv3 & LGPLv3
-	//"DataVisualization", //GPLv3
-	//"Charts",            //GPLv3
-	//"Quick2DRenderer",   //GPLv3
-
-	"Sailfish",
-}
-
-func GetLibs() []string {
-	for i := len(Libs) - 1; i >= 0; i-- {
-		switch {
-		case
-			!(runtime.GOOS == "darwin" || runtime.GOOS == "linux") && Libs[i] == "WebEngine",
-			runtime.GOOS != "windows" && Libs[i] == "WinExtras",
-			runtime.GOOS != "darwin" && Libs[i] == "MacExtras",
-			runtime.GOOS != "linux" && Libs[i] == "X11Extras":
-			{
-				Libs = append(Libs[:i], Libs[i+1:]...)
-			}
-		}
-	}
-
-	return Libs
-}
-
-var LibDeps = map[string][]string{
-	"Core":          {"Widgets", "Gui"}, //Widgets, Gui
-	"AndroidExtras": {"Core"},
-	"Gui":           {"Widgets", "Core"}, //Widgets
-	"Network":       {"Core"},
-	"Xml":           {"XmlPatterns", "Core"}, //XmlPatterns
-	"DBus":          {"Core"},
-	"Nfc":           {"Core"},
-	"Script":        {"Core"},
-	"Sensors":       {"Core"},
-	"Positioning":   {"Core"},
-	"Widgets":       {"Gui", "Core"},
-	"Sql":           {"Widgets", "Gui", "Core"}, //Widgets, Gui
-	"MacExtras":     {"Gui", "Core"},
-	"Qml":           {"Network", "Core"},
-	"WebSockets":    {"Network", "Core"},
-	"XmlPatterns":   {"Network", "Core"},
-	"Bluetooth":     {"Core"},
-	"WebChannel":    {"Network", "Qml", "Core"}, //Network (needed for static linking ios)
-	"Svg":           {"Widgets", "Gui", "Core"},
-	"Multimedia":    {"MultimediaWidgets", "Widgets", "Network", "Gui", "Core"},   //MultimediaWidgets, Widgets
-	"Quick":         {"QuickWidgets", "Widgets", "Network", "Qml", "Gui", "Core"}, //QuickWidgets, Widgets, Network (needed for static linking ios)
-	"Help":          {"Sql", "CLucene", "Network", "Widgets", "Gui", "Core"},      //Sql + CLucene + Network (needed for static linking ios)
-	"Location":      {"Positioning", "Quick", "Gui", "Core"},
-	"ScriptTools":   {"Script", "Widgets", "Core"}, //Script, Widgets
-	"UiTools":       {"Widgets", "Gui", "Core"},
-	"X11Extras":     {"Gui", "Core"},
-	"WinExtras":     {"Gui", "Core"},
-	"WebEngine":     {"Widgets", "WebEngineWidgets", "WebChannel", "Network", "WebEngineCore", "Quick", "Gui", "Qml", "Core"}, //Widgets, WebEngineWidgets, WebChannel, Network
-	"TestLib":       {"Widgets", "Gui", "Core"},                                                                               //Widgets, Gui
-	"SerialPort":    {"Core"},
-	"SerialBus":     {"Core"},
-	"PrintSupport":  {"Widgets", "Gui", "Core"},
-	//"PlatformHeaders": []string{}, //TODO:
-	"Designer": {"UiPlugin", "Widgets", "Gui", "Xml", "Core"},
-	"Scxml":    {"Network", "Qml", "Core"}, //Network (needed for static linking ios)
-	"Gamepad":  {"Gui", "Core"},
-
-	"Purchasing": {"Core"},
-	//"DataVisualization": []string{"Gui", "Core"},
-	//"Charts":            []string{"Widgets", "Gui", "Core"},
-	//"Quick2DRenderer":   []string{}, //TODO:
-
-	"Sailfish": {"Core"},
-
-	parser.MOC:  make([]string, 0),
-	"build_ios": {"Core", "Gui", "Network", "Sql", "Xml", "DBus", "Nfc", "Script", "Sensors", "Positioning", "Widgets", "Qml", "WebSockets", "XmlPatterns", "Bluetooth", "WebChannel", "Svg", "Multimedia", "Quick", "Help", "Location", "ScriptTools", "MultimediaWidgets", "UiTools", "PrintSupport"},
-}
-
 func isGeneric(f *parser.Function) bool {
 
-	if f.Class() == "QAndroidJniObject" {
+	if f.ClassName() == "QAndroidJniObject" {
 		switch f.Name {
 		case
 			"callMethod",
@@ -419,7 +306,7 @@ func shortModule(module string) string {
 
 func getSortedClassNamesForModule(module string) []string {
 	var output = make([]string, 0)
-	for _, class := range parser.ClassMap {
+	for _, class := range parser.CurrentState.ClassMap {
 		if class.Module == module {
 			output = append(output, class.Name)
 		}
@@ -434,31 +321,11 @@ func getSortedClassesForModule(module string) []*parser.Class {
 		output     = make([]*parser.Class, len(classNames))
 	)
 	for i, name := range classNames {
-		output[i] = parser.ClassMap[name]
+		output[i] = parser.CurrentState.ClassMap[name]
 	}
 	return output
 }
 
-func manualWeakLink(module string) {
-	for _, class := range getSortedClassesForModule(module) {
-		class.WeakLink = make(map[string]bool)
-
-		switch class.Module {
-		case "QtCore":
-			{
-				class.WeakLink["QtGui"] = true
-				class.WeakLink["QtWidgets"] = true
-			}
-
-		case "QtGui":
-			{
-				class.WeakLink["QtWidgets"] = true
-				class.WeakLink["QtMultimedia"] = true
-			}
-		}
-	}
-}
-
 func classNeedsDestructor(c *parser.Class) bool {
 	for _, f := range c.Functions {
 		if f.Meta == parser.DESTRUCTOR {
@@ -469,5 +336,5 @@ func classNeedsDestructor(c *parser.Class) bool {
 }
 
 func UseStub() bool {
-	return utils.QT_STUB() && !Minimal && !Moc && !(CurrentModule == "AndroidExtras" || CurrentModule == "Sailfish")
+	return utils.QT_STUB() && !parser.CurrentState.Minimal && !parser.CurrentState.Moc && !(parser.CurrentState.CurrentModule == "AndroidExtras" || parser.CurrentState.CurrentModule == "Sailfish")
 }

internal/binding/templater/template_c.go

@@ -0,0 +1,110 @@
+package templater
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	"github.com/therecipe/qt/internal/binding/converter"
+	"github.com/therecipe/qt/internal/binding/parser"
+)
+
+func test(bb *bytes.Buffer, class *parser.Class, fu func(*parser.Function) string, del string) {
+	var implementedVirtuals = make(map[string]struct{})
+
+	//all class fs
+	for _, f := range class.Functions {
+		if !functionIsSupported(class, f) {
+			continue
+		}
+		implementedVirtuals[fmt.Sprint(f.Name, f.OverloadNumber)] = struct{}{}
+
+		switch {
+		case f.Meta == parser.SIGNAL:
+			{
+				for _, signalMode := range []string{parser.CONNECT, parser.DISCONNECT} {
+					var f = *f
+					f.SignalMode = signalMode
+					fmt.Fprintf(bb, "%v%v", fu(&f), del)
+				}
+
+				var f = *f
+				f.Meta = parser.PLAIN
+				if converter.IsPrivateSignal(&f) {
+					continue
+				}
+				fmt.Fprintf(bb, "%v%v", fu(&f), del)
+			}
+
+		case (f.Virtual == parser.IMPURE || f.Virtual == parser.PURE) && !strings.Contains(f.Meta, "constructor"):
+			{
+				var f = *f
+				if f.Meta != parser.SLOT {
+					f.Meta = parser.PLAIN
+				}
+
+				fmt.Fprintf(bb, "%v%v", fu(&f), del)
+				if f.Virtual == parser.IMPURE {
+					f.Meta = parser.PLAIN
+					f.Default = true
+					fmt.Fprintf(bb, "%v%v", fu(&f), del)
+				}
+			}
+
+		case isGeneric(f):
+			{
+				for _, mode := range converter.CppOutputParametersJNIGenericModes(f) {
+					var f = *f
+					f.TemplateModeJNI = mode
+
+					fmt.Fprintf(bb, "%v%v", fu(&f), del)
+				}
+			}
+
+		default:
+			{
+				if !(f.Meta == parser.CONSTRUCTOR && hasUnimplementedPureVirtualFunctions(class.Name)) {
+					fmt.Fprintf(bb, "%v%v", fu(f), del)
+				}
+			}
+		}
+
+	}
+
+	//virtual parent functions
+	for _, parentClassName := range class.GetAllBases() {
+		var parentClass = parser.CurrentState.ClassMap[parentClassName]
+		if classIsSupported(parentClass) {
+
+			for _, f := range parentClass.Functions {
+				if _, exists := implementedVirtuals[fmt.Sprint(f.Name, f.OverloadNumber)]; !exists {
+					implementedVirtuals[fmt.Sprint(f.Name, f.OverloadNumber)] = struct{}{}
+
+					if functionIsSupported(parentClass, f) {
+						if f.Meta != parser.SIGNAL && (f.Virtual == parser.IMPURE || f.Virtual == parser.PURE || f.Meta == parser.SLOT) && !strings.Contains(f.Meta, "structor") {
+
+							var f = *f
+							f.Fullname = fmt.Sprintf("%v::%v", class.Name, f.Name)
+							if f.Meta != parser.SLOT {
+								f.Meta = parser.PLAIN
+							}
+							fmt.Fprintf(bb, "%v%v", fu(&f), del)
+
+							var class, exist = f.Class()
+							if !exist || (class.Module == parser.MOC && f.Virtual == parser.PURE) {
+								continue
+							}
+
+							f.Meta = parser.PLAIN
+							f.Default = true
+							fmt.Fprintf(bb, "%v%v", fu(&f), del)
+
+						}
+					}
+
+				}
+			}
+
+		}
+	}
+}

internal/binding/templater/template_cpp.go

@@ -20,7 +20,7 @@ func CppTemplate(module string) []byte {
 		var items = make(map[string]string)
 
 		for _, class := range tmpArray {
-			items[class] = parser.ClassMap[class].Bases
+			items[class] = parser.CurrentState.ClassMap[class].Bases
 		}
 
 		var provided = make([]string, 0)
@@ -28,7 +28,7 @@ func CppTemplate(module string) []byte {
 		for len(items) > 0 {
 			for item, dependency := range items {
 				var existsInOtherModule bool
-				if parser.ClassMap[dependency].Module != parser.MOC {
+				if parser.CurrentState.ClassMap[dependency].Module != parser.MOC {
 					existsInOtherModule = true
 				}
 				var existsInCurrentOrder bool
@@ -49,7 +49,7 @@ func CppTemplate(module string) []byte {
 	}
 
 	for _, className := range tmpArray {
-		var class = parser.ClassMap[className]
+		var class = parser.CurrentState.ClassMap[className]
 
 		//all class enums
 		for _, enum := range class.Enums {
@@ -61,7 +61,7 @@ func CppTemplate(module string) []byte {
 		}
 
 		if classIsSupported(class) {
-			var implementedVirtuals = make(map[string]bool)
+			var implementedVirtuals = make(map[string]struct{})
 
 			if classNeedsCallbackFunctions(class) || class.Module == parser.MOC {
 
@@ -116,7 +116,7 @@ func CppTemplate(module string) []byte {
 										return "My"
 									}(),
 
-									function.Class(),
+									function.ClassName(),
 
 									strings.Split(strings.Split(function.Signature, "(")[1], ")")[0],
 
@@ -124,7 +124,7 @@ func CppTemplate(module string) []byte {
 										if module == parser.MOC {
 											return class.GetBases()[0]
 										}
-										return function.Class()
+										return function.ClassName()
 									}(),
 
 									strings.Join(input, ", "),
@@ -137,7 +137,7 @@ func CppTemplate(module string) []byte {
 
 				//all class functions
 				for _, function := range class.Functions {
-					implementedVirtuals[fmt.Sprint(function.Fullname, function.OverloadNumber)] = true
+					implementedVirtuals[fmt.Sprint(function.Fullname, function.OverloadNumber)] = struct{}{}
 					if functionIsSupported(class, function) && !strings.Contains(function.Meta, "constructor") {
 						if function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SIGNAL || function.Meta == parser.SLOT {
 							if !(module == parser.MOC && function.Meta == parser.SLOT) {
@@ -149,12 +149,12 @@ func CppTemplate(module string) []byte {
 
 				//virtual parent functions
 				for _, parentClassName := range class.GetAllBases() {
-					var parentClass = parser.ClassMap[parentClassName]
+					var parentClass = parser.CurrentState.ClassMap[parentClassName]
 					if classIsSupported(parentClass) {
 
 						for _, function := range parentClass.Functions {
 							if _, exists := implementedVirtuals[fmt.Sprint(fmt.Sprintf("%v::%v", class.Name, function.Name), function.OverloadNumber)]; !exists {
-								implementedVirtuals[fmt.Sprint(fmt.Sprintf("%v::%v", class.Name, function.Name), function.OverloadNumber)] = true
+								implementedVirtuals[fmt.Sprint(fmt.Sprintf("%v::%v", class.Name, function.Name), function.OverloadNumber)] = struct{}{}
 								if functionIsSupported(class, function) && !strings.Contains(function.Meta, "structor") {
 
 									var function = *function
@@ -194,96 +194,7 @@ func CppTemplate(module string) []byte {
 				fmt.Fprintf(bb, "Q_DECLARE_METATYPE(%v*)\n\n", class.Name)
 			}
 
-			implementedVirtuals = make(map[string]bool)
-
-			//all class functions
-			for _, function := range class.Functions {
-				implementedVirtuals[fmt.Sprint(function.Fullname, function.OverloadNumber)] = true
-				if functionIsSupported(class, function) {
-
-					switch {
-					case function.Meta == parser.SIGNAL:
-						{
-							for _, signalMode := range []string{parser.CONNECT, parser.DISCONNECT} {
-								var function = *function
-								function.SignalMode = signalMode
-
-								fmt.Fprintf(bb, "%v\n\n", cppFunction(&function))
-							}
-
-							var function = *function
-							function.Meta = parser.PLAIN
-							if !converter.IsPrivateSignal(&function) {
-								fmt.Fprintf(bb, "%v\n\n", cppFunction(&function))
-							}
-						}
-
-					case (function.Virtual == parser.IMPURE || function.Virtual == parser.PURE) && !strings.Contains(function.Meta, "constructor"):
-						{
-							var function = *function
-							if function.Meta != parser.SLOT {
-								function.Meta = parser.PLAIN
-							}
-
-							fmt.Fprintf(bb, "%v\n\n", cppFunction(&function))
-							if function.Virtual == parser.IMPURE {
-								function.Meta = parser.PLAIN
-								function.Default = true
-								fmt.Fprintf(bb, "%v\n\n", cppFunction(&function))
-							}
-						}
-
-					case isGeneric(function):
-						{
-							for _, mode := range converter.CppOutputParametersJNIGenericModes(function) {
-								var function = *function
-								function.TemplateModeJNI = mode
-
-								fmt.Fprintf(bb, "%v\n\n", cppFunction(&function))
-							}
-						}
-
-					default:
-						{
-							if !(function.Meta == parser.CONSTRUCTOR && hasUnimplementedPureVirtualFunctions(class.Name)) {
-								fmt.Fprintf(bb, "%v\n\n", cppFunction(function))
-							}
-						}
-					}
-				}
-			}
-
-			//virtual parent functions
-			for _, parentClassName := range class.GetAllBases() {
-				var parentClass = parser.ClassMap[parentClassName]
-				if classIsSupported(parentClass) {
-
-					for _, function := range parentClass.Functions {
-						if _, exists := implementedVirtuals[fmt.Sprint(fmt.Sprintf("%v::%v", class.Name, function.Name), function.OverloadNumber)]; !exists {
-							implementedVirtuals[fmt.Sprint(fmt.Sprintf("%v::%v", class.Name, function.Name), function.OverloadNumber)] = true
-
-							if functionIsSupported(parentClass, function) {
-								if function.Meta != parser.SIGNAL && (function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SLOT) && !strings.Contains(function.Meta, "structor") {
-
-									var function = *function
-									function.Fullname = fmt.Sprintf("%v::%v", class.Name, function.Name)
-									if function.Meta != parser.SLOT {
-										function.Meta = parser.PLAIN
-									}
-									fmt.Fprintf(bb, "%v\n\n", cppFunction(&function))
-
-									function.Meta = parser.PLAIN
-									function.Default = true
-									fmt.Fprintf(bb, "%v\n\n", cppFunction(&function))
-
-								}
-							}
-
-						}
-					}
-
-				}
-			}
+			test(bb, class, cppFunction, "\n\n")
 
 		}
 
@@ -307,7 +218,7 @@ func preambleCpp(module string, input []byte) []byte {
 `,
 		func() string {
 			switch {
-			case Minimal:
+			case parser.CurrentState.Minimal:
 				{
 					return "// +build minimal"
 				}
@@ -353,7 +264,7 @@ func preambleCpp(module string, input []byte) []byte {
 
 			default:
 				{
-					if Minimal {
+					if parser.CurrentState.Minimal {
 						return fmt.Sprintf("%v-minimal", shortModule(module))
 					}
 					return shortModule(module)
@@ -363,7 +274,7 @@ func preambleCpp(module string, input []byte) []byte {
 	)
 
 	var classes = make([]string, 0)
-	for _, class := range parser.ClassMap {
+	for _, class := range parser.CurrentState.ClassMap {
 		if strings.Contains(string(input), class.Name) && !(strings.HasPrefix(class.Name, "Qt") || class.Module == parser.MOC) {
 			classes = append(classes, class.Name)
 		}
@@ -374,7 +285,7 @@ func preambleCpp(module string, input []byte) []byte {
 		if class == "SailfishApp" {
 			fmt.Fprintln(bb, "#include <sailfishapp.h>")
 		} else {
-			if strings.HasPrefix(class, "Q") {
+			if strings.HasPrefix(class, "Q") && !(class == "QBluetooth" || class == "QDBus" || class == "QCss" || class == "QPdf" || class == "QSsl" || class == "QPrint" || class == "QScript" || class == "QSql" || class == "QTest" || class == "QWebSocketProtocol") {
 				fmt.Fprintf(bb, "#include <%v>\n", class)
 			}
 		}

internal/binding/templater/template_go.go

@@ -28,7 +28,7 @@ func GoTemplate(module string, stub bool) []byte {
 
 		class.Stub = UseStub() || stub
 
-		if !Minimal || (Minimal && class.Export) {
+		if !parser.CurrentState.Minimal || (parser.CurrentState.Minimal && class.Export) {
 
 			if module != parser.MOC {
 				fmt.Fprintf(bb, "type %v struct {\n%v\n}\n\n",
@@ -44,7 +44,7 @@ func GoTemplate(module string, stub bool) []byte {
 						defer bb.Reset()
 
 						for _, parentClassName := range class.GetBases() {
-							var parentClass = parser.ClassMap[parentClassName]
+							var parentClass = parser.CurrentState.ClassMap[parentClassName]
 							if parentClass.Module == class.Module {
 								fmt.Fprintf(bb, "%v\n", parentClassName)
 							} else {
@@ -66,7 +66,7 @@ func GoTemplate(module string, stub bool) []byte {
 					defer bb.Reset()
 
 					for _, parentClassName := range class.GetBases() {
-						var parentClass = parser.ClassMap[parentClassName]
+						var parentClass = parser.CurrentState.ClassMap[parentClassName]
 						if parentClass.Module == class.Module {
 							fmt.Fprintf(bb, "%v_ITF\n", parentClassName)
 						} else {
@@ -135,7 +135,7 @@ ptr.SetPointer(nil)
 }
 
 `, class.Name, class.Name, func() string {
-						if classNeedsCallbackFunctions(class) || class.IsQObjectSubClass() {
+						if classNeedsCallbackFunctions(class) || class.IsSubClassOfQObject() {
 							return "\nqt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()))"
 						}
 						return ""
@@ -146,11 +146,11 @@ ptr.SetPointer(nil)
 
 		if classIsSupported(class) {
 
-			var implementedVirtuals = make(map[string]bool)
+			var implementedVirtuals = make(map[string]struct{})
 
 			//all class functions
 			for _, function := range class.Functions {
-				implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = true
+				implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = struct{}{}
 
 				if functionIsSupported(class, function) {
 
@@ -218,21 +218,24 @@ ptr.SetPointer(nil)
 
 			//virtual parent functions
 			for _, parentClassName := range class.GetAllBases() {
-				var parentClass = parser.ClassMap[parentClassName]
+				var parentClass = parser.CurrentState.ClassMap[parentClassName]
 				if classIsSupported(parentClass) {
 
 					for _, function := range parentClass.Functions {
 						if _, exists := implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)]; !exists {
-							implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = true
+							implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = struct{}{}
 
 							if functionIsSupported(parentClass, function) {
 								if function.Meta != parser.SIGNAL && (function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SLOT) && !strings.Contains(function.Meta, "structor") {
 
 									for _, signalMode := range []string{parser.CALLBACK, parser.CONNECT, parser.DISCONNECT} {
+										var pbf = function.Virtual == parser.PURE
+
 										var function = *function
 										function.Fullname = fmt.Sprintf("%v::%v", class.Name, function.Name)
 										function.Virtual = parser.IMPURE
 										function.SignalMode = signalMode
+										function.PureBaseFunction = pbf
 
 										fmt.Fprintf(bb, "%v%v\n\n",
 											func() string {
@@ -253,6 +256,11 @@ ptr.SetPointer(nil)
 									}
 									fmt.Fprintf(bb, "%v\n\n", goFunction(&function))
 
+									var class, exist = function.Class()
+									if !exist || (class.Module == parser.MOC && function.Virtual == parser.PURE) {
+										continue
+									}
+
 									function.Meta = parser.PLAIN
 									function.Default = true
 									fmt.Fprintf(bb, "%v\n\n", goFunction(&function))
@@ -285,8 +293,8 @@ package %v
 import "C"
 import (
 `, func() string {
-			if MocModule != "" {
-				return MocModule
+			if parser.CurrentState.MocModule != "" {
+				return parser.CurrentState.MocModule
 			}
 			return module
 		}())
@@ -313,7 +321,7 @@ import (
 						return "// +build !sailfish,!sailfish_emulator"
 					}
 
-				case Minimal:
+				case parser.CurrentState.Minimal:
 					{
 						return "// +build minimal"
 					}
@@ -341,14 +349,14 @@ import (
 			}(),
 
 			func() string {
-				if MocModule != "" {
-					return MocModule
+				if parser.CurrentState.MocModule != "" {
+					return parser.CurrentState.MocModule
 				}
 				return module
 			}(),
 
 			func() string {
-				if Minimal {
+				if parser.CurrentState.Minimal {
 					return fmt.Sprintf("%v-minimal", module)
 				}
 
@@ -377,7 +385,7 @@ import (
 		)
 	}
 
-	for _, m := range append(Libs, "qt", "strings", "unsafe", "log", "runtime", "fmt") {
+	for _, m := range append(parser.Libs, "qt", "strings", "unsafe", "log", "runtime", "fmt") {
 		m = strings.ToLower(m)
 		if strings.Contains(string(input), fmt.Sprintf("%v.", m)) {
 			switch m {
@@ -396,7 +404,7 @@ import (
 					fmt.Fprintf(bb, "\"github.com/therecipe/qt/%v\"\n", m)
 
 					if module == parser.MOC {
-						LibDeps[parser.MOC] = append(LibDeps[parser.MOC], strings.Title(m))
+						parser.LibDeps[parser.MOC] = append(parser.LibDeps[parser.MOC], strings.Title(m))
 					}
 				}
 			}
@@ -415,7 +423,7 @@ import (
 }
 
 func renameSubClasses(in []byte, r string) []byte {
-	for _, c := range parser.ClassMap {
+	for _, c := range parser.CurrentState.ClassMap {
 		if c.Fullname != "" {
 			in = []byte(strings.Replace(string(in), c.Name, strings.Replace(c.Fullname, "::", r, -1), -1))
 			in = []byte(strings.Replace(string(in), "C."+strings.Replace(c.Fullname, "::", r, -1), "C."+c.Name, -1))

internal/binding/templater/template_h.go

@@ -29,7 +29,7 @@ extern "C" {
 `,
 		func() string {
 			switch {
-			case Minimal:
+			case parser.CurrentState.Minimal:
 				{
 					return "// +build minimal"
 				}
@@ -63,7 +63,6 @@ extern "C" {
 	fmt.Fprintf(bb, "struct %v_PackedList { void* data; long long len; };\n", strings.Title(module))
 
 	for _, class := range getSortedClassesForModule(module) {
-		var implementedVirtuals = make(map[string]bool)
 
 		//all class enums
 		for _, enum := range class.Enums {
@@ -76,95 +75,7 @@ extern "C" {
 
 		if classIsSupported(class) {
 
-			//all class functions
-			for _, function := range class.Functions {
-				implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = true
-				if functionIsSupported(class, function) {
-
-					switch {
-					case function.Meta == parser.SIGNAL:
-						{
-							for _, signalMode := range []string{parser.CONNECT, parser.DISCONNECT} {
-								var function = *function
-								function.SignalMode = signalMode
-
-								fmt.Fprintf(bb, "%v;\n", cppFunctionHeader(&function))
-							}
-
-							var function = *function
-							function.Meta = parser.PLAIN
-							if !converter.IsPrivateSignal(&function) {
-								fmt.Fprintf(bb, "%v;\n", cppFunctionHeader(&function))
-							}
-						}
-
-					case (function.Virtual == parser.IMPURE || function.Virtual == parser.PURE) && !strings.Contains(function.Meta, "constructor"):
-						{
-							var function = *function
-							if function.Meta != parser.SLOT {
-								function.Meta = parser.PLAIN
-							}
-
-							fmt.Fprintf(bb, "%v;\n", cppFunctionHeader(&function))
-							if function.Virtual == parser.IMPURE {
-								function.Meta = parser.PLAIN
-								function.Default = true
-								fmt.Fprintf(bb, "%v;\n", cppFunctionHeader(&function))
-							}
-						}
-
-					case isGeneric(function):
-						{
-							for _, mode := range converter.CppOutputParametersJNIGenericModes(function) {
-								var function = *function
-								function.TemplateModeJNI = mode
-
-								fmt.Fprintf(bb, "%v;\n", cppFunctionHeader(&function))
-							}
-						}
-
-					default:
-						{
-							if !(function.Meta == parser.CONSTRUCTOR && hasUnimplementedPureVirtualFunctions(class.Name)) {
-								fmt.Fprintf(bb, "%v;\n", cppFunctionHeader(function))
-							}
-						}
-					}
-
-				}
-			}
-
-			//virtual parent functions
-			for _, parentClassName := range class.GetAllBases() {
-				var parentClass = parser.ClassMap[parentClassName]
-				if classIsSupported(parentClass) {
-
-					for _, function := range parentClass.Functions {
-						if _, exists := implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)]; !exists {
-							implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = true
-
-							if functionIsSupported(parentClass, function) {
-								if function.Meta != parser.SIGNAL && (function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SLOT) && !strings.Contains(function.Meta, "structor") {
-
-									var function = *function
-									function.Fullname = fmt.Sprintf("%v::%v", class.Name, function.Name)
-									if function.Meta != parser.SLOT {
-										function.Meta = parser.PLAIN
-									}
-									fmt.Fprintf(bb, "%v;\n", cppFunctionHeader(&function))
-
-									function.Meta = parser.PLAIN
-									function.Default = true
-									fmt.Fprintf(bb, "%v;\n", cppFunctionHeader(&function))
-
-								}
-							}
-
-						}
-					}
-
-				}
-			}
+			test(bb, class, cppFunctionHeader, ";\n")
 
 		}
 

internal/binding/templater/templater.go

@@ -3,72 +3,75 @@ package templater
 import (
 	"strings"
 
+	"github.com/therecipe/qt/internal/binding/parser"
 	"github.com/therecipe/qt/internal/utils"
 )
 
-var (
-	Minimal       bool
-	Moc           bool
-	CurrentModule string
-)
-
-func GenModule(name string) {
-	if ShouldBuild(name) {
+func GenModule(m string) {
+	if !ShouldBuild(m) {
+		return
+	}
 
 	var (
-			pkgName = strings.ToLower(name)
+		pkgName = strings.ToLower(m)
 		suffix  string
 	)
 
-		if name == "AndroidExtras" {
+	switch m {
+	case "AndroidExtras":
+		{
 			suffix = "_android"
 		}
-		if name == "Sailfish" {
+
+	case "Sailfish":
+		{
 			suffix = "_sailfish"
 		}
+	}
 
 	//cleanup
-		if !Minimal {
+	if !parser.CurrentState.Minimal {
 		utils.RemoveAll(utils.GoQtPkgPath(pkgName))
-			utils.RemoveAll(utils.GoQtPkgPath("internal", "binding", "dump", name))
+		utils.MkdirAll(utils.GoQtPkgPath(pkgName))
+
+		if m == "AndroidExtras" {
+			//TODO: move into internal/runtime
+			utils.Save(utils.GoQtPkgPath(pkgName, "utils-androidextras_android.go"), utils.Load(utils.GoQtPkgPath("internal", "binding", "files", "utils-androidextras_android.go")))
+		}
 	}
 
 	//prepare
-		utils.MakeFolder(utils.GoQtPkgPath(pkgName))
-		CopyCgo(name)
-		if name == "AndroidExtras" && !Minimal {
-			utils.Save(utils.GoQtPkgPath(pkgName, "utils-androidextras_android.go"), utils.Load(utils.GoQtPkgPath("internal", "binding", "files", "utils-androidextras_android.go")))
-		}
-		manualWeakLink("Qt" + name)
+	CopyCgo(m, "")
 
-		CurrentModule = name
+	parser.CurrentState.CurrentModule = m
 
 	//dry run
-		CppTemplate("Qt" + name)
-		GoTemplate("Qt"+name, false)
+	CppTemplate("Qt" + m)
+	GoTemplate("Qt"+m, false)
 
 	//generate
-		if Minimal {
-			if !(name == "AndroidExtras" || name == "Sailfish") {
-				utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+"-minimal"+suffix+".cpp"), CppTemplate("Qt"+name))
-				utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+"-minimal"+suffix+".h"), HTemplate("Qt"+name))
-			}
-		} else {
-			if !UseStub() {
-				utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+suffix+".cpp"), CppTemplate("Qt"+name))
-				utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+suffix+".h"), HTemplate("Qt"+name))
-			}
+	if parser.CurrentState.Minimal {
+		if suffix != "" {
+			return
 		}
 
-		if Minimal {
-			if !(name == "AndroidExtras" || name == "Sailfish") {
-				utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+"-minimal.go"), GoTemplate("Qt"+name, false))
+		utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+"-minimal.cpp"), CppTemplate("Qt"+m))
+		utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+"-minimal.h"), HTemplate("Qt"+m))
+		utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+"-minimal.go"), GoTemplate("Qt"+m, false))
+
+		return
 	}
-		} else {
-			if name == "AndroidExtras" || name == "Sailfish" {
-				utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+suffix+".go"), GoTemplate("Qt"+name, false))
-			}
-			utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+".go"), GoTemplate("Qt"+name, name == "AndroidExtras" || name == "Sailfish"))
+
+	if !UseStub() {
+		utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+suffix+".cpp"), CppTemplate("Qt"+m))
+		utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+suffix+".h"), HTemplate("Qt"+m))
 	}
+
+	//always generate full
+	if suffix != "" {
+		utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+suffix+".go"), GoTemplate("Qt"+m, false))
 	}
+
+	//may generate stub
+	utils.SaveBytes(utils.GoQtPkgPath(pkgName, pkgName+".go"), GoTemplate("Qt"+m, suffix != ""))
 }

internal/moc/moc.go

@@ -22,7 +22,7 @@ import (
 
 func init() {
 	// TODO: dangerous
-	templater.Moc = true
+	parser.CurrentState.Moc = true
 }
 
 type appMoc struct {
@@ -44,16 +44,12 @@ func newAppMoc(appPath string) *appMoc {
 
 func cacheModules() (err error) {
 
-	if len(parser.ClassMap) != 0 {
+	if len(parser.CurrentState.ClassMap) != 0 {
 		utils.Log.WithField("func", "cacheModules").Debug("modules already cached, skipping caching of modules")
 		return
 	}
 
-	for _, module := range templater.GetLibs() {
-		if _, err = parser.GetModule(module); err != nil {
-			return
-		}
-	}
+	parser.LoadModules()
 
 	return
 }
@@ -61,8 +57,8 @@ func cacheModules() (err error) {
 // return how many moc classes are in module, delete those that are not
 func (m *appMoc) cleanupClassMap() (size int) {
 	for _, class := range m.module.Namespace.Classes {
-		if !class.IsQObjectSubClass() {
-			delete(parser.ClassMap, class.Name)
+		if !class.IsSubClassOfQObject() {
+			delete(parser.CurrentState.ClassMap, class.Name)
 		} else {
 			size++
 		}
@@ -81,7 +77,7 @@ func (m *appMoc) parseGo(path string) error {
 		return errParse
 	}
 
-	templater.MocModule = file.Name.String()
+	parser.CurrentState.MocModule = file.Name.String()
 
 	for _, d := range file.Decls {
 		typeDecl, ok := d.(*ast.GenDecl)
@@ -207,7 +203,7 @@ func CleanPath(path string) (err error) {
 				for _, tFile := range tmpFileNames {
 					if tFile == info.Name() {
 						utils.Log.WithFields(fields).WithField("filename", tFile).Debug("Remove file")
-						return os.RemoveAll(path)
+						return utils.RemoveAll(path)
 					}
 				}
 
@@ -320,7 +316,7 @@ func (m *appMoc) generate() error {
 	//find valid base classes for the moc classes in moc namespace and global namespace
 	for _, c := range m.module.Namespace.Classes {
 		for _, bc := range c.GetBases() {
-			if isInClassArray(m.module.Namespace.Classes, bc) || isInClassMap(parser.ClassMap, bc) {
+			if isInClassArray(m.module.Namespace.Classes, bc) || isInClassMap(parser.CurrentState.ClassMap, bc) {
 				c.Bases = bc
 				break
 			}
@@ -349,12 +345,12 @@ func (m *appMoc) generate() error {
 	//copy constructor and destructor
 	for _ = range m.module.Namespace.Classes {
 		for _, c := range m.module.Namespace.Classes {
-			if bc, exists := parser.ClassMap[c.Bases]; exists {
+			if bc, exists := parser.CurrentState.ClassMap[c.Bases]; exists {
 				for _, bcf := range bc.Functions {
 					if bcf.Meta == parser.CONSTRUCTOR || bcf.Meta == parser.DESTRUCTOR {
 						var f = *bcf
-						f.Name = strings.Replace(f.Name, bcf.Class(), c.Name, -1)
-						f.Fullname = strings.Replace(f.Fullname, bcf.Class(), c.Name, -1)
+						f.Name = strings.Replace(f.Name, bcf.ClassName(), c.Name, -1)
+						f.Fullname = strings.Replace(f.Fullname, bcf.ClassName(), c.Name, -1)
 
 						if !c.HasFunctionWithName(f.Name) {
 							c.Functions = append(c.Functions, &f)
@@ -365,22 +361,22 @@ func (m *appMoc) generate() error {
 		}
 	}
 
-	if err = ioutil.WriteFile(filepath.Join(m.appPath, "moc.cpp"), templater.CppTemplate(parser.MOC), 0644); err != nil {
+	if err = utils.SaveBytes(filepath.Join(m.appPath, "moc.cpp"), templater.CppTemplate(parser.MOC)); err != nil {
 		return err
 	}
 
-	if err = ioutil.WriteFile(filepath.Join(m.appPath, "moc.h"), templater.HTemplate(parser.MOC), 0644); err != nil {
+	if err = utils.SaveBytes(filepath.Join(m.appPath, "moc.h"), templater.HTemplate(parser.MOC)); err != nil {
 		return err
 	}
 
-	if err = ioutil.WriteFile(filepath.Join(m.appPath, "moc.go"), templater.GoTemplate(parser.MOC, false), 0644); err != nil {
+	if err = utils.SaveBytes(filepath.Join(m.appPath, "moc.go"), templater.GoTemplate(parser.MOC, false)); err != nil {
 		return err
 	}
-	templater.CopyCgoForMoc(parser.MOC, m.appPath)
+	templater.CopyCgo(parser.MOC, m.appPath)
 
-	for _, c := range parser.ClassMap {
+	for _, c := range parser.CurrentState.ClassMap {
 		if c.Module == parser.MOC {
-			delete(parser.ClassMap, c.Name)
+			delete(parser.CurrentState.ClassMap, c.Name)
 		}
 	}
 
@@ -487,8 +483,8 @@ func getCppTypeFromGoType(t string) string {
 		return strings.Replace(t, "_", ":", -1)
 	}
 
-	if _, exists := parser.ClassMap[t]; exists {
-		if parser.ClassMap[t].IsQObjectSubClass() {
+	if _, exists := parser.CurrentState.ClassMap[t]; exists {
+		if parser.CurrentState.ClassMap[t].IsSubClassOfQObject() {
 			return t + "*"
 		}
 		return t

internal/utils/darwin.go

@@ -60,7 +60,7 @@ func UseHomeBrew() bool {
 }
 
 func IsHomeBrewQtDir() bool {
-	return Exists(filepath.Join(QT_DIR(), "INSTALL_RECEIPT.json"))
+	return ExistsFile(filepath.Join(QT_DIR(), "INSTALL_RECEIPT.json"))
 }
 
 func QT_DARWIN_DIR() string {

internal/utils/sailfish.go

@@ -21,10 +21,7 @@ func VIRTUALBOX_DIR() string {
 		Log.WithError(err).Error("failed to find vboxmanage in your PATH")
 	}
 
-	path, err = filepath.Abs(filepath.Dir(path))
-	if err != nil {
-		Log.WithError(err).Errorf("failed to create absolute path for %v", path)
-	}
+	path, err = Abs(filepath.Dir(path))
 
 	return path
 }

internal/utils/utils.go

@@ -10,15 +10,20 @@ import (
 	"github.com/Sirupsen/logrus"
 )
 
-func Exists(name string) bool {
+func ExistsFile(name string) bool {
 	var _, err = ioutil.ReadFile(name)
 	return err == nil
 }
 
-func MakeFolder(dir string) error {
+func ExistsDir(name string) bool {
+	var _, err = ioutil.ReadDir(name)
+	return err == nil
+}
+
+func MkdirAll(dir string) error {
 	var err = os.MkdirAll(dir, 0777)
 	if err != nil {
-		Log.WithError(err).Panicf("failed to create folder %v", dir)
+		Log.WithError(err).Panicf("failed to create dir %v", dir)
 	}
 	return err
 }
@@ -56,12 +61,12 @@ func Load(name string) string {
 	return string(out)
 }
 
-func GetAbsPath(appPath string) string {
+func Abs(appPath string) (string, error) {
 	var path, err = filepath.Abs(appPath)
 	if err != nil {
 		Log.WithError(err).Panicf("failed to get absolute path for %v", appPath)
 	}
-	return path
+	return path, err
 }
 
 func GoQtPkgPath(s ...string) string {

internal/utils/windows.go

@@ -31,5 +31,5 @@ func QT_MSYS2_DIR() string {
 }
 
 func IsMsys2QtDir() bool {
-	return Exists(filepath.Join(os.Getenv("QT_MSYS2_DIR"), "msys2.exe"))
+	return ExistsFile(filepath.Join(os.Getenv("QT_MSYS2_DIR"), "msys2.exe"))
 }

location/location.go

@@ -3317,6 +3317,59 @@ func (ptr *QGeoServiceProviderFactory) DestroyQGeoServiceProviderFactoryDefault(
 	}
 }
 
+//QLocation::Visibility
+type QLocation__Visibility int64
+
+const (
+	QLocation__UnspecifiedVisibility = QLocation__Visibility(0x00)
+	QLocation__DeviceVisibility      = QLocation__Visibility(0x01)
+	QLocation__PrivateVisibility     = QLocation__Visibility(0x02)
+	QLocation__PublicVisibility      = QLocation__Visibility(0x04)
+)
+
+type QLocation struct {
+	ptr unsafe.Pointer
+}
+
+type QLocation_ITF interface {
+	QLocation_PTR() *QLocation
+}
+
+func (p *QLocation) QLocation_PTR() *QLocation {
+	return p
+}
+
+func (p *QLocation) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QLocation) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQLocation(ptr QLocation_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QLocation_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQLocationFromPointer(ptr unsafe.Pointer) *QLocation {
+	var n = new(QLocation)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QLocation) DestroyQLocation() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QPlace struct {
 	ptr unsafe.Pointer
 }

multimedia/multimedia.cpp

@@ -186,6 +186,16 @@ void* QAbstractPlanarVideoBuffer_HandleDefault(void* ptr)
 	return new QVariant(static_cast<QAbstractPlanarVideoBuffer*>(ptr)->QAbstractPlanarVideoBuffer::handle());
 }
 
+struct QtMultimedia_PackedString QAbstractPlanarVideoBuffer_Map(void* ptr, long long mode, int numBytes, int bytesPerLine)
+{
+	return ({ char* t63420a = static_cast<char*>(static_cast<void*>(static_cast<QAbstractPlanarVideoBuffer*>(ptr)->map(static_cast<QAbstractVideoBuffer::MapMode>(mode), &numBytes, &bytesPerLine))); QtMultimedia_PackedString { t63420a, -1 }; });
+}
+
+struct QtMultimedia_PackedString QAbstractPlanarVideoBuffer_MapDefault(void* ptr, long long mode, int numBytes, int bytesPerLine)
+{
+	return ({ char* tbdd456 = static_cast<char*>(static_cast<void*>(static_cast<QAbstractPlanarVideoBuffer*>(ptr)->QAbstractPlanarVideoBuffer::map(static_cast<QAbstractVideoBuffer::MapMode>(mode), &numBytes, &bytesPerLine))); QtMultimedia_PackedString { tbdd456, -1 }; });
+}
+
 long long QAbstractPlanarVideoBuffer_MapMode(void* ptr)
 {
 	return static_cast<QAbstractPlanarVideoBuffer*>(ptr)->mapMode();
@@ -3635,6 +3645,11 @@ void QCamera_DestroyQCamera(void* ptr)
 	static_cast<QCamera*>(ptr)->~QCamera();
 }
 
+void* QCamera_availableDevices_atList(void* ptr, int i)
+{
+	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
+}
+
 void* QCamera_supportedViewfinderResolutions_atList(void* ptr, int i)
 {
 	return ({ QSize tmpValue = static_cast<QList<QSize>*>(ptr)->at(i); new QSize(tmpValue.width(), tmpValue.height()); });

multimedia/multimedia.go

@@ -10041,6 +10041,15 @@ func (ptr *QCamera) DestroyQCamera() {
 	}
 }
 
+func (ptr *QCamera) availableDevices_atList(i int) *core.QByteArray {
+	if ptr.Pointer() != nil {
+		var tmpValue = core.NewQByteArrayFromPointer(C.QCamera_availableDevices_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
+		return tmpValue
+	}
+	return nil
+}
+
 func (ptr *QCamera) supportedViewfinderResolutions_atList(i int) *core.QSize {
 	if ptr.Pointer() != nil {
 		var tmpValue = core.NewQSizeFromPointer(C.QCamera_supportedViewfinderResolutions_atList(ptr.Pointer(), C.int(int32(i))))

multimedia/multimedia.h

@@ -17,6 +17,8 @@ void QAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBuffer(void* ptr);
 void QAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBufferDefault(void* ptr);
 void* QAbstractPlanarVideoBuffer_Handle(void* ptr);
 void* QAbstractPlanarVideoBuffer_HandleDefault(void* ptr);
+struct QtMultimedia_PackedString QAbstractPlanarVideoBuffer_Map(void* ptr, long long mode, int numBytes, int bytesPerLine);
+struct QtMultimedia_PackedString QAbstractPlanarVideoBuffer_MapDefault(void* ptr, long long mode, int numBytes, int bytesPerLine);
 long long QAbstractPlanarVideoBuffer_MapMode(void* ptr);
 ;
 void QAbstractPlanarVideoBuffer_Release(void* ptr);
@@ -645,6 +647,7 @@ void QCamera_Unlock(void* ptr);
 void QCamera_Unlock2(void* ptr, long long locks);
 void* QCamera_ViewfinderSettings(void* ptr);
 void QCamera_DestroyQCamera(void* ptr);
+void* QCamera_availableDevices_atList(void* ptr, int i);
 void* QCamera_supportedViewfinderResolutions_atList(void* ptr, int i);
 void* QCamera_supportedViewfinderSettings_atList(void* ptr, int i);
 char QCamera_Bind(void* ptr, void* object);

network/network.cpp

@@ -47,6 +47,7 @@
 #include <QNetworkRequest>
 #include <QNetworkSession>
 #include <QObject>
+#include <QRegExp>
 #include <QSslCertificate>
 #include <QSslCertificateExtension>
 #include <QSslCipher>
@@ -3324,6 +3325,11 @@ struct QtNetwork_PackedList QNetworkCookieJar_AllCookies(void* ptr)
 	return ({ QList<QNetworkCookie>* tmpValue = new QList<QNetworkCookie>(static_cast<QNetworkCookieJar*>(ptr)->allCookies()); QtNetwork_PackedList { tmpValue, tmpValue->size() }; });
 }
 
+struct QtNetwork_PackedList QNetworkCookieJar_CookiesForUrl(void* ptr, void* url)
+{
+	return ({ QList<QNetworkCookie>* tmpValue = new QList<QNetworkCookie>(static_cast<QNetworkCookieJar*>(ptr)->cookiesForUrl(*static_cast<QUrl*>(url))); QtNetwork_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 char QNetworkCookieJar_DeleteCookie(void* ptr, void* cookie)
 {
 	return static_cast<QNetworkCookieJar*>(ptr)->deleteCookie(*static_cast<QNetworkCookie*>(cookie));
@@ -5151,6 +5157,56 @@ void* QNetworkSession_MetaObjectDefault(void* ptr)
 	return const_cast<QMetaObject*>(static_cast<QNetworkSession*>(ptr)->QNetworkSession::metaObject());
 }
 
+int QSsl_TlsV1_1_Type()
+{
+	return QSsl::TlsV1_1;
+}
+
+int QSsl_TlsV1_2_Type()
+{
+	return QSsl::TlsV1_2;
+}
+
+int QSsl_AnyProtocol_Type()
+{
+	return QSsl::AnyProtocol;
+}
+
+int QSsl_TlsV1SslV3_Type()
+{
+	return QSsl::TlsV1SslV3;
+}
+
+int QSsl_SecureProtocols_Type()
+{
+	return QSsl::SecureProtocols;
+}
+
+int QSsl_TlsV1_0OrLater_Type()
+{
+	return QSsl::TlsV1_0OrLater;
+}
+
+int QSsl_TlsV1_1OrLater_Type()
+{
+	return QSsl::TlsV1_1OrLater;
+}
+
+int QSsl_TlsV1_2OrLater_Type()
+{
+	return QSsl::TlsV1_2OrLater;
+}
+
+void* QSslCertificate_NewQSslCertificate(void* device, long long format)
+{
+	return new QSslCertificate(static_cast<QIODevice*>(device), static_cast<QSsl::EncodingFormat>(format));
+}
+
+void* QSslCertificate_NewQSslCertificate2(void* data, long long format)
+{
+	return new QSslCertificate(*static_cast<QByteArray*>(data), static_cast<QSsl::EncodingFormat>(format));
+}
+
 void* QSslCertificate_NewQSslCertificate3(void* other)
 {
 	return new QSslCertificate(*static_cast<QSslCertificate*>(other));
@@ -5166,6 +5222,21 @@ void* QSslCertificate_Digest(void* ptr, long long algorithm)
 	return new QByteArray(static_cast<QSslCertificate*>(ptr)->digest(static_cast<QCryptographicHash::Algorithm>(algorithm)));
 }
 
+struct QtNetwork_PackedList QSslCertificate_QSslCertificate_FromData(void* data, long long format)
+{
+	return ({ QList<QSslCertificate>* tmpValue = new QList<QSslCertificate>(QSslCertificate::fromData(*static_cast<QByteArray*>(data), static_cast<QSsl::EncodingFormat>(format))); QtNetwork_PackedList { tmpValue, tmpValue->size() }; });
+}
+
+struct QtNetwork_PackedList QSslCertificate_QSslCertificate_FromDevice(void* device, long long format)
+{
+	return ({ QList<QSslCertificate>* tmpValue = new QList<QSslCertificate>(QSslCertificate::fromDevice(static_cast<QIODevice*>(device), static_cast<QSsl::EncodingFormat>(format))); QtNetwork_PackedList { tmpValue, tmpValue->size() }; });
+}
+
+struct QtNetwork_PackedList QSslCertificate_QSslCertificate_FromPath(char* path, long long format, long long syntax)
+{
+	return ({ QList<QSslCertificate>* tmpValue = new QList<QSslCertificate>(QSslCertificate::fromPath(QString(path), static_cast<QSsl::EncodingFormat>(format), static_cast<QRegExp::PatternSyntax>(syntax))); QtNetwork_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 char QSslCertificate_IsBlacklisted(void* ptr)
 {
 	return static_cast<QSslCertificate*>(ptr)->isBlacklisted();
@@ -5356,6 +5427,11 @@ void* QSslCipher_NewQSslCipher2(char* name)
 	return new QSslCipher(QString(name));
 }
 
+void* QSslCipher_NewQSslCipher3(char* name, long long protocol)
+{
+	return new QSslCipher(QString(name), static_cast<QSsl::SslProtocol>(protocol));
+}
+
 struct QtNetwork_PackedString QSslCipher_AuthenticationMethod(void* ptr)
 {
 	return ({ QByteArray tfc1f5a = static_cast<QSslCipher*>(ptr)->authenticationMethod().toUtf8(); QtNetwork_PackedString { const_cast<char*>(tfc1f5a.prepend("WHITESPACE").constData()+10), tfc1f5a.size()-10 }; });
@@ -5381,6 +5457,11 @@ struct QtNetwork_PackedString QSslCipher_Name(void* ptr)
 	return ({ QByteArray t9ef3a9 = static_cast<QSslCipher*>(ptr)->name().toUtf8(); QtNetwork_PackedString { const_cast<char*>(t9ef3a9.prepend("WHITESPACE").constData()+10), t9ef3a9.size()-10 }; });
 }
 
+long long QSslCipher_Protocol(void* ptr)
+{
+	return static_cast<QSslCipher*>(ptr)->protocol();
+}
+
 struct QtNetwork_PackedString QSslCipher_ProtocolString(void* ptr)
 {
 	return ({ QByteArray t99c307 = static_cast<QSslCipher*>(ptr)->protocolString().toUtf8(); QtNetwork_PackedString { const_cast<char*>(t99c307.prepend("WHITESPACE").constData()+10), t99c307.size()-10 }; });
@@ -5491,11 +5572,21 @@ void* QSslConfiguration_PrivateKey(void* ptr)
 	return new QSslKey(static_cast<QSslConfiguration*>(ptr)->privateKey());
 }
 
+long long QSslConfiguration_Protocol(void* ptr)
+{
+	return static_cast<QSslConfiguration*>(ptr)->protocol();
+}
+
 void* QSslConfiguration_SessionCipher(void* ptr)
 {
 	return new QSslCipher(static_cast<QSslConfiguration*>(ptr)->sessionCipher());
 }
 
+long long QSslConfiguration_SessionProtocol(void* ptr)
+{
+	return static_cast<QSslConfiguration*>(ptr)->sessionProtocol();
+}
+
 void* QSslConfiguration_SessionTicket(void* ptr)
 {
 	return new QByteArray(static_cast<QSslConfiguration*>(ptr)->sessionTicket());
@@ -5531,11 +5622,21 @@ void QSslConfiguration_SetPrivateKey(void* ptr, void* key)
 	static_cast<QSslConfiguration*>(ptr)->setPrivateKey(*static_cast<QSslKey*>(key));
 }
 
+void QSslConfiguration_SetProtocol(void* ptr, long long protocol)
+{
+	static_cast<QSslConfiguration*>(ptr)->setProtocol(static_cast<QSsl::SslProtocol>(protocol));
+}
+
 void QSslConfiguration_SetSessionTicket(void* ptr, void* sessionTicket)
 {
 	static_cast<QSslConfiguration*>(ptr)->setSessionTicket(*static_cast<QByteArray*>(sessionTicket));
 }
 
+void QSslConfiguration_SetSslOption(void* ptr, long long option, char on)
+{
+	static_cast<QSslConfiguration*>(ptr)->setSslOption(static_cast<QSsl::SslOption>(option), on != 0);
+}
+
 struct QtNetwork_PackedList QSslConfiguration_QSslConfiguration_SupportedCiphers()
 {
 	return ({ QList<QSslCipher>* tmpValue = new QList<QSslCipher>(QSslConfiguration::supportedCiphers()); QtNetwork_PackedList { tmpValue, tmpValue->size() }; });
@@ -5551,6 +5652,11 @@ struct QtNetwork_PackedList QSslConfiguration_QSslConfiguration_SystemCaCertific
 	return ({ QList<QSslCertificate>* tmpValue = new QList<QSslCertificate>(QSslConfiguration::systemCaCertificates()); QtNetwork_PackedList { tmpValue, tmpValue->size() }; });
 }
 
+char QSslConfiguration_TestSslOption(void* ptr, long long option)
+{
+	return static_cast<QSslConfiguration*>(ptr)->testSslOption(static_cast<QSsl::SslOption>(option));
+}
+
 void QSslConfiguration_DestroyQSslConfiguration(void* ptr)
 {
 	static_cast<QSslConfiguration*>(ptr)->~QSslConfiguration();
@@ -5686,11 +5792,26 @@ void* QSslKey_NewQSslKey()
 	return new QSslKey();
 }
 
+void* QSslKey_NewQSslKey3(void* device, long long algorithm, long long encoding, long long ty, void* passPhrase)
+{
+	return new QSslKey(static_cast<QIODevice*>(device), static_cast<QSsl::KeyAlgorithm>(algorithm), static_cast<QSsl::EncodingFormat>(encoding), static_cast<QSsl::KeyType>(ty), *static_cast<QByteArray*>(passPhrase));
+}
+
+void* QSslKey_NewQSslKey2(void* encoded, long long algorithm, long long encoding, long long ty, void* passPhrase)
+{
+	return new QSslKey(*static_cast<QByteArray*>(encoded), static_cast<QSsl::KeyAlgorithm>(algorithm), static_cast<QSsl::EncodingFormat>(encoding), static_cast<QSsl::KeyType>(ty), *static_cast<QByteArray*>(passPhrase));
+}
+
 void* QSslKey_NewQSslKey5(void* other)
 {
 	return new QSslKey(*static_cast<QSslKey*>(other));
 }
 
+long long QSslKey_Algorithm(void* ptr)
+{
+	return static_cast<QSslKey*>(ptr)->algorithm();
+}
+
 void QSslKey_Clear(void* ptr)
 {
 	static_cast<QSslKey*>(ptr)->clear();
@@ -5721,6 +5842,11 @@ void* QSslKey_ToPem(void* ptr, void* passPhrase)
 	return new QByteArray(static_cast<QSslKey*>(ptr)->toPem(*static_cast<QByteArray*>(passPhrase)));
 }
 
+long long QSslKey_Type(void* ptr)
+{
+	return static_cast<QSslKey*>(ptr)->type();
+}
+
 void QSslKey_DestroyQSslKey(void* ptr)
 {
 	static_cast<QSslKey*>(ptr)->~QSslKey();
@@ -5833,11 +5959,21 @@ void QSslSocket_AddCaCertificate(void* ptr, void* certificate)
 	static_cast<QSslSocket*>(ptr)->addCaCertificate(*static_cast<QSslCertificate*>(certificate));
 }
 
+char QSslSocket_AddCaCertificates(void* ptr, char* path, long long format, long long syntax)
+{
+	return static_cast<QSslSocket*>(ptr)->addCaCertificates(QString(path), static_cast<QSsl::EncodingFormat>(format), static_cast<QRegExp::PatternSyntax>(syntax));
+}
+
 void QSslSocket_QSslSocket_AddDefaultCaCertificate(void* certificate)
 {
 	QSslSocket::addDefaultCaCertificate(*static_cast<QSslCertificate*>(certificate));
 }
 
+char QSslSocket_QSslSocket_AddDefaultCaCertificates(char* path, long long encoding, long long syntax)
+{
+	return QSslSocket::addDefaultCaCertificates(QString(path), static_cast<QSsl::EncodingFormat>(encoding), static_cast<QRegExp::PatternSyntax>(syntax));
+}
+
 char QSslSocket_AtEnd(void* ptr)
 {
 	return static_cast<QSslSocket*>(ptr)->atEnd();
@@ -6018,6 +6154,11 @@ void* QSslSocket_PrivateKey(void* ptr)
 	return new QSslKey(static_cast<QSslSocket*>(ptr)->privateKey());
 }
 
+long long QSslSocket_Protocol(void* ptr)
+{
+	return static_cast<QSslSocket*>(ptr)->protocol();
+}
+
 void QSslSocket_Resume(void* ptr)
 {
 	static_cast<QSslSocket*>(ptr)->resume();
@@ -6033,11 +6174,21 @@ void* QSslSocket_SessionCipher(void* ptr)
 	return new QSslCipher(static_cast<QSslSocket*>(ptr)->sessionCipher());
 }
 
+long long QSslSocket_SessionProtocol(void* ptr)
+{
+	return static_cast<QSslSocket*>(ptr)->sessionProtocol();
+}
+
 void QSslSocket_SetLocalCertificate(void* ptr, void* certificate)
 {
 	static_cast<QSslSocket*>(ptr)->setLocalCertificate(*static_cast<QSslCertificate*>(certificate));
 }
 
+void QSslSocket_SetLocalCertificate2(void* ptr, char* path, long long format)
+{
+	static_cast<QSslSocket*>(ptr)->setLocalCertificate(QString(path), static_cast<QSsl::EncodingFormat>(format));
+}
+
 void QSslSocket_SetPeerVerifyDepth(void* ptr, int depth)
 {
 	static_cast<QSslSocket*>(ptr)->setPeerVerifyDepth(depth);
@@ -6058,6 +6209,16 @@ void QSslSocket_SetPrivateKey(void* ptr, void* key)
 	static_cast<QSslSocket*>(ptr)->setPrivateKey(*static_cast<QSslKey*>(key));
 }
 
+void QSslSocket_SetPrivateKey2(void* ptr, char* fileName, long long algorithm, long long format, void* passPhrase)
+{
+	static_cast<QSslSocket*>(ptr)->setPrivateKey(QString(fileName), static_cast<QSsl::KeyAlgorithm>(algorithm), static_cast<QSsl::EncodingFormat>(format), *static_cast<QByteArray*>(passPhrase));
+}
+
+void QSslSocket_SetProtocol(void* ptr, long long protocol)
+{
+	static_cast<QSslSocket*>(ptr)->setProtocol(static_cast<QSsl::SslProtocol>(protocol));
+}
+
 void QSslSocket_SetReadBufferSize(void* ptr, long long size)
 {
 	static_cast<QSslSocket*>(ptr)->setReadBufferSize(size);
@@ -6183,6 +6344,26 @@ void QSslSocket_DestroyQSslSocket(void* ptr)
 	static_cast<QSslSocket*>(ptr)->~QSslSocket();
 }
 
+void* QSslSocket_caCertificates_atList(void* ptr, int i)
+{
+	return new QSslCertificate(static_cast<QList<QSslCertificate>*>(ptr)->at(i));
+}
+
+void* QSslSocket_ciphers_atList(void* ptr, int i)
+{
+	return new QSslCipher(static_cast<QList<QSslCipher>*>(ptr)->at(i));
+}
+
+void* QSslSocket_defaultCaCertificates_atList(void* ptr, int i)
+{
+	return new QSslCertificate(static_cast<QList<QSslCertificate>*>(ptr)->at(i));
+}
+
+void* QSslSocket_defaultCiphers_atList(void* ptr, int i)
+{
+	return new QSslCipher(static_cast<QList<QSslCipher>*>(ptr)->at(i));
+}
+
 void* QSslSocket_localCertificateChain_atList(void* ptr, int i)
 {
 	return new QSslCertificate(static_cast<QList<QSslCertificate>*>(ptr)->at(i));
@@ -6198,6 +6379,16 @@ void* QSslSocket_sslErrors_atList(void* ptr, int i)
 	return new QSslError(static_cast<QList<QSslError>*>(ptr)->at(i));
 }
 
+void* QSslSocket_supportedCiphers_atList(void* ptr, int i)
+{
+	return new QSslCipher(static_cast<QList<QSslCipher>*>(ptr)->at(i));
+}
+
+void* QSslSocket_systemCaCertificates_atList(void* ptr, int i)
+{
+	return new QSslCertificate(static_cast<QList<QSslCertificate>*>(ptr)->at(i));
+}
+
 void QSslSocket_ConnectToHost2(void* ptr, void* address, unsigned short port, long long openMode)
 {
 	static_cast<QSslSocket*>(ptr)->connectToHost(*static_cast<QHostAddress*>(address), port, static_cast<QIODevice::OpenModeFlag>(openMode));

network/network.go

@@ -8581,6 +8581,19 @@ func (ptr *QNetworkCookieJar) AllCookies() []*QNetworkCookie {
 	return nil
 }
 
+func (ptr *QNetworkCookieJar) CookiesForUrl(url core.QUrl_ITF) []*QNetworkCookie {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtNetwork_PackedList) []*QNetworkCookie {
+			var out = make([]*QNetworkCookie, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQNetworkCookieJarFromPointer(l.data).cookiesForUrl_atList(i)
+			}
+			return out
+		}(C.QNetworkCookieJar_CookiesForUrl(ptr.Pointer(), core.PointerFromQUrl(url)))
+	}
+	return nil
+}
+
 //export callbackQNetworkCookieJar_DeleteCookie
 func callbackQNetworkCookieJar_DeleteCookie(ptr unsafe.Pointer, cookie unsafe.Pointer) C.char {
 
@@ -13617,6 +13630,116 @@ func (ptr *QNetworkSession) MetaObjectDefault() *core.QMetaObject {
 	return nil
 }
 
+//QSsl::AlternativeNameEntryType
+type QSsl__AlternativeNameEntryType int64
+
+const (
+	QSsl__EmailEntry = QSsl__AlternativeNameEntryType(0)
+	QSsl__DnsEntry   = QSsl__AlternativeNameEntryType(1)
+)
+
+//QSsl::EncodingFormat
+type QSsl__EncodingFormat int64
+
+const (
+	QSsl__Pem = QSsl__EncodingFormat(0)
+	QSsl__Der = QSsl__EncodingFormat(1)
+)
+
+//QSsl::KeyAlgorithm
+type QSsl__KeyAlgorithm int64
+
+const (
+	QSsl__Opaque = QSsl__KeyAlgorithm(0)
+	QSsl__Rsa    = QSsl__KeyAlgorithm(1)
+	QSsl__Dsa    = QSsl__KeyAlgorithm(2)
+	QSsl__Ec     = QSsl__KeyAlgorithm(3)
+)
+
+//QSsl::KeyType
+type QSsl__KeyType int64
+
+const (
+	QSsl__PrivateKey = QSsl__KeyType(0)
+	QSsl__PublicKey  = QSsl__KeyType(1)
+)
+
+//QSsl::SslOption
+type QSsl__SslOption int64
+
+const (
+	QSsl__SslOptionDisableEmptyFragments         = QSsl__SslOption(0x01)
+	QSsl__SslOptionDisableSessionTickets         = QSsl__SslOption(0x02)
+	QSsl__SslOptionDisableCompression            = QSsl__SslOption(0x04)
+	QSsl__SslOptionDisableServerNameIndication   = QSsl__SslOption(0x08)
+	QSsl__SslOptionDisableLegacyRenegotiation    = QSsl__SslOption(0x10)
+	QSsl__SslOptionDisableSessionSharing         = QSsl__SslOption(0x20)
+	QSsl__SslOptionDisableSessionPersistence     = QSsl__SslOption(0x40)
+	QSsl__SslOptionDisableServerCipherPreference = QSsl__SslOption(0x80)
+)
+
+//QSsl::SslProtocol
+type QSsl__SslProtocol int64
+
+var (
+	QSsl__SslV3           = QSsl__SslProtocol(0)
+	QSsl__SslV2           = QSsl__SslProtocol(1)
+	QSsl__TlsV1_0         = QSsl__SslProtocol(2)
+	QSsl__TlsV1           = QSsl__SslProtocol(QSsl__TlsV1_0)
+	QSsl__TlsV1_1         = QSsl__SslProtocol(C.QSsl_TlsV1_1_Type())
+	QSsl__TlsV1_2         = QSsl__SslProtocol(C.QSsl_TlsV1_2_Type())
+	QSsl__AnyProtocol     = QSsl__SslProtocol(C.QSsl_AnyProtocol_Type())
+	QSsl__TlsV1SslV3      = QSsl__SslProtocol(C.QSsl_TlsV1SslV3_Type())
+	QSsl__SecureProtocols = QSsl__SslProtocol(C.QSsl_SecureProtocols_Type())
+	QSsl__TlsV1_0OrLater  = QSsl__SslProtocol(C.QSsl_TlsV1_0OrLater_Type())
+	QSsl__TlsV1_1OrLater  = QSsl__SslProtocol(C.QSsl_TlsV1_1OrLater_Type())
+	QSsl__TlsV1_2OrLater  = QSsl__SslProtocol(C.QSsl_TlsV1_2OrLater_Type())
+	QSsl__UnknownProtocol = QSsl__SslProtocol(-1)
+)
+
+type QSsl struct {
+	ptr unsafe.Pointer
+}
+
+type QSsl_ITF interface {
+	QSsl_PTR() *QSsl
+}
+
+func (p *QSsl) QSsl_PTR() *QSsl {
+	return p
+}
+
+func (p *QSsl) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QSsl) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQSsl(ptr QSsl_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QSsl_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQSslFromPointer(ptr unsafe.Pointer) *QSsl {
+	var n = new(QSsl)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QSsl) DestroyQSsl() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 //QSslCertificate::SubjectInfo
 type QSslCertificate__SubjectInfo int64
 
@@ -13669,6 +13792,18 @@ func NewQSslCertificateFromPointer(ptr unsafe.Pointer) *QSslCertificate {
 	n.SetPointer(ptr)
 	return n
 }
+func NewQSslCertificate(device core.QIODevice_ITF, format QSsl__EncodingFormat) *QSslCertificate {
+	var tmpValue = NewQSslCertificateFromPointer(C.QSslCertificate_NewQSslCertificate(core.PointerFromQIODevice(device), C.longlong(format)))
+	runtime.SetFinalizer(tmpValue, (*QSslCertificate).DestroyQSslCertificate)
+	return tmpValue
+}
+
+func NewQSslCertificate2(data core.QByteArray_ITF, format QSsl__EncodingFormat) *QSslCertificate {
+	var tmpValue = NewQSslCertificateFromPointer(C.QSslCertificate_NewQSslCertificate2(core.PointerFromQByteArray(data), C.longlong(format)))
+	runtime.SetFinalizer(tmpValue, (*QSslCertificate).DestroyQSslCertificate)
+	return tmpValue
+}
+
 func NewQSslCertificate3(other QSslCertificate_ITF) *QSslCertificate {
 	var tmpValue = NewQSslCertificateFromPointer(C.QSslCertificate_NewQSslCertificate3(PointerFromQSslCertificate(other)))
 	runtime.SetFinalizer(tmpValue, (*QSslCertificate).DestroyQSslCertificate)
@@ -13690,6 +13825,70 @@ func (ptr *QSslCertificate) Digest(algorithm core.QCryptographicHash__Algorithm)
 	return nil
 }
 
+func QSslCertificate_FromData(data core.QByteArray_ITF, format QSsl__EncodingFormat) []*QSslCertificate {
+	return func(l C.struct_QtNetwork_PackedList) []*QSslCertificate {
+		var out = make([]*QSslCertificate, int(l.len))
+		for i := 0; i < int(l.len); i++ {
+			out[i] = NewQSslCertificateFromPointer(l.data).fromData_atList(i)
+		}
+		return out
+	}(C.QSslCertificate_QSslCertificate_FromData(core.PointerFromQByteArray(data), C.longlong(format)))
+}
+
+func (ptr *QSslCertificate) FromData(data core.QByteArray_ITF, format QSsl__EncodingFormat) []*QSslCertificate {
+	return func(l C.struct_QtNetwork_PackedList) []*QSslCertificate {
+		var out = make([]*QSslCertificate, int(l.len))
+		for i := 0; i < int(l.len); i++ {
+			out[i] = NewQSslCertificateFromPointer(l.data).fromData_atList(i)
+		}
+		return out
+	}(C.QSslCertificate_QSslCertificate_FromData(core.PointerFromQByteArray(data), C.longlong(format)))
+}
+
+func QSslCertificate_FromDevice(device core.QIODevice_ITF, format QSsl__EncodingFormat) []*QSslCertificate {
+	return func(l C.struct_QtNetwork_PackedList) []*QSslCertificate {
+		var out = make([]*QSslCertificate, int(l.len))
+		for i := 0; i < int(l.len); i++ {
+			out[i] = NewQSslCertificateFromPointer(l.data).fromDevice_atList(i)
+		}
+		return out
+	}(C.QSslCertificate_QSslCertificate_FromDevice(core.PointerFromQIODevice(device), C.longlong(format)))
+}
+
+func (ptr *QSslCertificate) FromDevice(device core.QIODevice_ITF, format QSsl__EncodingFormat) []*QSslCertificate {
+	return func(l C.struct_QtNetwork_PackedList) []*QSslCertificate {
+		var out = make([]*QSslCertificate, int(l.len))
+		for i := 0; i < int(l.len); i++ {
+			out[i] = NewQSslCertificateFromPointer(l.data).fromDevice_atList(i)
+		}
+		return out
+	}(C.QSslCertificate_QSslCertificate_FromDevice(core.PointerFromQIODevice(device), C.longlong(format)))
+}
+
+func QSslCertificate_FromPath(path string, format QSsl__EncodingFormat, syntax core.QRegExp__PatternSyntax) []*QSslCertificate {
+	var pathC = C.CString(path)
+	defer C.free(unsafe.Pointer(pathC))
+	return func(l C.struct_QtNetwork_PackedList) []*QSslCertificate {
+		var out = make([]*QSslCertificate, int(l.len))
+		for i := 0; i < int(l.len); i++ {
+			out[i] = NewQSslCertificateFromPointer(l.data).fromPath_atList(i)
+		}
+		return out
+	}(C.QSslCertificate_QSslCertificate_FromPath(pathC, C.longlong(format), C.longlong(syntax)))
+}
+
+func (ptr *QSslCertificate) FromPath(path string, format QSsl__EncodingFormat, syntax core.QRegExp__PatternSyntax) []*QSslCertificate {
+	var pathC = C.CString(path)
+	defer C.free(unsafe.Pointer(pathC))
+	return func(l C.struct_QtNetwork_PackedList) []*QSslCertificate {
+		var out = make([]*QSslCertificate, int(l.len))
+		for i := 0; i < int(l.len); i++ {
+			out[i] = NewQSslCertificateFromPointer(l.data).fromPath_atList(i)
+		}
+		return out
+	}(C.QSslCertificate_QSslCertificate_FromPath(pathC, C.longlong(format), C.longlong(syntax)))
+}
+
 func (ptr *QSslCertificate) IsBlacklisted() bool {
 	if ptr.Pointer() != nil {
 		return C.QSslCertificate_IsBlacklisted(ptr.Pointer()) != 0
@@ -14071,6 +14270,14 @@ func NewQSslCipher2(name string) *QSslCipher {
 	return tmpValue
 }
 
+func NewQSslCipher3(name string, protocol QSsl__SslProtocol) *QSslCipher {
+	var nameC = C.CString(name)
+	defer C.free(unsafe.Pointer(nameC))
+	var tmpValue = NewQSslCipherFromPointer(C.QSslCipher_NewQSslCipher3(nameC, C.longlong(protocol)))
+	runtime.SetFinalizer(tmpValue, (*QSslCipher).DestroyQSslCipher)
+	return tmpValue
+}
+
 func (ptr *QSslCipher) AuthenticationMethod() string {
 	if ptr.Pointer() != nil {
 		return cGoUnpackString(C.QSslCipher_AuthenticationMethod(ptr.Pointer()))
@@ -14106,6 +14313,13 @@ func (ptr *QSslCipher) Name() string {
 	return ""
 }
 
+func (ptr *QSslCipher) Protocol() QSsl__SslProtocol {
+	if ptr.Pointer() != nil {
+		return QSsl__SslProtocol(C.QSslCipher_Protocol(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QSslCipher) ProtocolString() string {
 	if ptr.Pointer() != nil {
 		return cGoUnpackString(C.QSslCipher_ProtocolString(ptr.Pointer()))
@@ -14348,6 +14562,13 @@ func (ptr *QSslConfiguration) PrivateKey() *QSslKey {
 	return nil
 }
 
+func (ptr *QSslConfiguration) Protocol() QSsl__SslProtocol {
+	if ptr.Pointer() != nil {
+		return QSsl__SslProtocol(C.QSslConfiguration_Protocol(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QSslConfiguration) SessionCipher() *QSslCipher {
 	if ptr.Pointer() != nil {
 		var tmpValue = NewQSslCipherFromPointer(C.QSslConfiguration_SessionCipher(ptr.Pointer()))
@@ -14357,6 +14578,13 @@ func (ptr *QSslConfiguration) SessionCipher() *QSslCipher {
 	return nil
 }
 
+func (ptr *QSslConfiguration) SessionProtocol() QSsl__SslProtocol {
+	if ptr.Pointer() != nil {
+		return QSsl__SslProtocol(C.QSslConfiguration_SessionProtocol(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QSslConfiguration) SessionTicket() *core.QByteArray {
 	if ptr.Pointer() != nil {
 		var tmpValue = core.NewQByteArrayFromPointer(C.QSslConfiguration_SessionTicket(ptr.Pointer()))
@@ -14405,12 +14633,24 @@ func (ptr *QSslConfiguration) SetPrivateKey(key QSslKey_ITF) {
 	}
 }
 
+func (ptr *QSslConfiguration) SetProtocol(protocol QSsl__SslProtocol) {
+	if ptr.Pointer() != nil {
+		C.QSslConfiguration_SetProtocol(ptr.Pointer(), C.longlong(protocol))
+	}
+}
+
 func (ptr *QSslConfiguration) SetSessionTicket(sessionTicket core.QByteArray_ITF) {
 	if ptr.Pointer() != nil {
 		C.QSslConfiguration_SetSessionTicket(ptr.Pointer(), core.PointerFromQByteArray(sessionTicket))
 	}
 }
 
+func (ptr *QSslConfiguration) SetSslOption(option QSsl__SslOption, on bool) {
+	if ptr.Pointer() != nil {
+		C.QSslConfiguration_SetSslOption(ptr.Pointer(), C.longlong(option), C.char(int8(qt.GoBoolToInt(on))))
+	}
+}
+
 func QSslConfiguration_SupportedCiphers() []*QSslCipher {
 	return func(l C.struct_QtNetwork_PackedList) []*QSslCipher {
 		var out = make([]*QSslCipher, int(l.len))
@@ -14457,6 +14697,13 @@ func (ptr *QSslConfiguration) SystemCaCertificates() []*QSslCertificate {
 	}(C.QSslConfiguration_QSslConfiguration_SystemCaCertificates())
 }
 
+func (ptr *QSslConfiguration) TestSslOption(option QSsl__SslOption) bool {
+	if ptr.Pointer() != nil {
+		return C.QSslConfiguration_TestSslOption(ptr.Pointer(), C.longlong(option)) != 0
+	}
+	return false
+}
+
 func (ptr *QSslConfiguration) DestroyQSslConfiguration() {
 	if ptr.Pointer() != nil {
 		C.QSslConfiguration_DestroyQSslConfiguration(ptr.Pointer())
@@ -14826,12 +15073,31 @@ func NewQSslKey() *QSslKey {
 	return tmpValue
 }
 
+func NewQSslKey3(device core.QIODevice_ITF, algorithm QSsl__KeyAlgorithm, encoding QSsl__EncodingFormat, ty QSsl__KeyType, passPhrase core.QByteArray_ITF) *QSslKey {
+	var tmpValue = NewQSslKeyFromPointer(C.QSslKey_NewQSslKey3(core.PointerFromQIODevice(device), C.longlong(algorithm), C.longlong(encoding), C.longlong(ty), core.PointerFromQByteArray(passPhrase)))
+	runtime.SetFinalizer(tmpValue, (*QSslKey).DestroyQSslKey)
+	return tmpValue
+}
+
+func NewQSslKey2(encoded core.QByteArray_ITF, algorithm QSsl__KeyAlgorithm, encoding QSsl__EncodingFormat, ty QSsl__KeyType, passPhrase core.QByteArray_ITF) *QSslKey {
+	var tmpValue = NewQSslKeyFromPointer(C.QSslKey_NewQSslKey2(core.PointerFromQByteArray(encoded), C.longlong(algorithm), C.longlong(encoding), C.longlong(ty), core.PointerFromQByteArray(passPhrase)))
+	runtime.SetFinalizer(tmpValue, (*QSslKey).DestroyQSslKey)
+	return tmpValue
+}
+
 func NewQSslKey5(other QSslKey_ITF) *QSslKey {
 	var tmpValue = NewQSslKeyFromPointer(C.QSslKey_NewQSslKey5(PointerFromQSslKey(other)))
 	runtime.SetFinalizer(tmpValue, (*QSslKey).DestroyQSslKey)
 	return tmpValue
 }
 
+func (ptr *QSslKey) Algorithm() QSsl__KeyAlgorithm {
+	if ptr.Pointer() != nil {
+		return QSsl__KeyAlgorithm(C.QSslKey_Algorithm(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QSslKey) Clear() {
 	if ptr.Pointer() != nil {
 		C.QSslKey_Clear(ptr.Pointer())
@@ -14876,6 +15142,13 @@ func (ptr *QSslKey) ToPem(passPhrase core.QByteArray_ITF) *core.QByteArray {
 	return nil
 }
 
+func (ptr *QSslKey) Type() QSsl__KeyType {
+	if ptr.Pointer() != nil {
+		return QSsl__KeyType(C.QSslKey_Type(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QSslKey) DestroyQSslKey() {
 	if ptr.Pointer() != nil {
 		C.QSslKey_DestroyQSslKey(ptr.Pointer())
@@ -15075,6 +15348,15 @@ func (ptr *QSslSocket) AddCaCertificate(certificate QSslCertificate_ITF) {
 	}
 }
 
+func (ptr *QSslSocket) AddCaCertificates(path string, format QSsl__EncodingFormat, syntax core.QRegExp__PatternSyntax) bool {
+	if ptr.Pointer() != nil {
+		var pathC = C.CString(path)
+		defer C.free(unsafe.Pointer(pathC))
+		return C.QSslSocket_AddCaCertificates(ptr.Pointer(), pathC, C.longlong(format), C.longlong(syntax)) != 0
+	}
+	return false
+}
+
 func QSslSocket_AddDefaultCaCertificate(certificate QSslCertificate_ITF) {
 	C.QSslSocket_QSslSocket_AddDefaultCaCertificate(PointerFromQSslCertificate(certificate))
 }
@@ -15083,6 +15365,18 @@ func (ptr *QSslSocket) AddDefaultCaCertificate(certificate QSslCertificate_ITF)
 	C.QSslSocket_QSslSocket_AddDefaultCaCertificate(PointerFromQSslCertificate(certificate))
 }
 
+func QSslSocket_AddDefaultCaCertificates(path string, encoding QSsl__EncodingFormat, syntax core.QRegExp__PatternSyntax) bool {
+	var pathC = C.CString(path)
+	defer C.free(unsafe.Pointer(pathC))
+	return C.QSslSocket_QSslSocket_AddDefaultCaCertificates(pathC, C.longlong(encoding), C.longlong(syntax)) != 0
+}
+
+func (ptr *QSslSocket) AddDefaultCaCertificates(path string, encoding QSsl__EncodingFormat, syntax core.QRegExp__PatternSyntax) bool {
+	var pathC = C.CString(path)
+	defer C.free(unsafe.Pointer(pathC))
+	return C.QSslSocket_QSslSocket_AddDefaultCaCertificates(pathC, C.longlong(encoding), C.longlong(syntax)) != 0
+}
+
 func (ptr *QSslSocket) AtEnd() bool {
 	if ptr.Pointer() != nil {
 		return C.QSslSocket_AtEnd(ptr.Pointer()) != 0
@@ -15417,6 +15711,13 @@ func (ptr *QSslSocket) PrivateKey() *QSslKey {
 	return nil
 }
 
+func (ptr *QSslSocket) Protocol() QSsl__SslProtocol {
+	if ptr.Pointer() != nil {
+		return QSsl__SslProtocol(C.QSslSocket_Protocol(ptr.Pointer()))
+	}
+	return 0
+}
+
 //export callbackQSslSocket_Resume
 func callbackQSslSocket_Resume(ptr unsafe.Pointer) {
 
@@ -15462,12 +15763,27 @@ func (ptr *QSslSocket) SessionCipher() *QSslCipher {
 	return nil
 }
 
+func (ptr *QSslSocket) SessionProtocol() QSsl__SslProtocol {
+	if ptr.Pointer() != nil {
+		return QSsl__SslProtocol(C.QSslSocket_SessionProtocol(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QSslSocket) SetLocalCertificate(certificate QSslCertificate_ITF) {
 	if ptr.Pointer() != nil {
 		C.QSslSocket_SetLocalCertificate(ptr.Pointer(), PointerFromQSslCertificate(certificate))
 	}
 }
 
+func (ptr *QSslSocket) SetLocalCertificate2(path string, format QSsl__EncodingFormat) {
+	if ptr.Pointer() != nil {
+		var pathC = C.CString(path)
+		defer C.free(unsafe.Pointer(pathC))
+		C.QSslSocket_SetLocalCertificate2(ptr.Pointer(), pathC, C.longlong(format))
+	}
+}
+
 func (ptr *QSslSocket) SetPeerVerifyDepth(depth int) {
 	if ptr.Pointer() != nil {
 		C.QSslSocket_SetPeerVerifyDepth(ptr.Pointer(), C.int(int32(depth)))
@@ -15494,6 +15810,20 @@ func (ptr *QSslSocket) SetPrivateKey(key QSslKey_ITF) {
 	}
 }
 
+func (ptr *QSslSocket) SetPrivateKey2(fileName string, algorithm QSsl__KeyAlgorithm, format QSsl__EncodingFormat, passPhrase core.QByteArray_ITF) {
+	if ptr.Pointer() != nil {
+		var fileNameC = C.CString(fileName)
+		defer C.free(unsafe.Pointer(fileNameC))
+		C.QSslSocket_SetPrivateKey2(ptr.Pointer(), fileNameC, C.longlong(algorithm), C.longlong(format), core.PointerFromQByteArray(passPhrase))
+	}
+}
+
+func (ptr *QSslSocket) SetProtocol(protocol QSsl__SslProtocol) {
+	if ptr.Pointer() != nil {
+		C.QSslSocket_SetProtocol(ptr.Pointer(), C.longlong(protocol))
+	}
+}
+
 //export callbackQSslSocket_SetReadBufferSize
 func callbackQSslSocket_SetReadBufferSize(ptr unsafe.Pointer, size C.longlong) {
 
@@ -15846,6 +16176,42 @@ func (ptr *QSslSocket) DestroyQSslSocket() {
 	}
 }
 
+func (ptr *QSslSocket) caCertificates_atList(i int) *QSslCertificate {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQSslCertificateFromPointer(C.QSslSocket_caCertificates_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*QSslCertificate).DestroyQSslCertificate)
+		return tmpValue
+	}
+	return nil
+}
+
+func (ptr *QSslSocket) ciphers_atList(i int) *QSslCipher {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQSslCipherFromPointer(C.QSslSocket_ciphers_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*QSslCipher).DestroyQSslCipher)
+		return tmpValue
+	}
+	return nil
+}
+
+func (ptr *QSslSocket) defaultCaCertificates_atList(i int) *QSslCertificate {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQSslCertificateFromPointer(C.QSslSocket_defaultCaCertificates_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*QSslCertificate).DestroyQSslCertificate)
+		return tmpValue
+	}
+	return nil
+}
+
+func (ptr *QSslSocket) defaultCiphers_atList(i int) *QSslCipher {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQSslCipherFromPointer(C.QSslSocket_defaultCiphers_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*QSslCipher).DestroyQSslCipher)
+		return tmpValue
+	}
+	return nil
+}
+
 func (ptr *QSslSocket) localCertificateChain_atList(i int) *QSslCertificate {
 	if ptr.Pointer() != nil {
 		var tmpValue = NewQSslCertificateFromPointer(C.QSslSocket_localCertificateChain_atList(ptr.Pointer(), C.int(int32(i))))
@@ -15873,6 +16239,24 @@ func (ptr *QSslSocket) sslErrors_atList(i int) *QSslError {
 	return nil
 }
 
+func (ptr *QSslSocket) supportedCiphers_atList(i int) *QSslCipher {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQSslCipherFromPointer(C.QSslSocket_supportedCiphers_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*QSslCipher).DestroyQSslCipher)
+		return tmpValue
+	}
+	return nil
+}
+
+func (ptr *QSslSocket) systemCaCertificates_atList(i int) *QSslCertificate {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQSslCertificateFromPointer(C.QSslSocket_systemCaCertificates_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*QSslCertificate).DestroyQSslCertificate)
+		return tmpValue
+	}
+	return nil
+}
+
 //export callbackQSslSocket_ConnectToHost2
 func callbackQSslSocket_ConnectToHost2(ptr unsafe.Pointer, address unsafe.Pointer, port C.ushort, openMode C.longlong) {
 

network/network.h

@@ -624,6 +624,7 @@ void QNetworkCookie_DestroyQNetworkCookie(void* ptr);
 void* QNetworkCookie_parseCookies_atList(void* ptr, int i);
 void* QNetworkCookieJar_NewQNetworkCookieJar(void* parent);
 struct QtNetwork_PackedList QNetworkCookieJar_AllCookies(void* ptr);
+struct QtNetwork_PackedList QNetworkCookieJar_CookiesForUrl(void* ptr, void* url);
 char QNetworkCookieJar_DeleteCookie(void* ptr, void* cookie);
 char QNetworkCookieJar_DeleteCookieDefault(void* ptr, void* cookie);
 char QNetworkCookieJar_InsertCookie(void* ptr, void* cookie);
@@ -969,9 +970,22 @@ char QNetworkSession_EventFilter(void* ptr, void* watched, void* event);
 char QNetworkSession_EventFilterDefault(void* ptr, void* watched, void* event);
 void* QNetworkSession_MetaObject(void* ptr);
 void* QNetworkSession_MetaObjectDefault(void* ptr);
+int QSsl_TlsV1_1_Type();
+int QSsl_TlsV1_2_Type();
+int QSsl_AnyProtocol_Type();
+int QSsl_TlsV1SslV3_Type();
+int QSsl_SecureProtocols_Type();
+int QSsl_TlsV1_0OrLater_Type();
+int QSsl_TlsV1_1OrLater_Type();
+int QSsl_TlsV1_2OrLater_Type();
+void* QSslCertificate_NewQSslCertificate(void* device, long long format);
+void* QSslCertificate_NewQSslCertificate2(void* data, long long format);
 void* QSslCertificate_NewQSslCertificate3(void* other);
 void QSslCertificate_Clear(void* ptr);
 void* QSslCertificate_Digest(void* ptr, long long algorithm);
+struct QtNetwork_PackedList QSslCertificate_QSslCertificate_FromData(void* data, long long format);
+struct QtNetwork_PackedList QSslCertificate_QSslCertificate_FromDevice(void* device, long long format);
+struct QtNetwork_PackedList QSslCertificate_QSslCertificate_FromPath(char* path, long long format, long long syntax);
 char QSslCertificate_IsBlacklisted(void* ptr);
 void QSslCertificate_Swap(void* ptr, void* other);
 void QSslCertificate_DestroyQSslCertificate(void* ptr);
@@ -1010,11 +1024,13 @@ void QSslCertificateExtension_DestroyQSslCertificateExtension(void* ptr);
 void* QSslCipher_NewQSslCipher();
 void* QSslCipher_NewQSslCipher4(void* other);
 void* QSslCipher_NewQSslCipher2(char* name);
+void* QSslCipher_NewQSslCipher3(char* name, long long protocol);
 struct QtNetwork_PackedString QSslCipher_AuthenticationMethod(void* ptr);
 struct QtNetwork_PackedString QSslCipher_EncryptionMethod(void* ptr);
 char QSslCipher_IsNull(void* ptr);
 struct QtNetwork_PackedString QSslCipher_KeyExchangeMethod(void* ptr);
 struct QtNetwork_PackedString QSslCipher_Name(void* ptr);
+long long QSslCipher_Protocol(void* ptr);
 struct QtNetwork_PackedString QSslCipher_ProtocolString(void* ptr);
 int QSslCipher_SupportedBits(void* ptr);
 void QSslCipher_Swap(void* ptr, void* other);
@@ -1037,7 +1053,9 @@ struct QtNetwork_PackedList QSslConfiguration_PeerCertificateChain(void* ptr);
 int QSslConfiguration_PeerVerifyDepth(void* ptr);
 long long QSslConfiguration_PeerVerifyMode(void* ptr);
 void* QSslConfiguration_PrivateKey(void* ptr);
+long long QSslConfiguration_Protocol(void* ptr);
 void* QSslConfiguration_SessionCipher(void* ptr);
+long long QSslConfiguration_SessionProtocol(void* ptr);
 void* QSslConfiguration_SessionTicket(void* ptr);
 int QSslConfiguration_SessionTicketLifeTimeHint(void* ptr);
 void QSslConfiguration_QSslConfiguration_SetDefaultConfiguration(void* configuration);
@@ -1045,10 +1063,13 @@ void QSslConfiguration_SetLocalCertificate(void* ptr, void* certificate);
 void QSslConfiguration_SetPeerVerifyDepth(void* ptr, int depth);
 void QSslConfiguration_SetPeerVerifyMode(void* ptr, long long mode);
 void QSslConfiguration_SetPrivateKey(void* ptr, void* key);
+void QSslConfiguration_SetProtocol(void* ptr, long long protocol);
 void QSslConfiguration_SetSessionTicket(void* ptr, void* sessionTicket);
+void QSslConfiguration_SetSslOption(void* ptr, long long option, char on);
 struct QtNetwork_PackedList QSslConfiguration_QSslConfiguration_SupportedCiphers();
 void QSslConfiguration_Swap(void* ptr, void* other);
 struct QtNetwork_PackedList QSslConfiguration_QSslConfiguration_SystemCaCertificates();
+char QSslConfiguration_TestSslOption(void* ptr, long long option);
 void QSslConfiguration_DestroyQSslConfiguration(void* ptr);
 void* QSslConfiguration_allowedNextProtocols_atList(void* ptr, int i);
 void* QSslConfiguration_caCertificates_atList(void* ptr, int i);
@@ -1076,13 +1097,17 @@ struct QtNetwork_PackedString QSslError_ErrorString(void* ptr);
 void QSslError_Swap(void* ptr, void* other);
 void QSslError_DestroyQSslError(void* ptr);
 void* QSslKey_NewQSslKey();
+void* QSslKey_NewQSslKey3(void* device, long long algorithm, long long encoding, long long ty, void* passPhrase);
+void* QSslKey_NewQSslKey2(void* encoded, long long algorithm, long long encoding, long long ty, void* passPhrase);
 void* QSslKey_NewQSslKey5(void* other);
+long long QSslKey_Algorithm(void* ptr);
 void QSslKey_Clear(void* ptr);
 char QSslKey_IsNull(void* ptr);
 int QSslKey_Length(void* ptr);
 void QSslKey_Swap(void* ptr, void* other);
 void* QSslKey_ToDer(void* ptr, void* passPhrase);
 void* QSslKey_ToPem(void* ptr, void* passPhrase);
+long long QSslKey_Type(void* ptr);
 void QSslKey_DestroyQSslKey(void* ptr);
 void* QSslPreSharedKeyAuthenticator_NewQSslPreSharedKeyAuthenticator();
 void* QSslPreSharedKeyAuthenticator_NewQSslPreSharedKeyAuthenticator2(void* authenticator);
@@ -1098,7 +1123,9 @@ void QSslPreSharedKeyAuthenticator_DestroyQSslPreSharedKeyAuthenticator(void* pt
 void* QSslSocket_NewQSslSocket(void* parent);
 void QSslSocket_Abort(void* ptr);
 void QSslSocket_AddCaCertificate(void* ptr, void* certificate);
+char QSslSocket_AddCaCertificates(void* ptr, char* path, long long format, long long syntax);
 void QSslSocket_QSslSocket_AddDefaultCaCertificate(void* certificate);
+char QSslSocket_QSslSocket_AddDefaultCaCertificates(char* path, long long encoding, long long syntax);
 char QSslSocket_AtEnd(void* ptr);
 long long QSslSocket_BytesAvailable(void* ptr);
 long long QSslSocket_BytesToWrite(void* ptr);
@@ -1135,14 +1162,19 @@ void QSslSocket_ConnectPreSharedKeyAuthenticationRequired(void* ptr);
 void QSslSocket_DisconnectPreSharedKeyAuthenticationRequired(void* ptr);
 void QSslSocket_PreSharedKeyAuthenticationRequired(void* ptr, void* authenticator);
 void* QSslSocket_PrivateKey(void* ptr);
+long long QSslSocket_Protocol(void* ptr);
 void QSslSocket_Resume(void* ptr);
 void QSslSocket_ResumeDefault(void* ptr);
 void* QSslSocket_SessionCipher(void* ptr);
+long long QSslSocket_SessionProtocol(void* ptr);
 void QSslSocket_SetLocalCertificate(void* ptr, void* certificate);
+void QSslSocket_SetLocalCertificate2(void* ptr, char* path, long long format);
 void QSslSocket_SetPeerVerifyDepth(void* ptr, int depth);
 void QSslSocket_SetPeerVerifyMode(void* ptr, long long mode);
 void QSslSocket_SetPeerVerifyName(void* ptr, char* hostName);
 void QSslSocket_SetPrivateKey(void* ptr, void* key);
+void QSslSocket_SetPrivateKey2(void* ptr, char* fileName, long long algorithm, long long format, void* passPhrase);
+void QSslSocket_SetProtocol(void* ptr, long long protocol);
 void QSslSocket_SetReadBufferSize(void* ptr, long long size);
 void QSslSocket_SetReadBufferSizeDefault(void* ptr, long long size);
 void QSslSocket_SetSocketOption(void* ptr, long long option, void* value);
@@ -1168,9 +1200,15 @@ char QSslSocket_WaitForEncrypted(void* ptr, int msecs);
 char QSslSocket_WaitForReadyRead(void* ptr, int msecs);
 long long QSslSocket_WriteData(void* ptr, char* data, long long len);
 void QSslSocket_DestroyQSslSocket(void* ptr);
+void* QSslSocket_caCertificates_atList(void* ptr, int i);
+void* QSslSocket_ciphers_atList(void* ptr, int i);
+void* QSslSocket_defaultCaCertificates_atList(void* ptr, int i);
+void* QSslSocket_defaultCiphers_atList(void* ptr, int i);
 void* QSslSocket_localCertificateChain_atList(void* ptr, int i);
 void* QSslSocket_peerCertificateChain_atList(void* ptr, int i);
 void* QSslSocket_sslErrors_atList(void* ptr, int i);
+void* QSslSocket_supportedCiphers_atList(void* ptr, int i);
+void* QSslSocket_systemCaCertificates_atList(void* ptr, int i);
 void QSslSocket_ConnectToHost2(void* ptr, void* address, unsigned short port, long long openMode);
 void QSslSocket_ConnectToHost2Default(void* ptr, void* address, unsigned short port, long long openMode);
 void QSslSocket_ConnectToHost(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);

printsupport/printsupport.go

@@ -4826,6 +4826,112 @@ func (ptr *QPageSetupDialog) MetaObjectDefault() *core.QMetaObject {
 	return nil
 }
 
+//QPrint::ColorMode
+type QPrint__ColorMode int64
+
+const (
+	QPrint__GrayScale = QPrint__ColorMode(0)
+	QPrint__Color     = QPrint__ColorMode(1)
+)
+
+//QPrint::DeviceState
+type QPrint__DeviceState int64
+
+const (
+	QPrint__Idle    = QPrint__DeviceState(0)
+	QPrint__Active  = QPrint__DeviceState(1)
+	QPrint__Aborted = QPrint__DeviceState(2)
+	QPrint__Error   = QPrint__DeviceState(3)
+)
+
+//QPrint::DuplexMode
+type QPrint__DuplexMode int64
+
+const (
+	QPrint__DuplexNone      = QPrint__DuplexMode(0)
+	QPrint__DuplexAuto      = QPrint__DuplexMode(1)
+	QPrint__DuplexLongSide  = QPrint__DuplexMode(2)
+	QPrint__DuplexShortSide = QPrint__DuplexMode(3)
+)
+
+//QPrint::InputSlotId
+type QPrint__InputSlotId int64
+
+const (
+	QPrint__Upper           = QPrint__InputSlotId(0)
+	QPrint__Lower           = QPrint__InputSlotId(1)
+	QPrint__Middle          = QPrint__InputSlotId(2)
+	QPrint__Manual          = QPrint__InputSlotId(3)
+	QPrint__Envelope        = QPrint__InputSlotId(4)
+	QPrint__EnvelopeManual  = QPrint__InputSlotId(5)
+	QPrint__Auto            = QPrint__InputSlotId(6)
+	QPrint__Tractor         = QPrint__InputSlotId(7)
+	QPrint__SmallFormat     = QPrint__InputSlotId(8)
+	QPrint__LargeFormat     = QPrint__InputSlotId(9)
+	QPrint__LargeCapacity   = QPrint__InputSlotId(10)
+	QPrint__Cassette        = QPrint__InputSlotId(11)
+	QPrint__FormSource      = QPrint__InputSlotId(12)
+	QPrint__MaxPageSource   = QPrint__InputSlotId(13)
+	QPrint__CustomInputSlot = QPrint__InputSlotId(14)
+	QPrint__LastInputSlot   = QPrint__InputSlotId(QPrint__CustomInputSlot)
+	QPrint__OnlyOne         = QPrint__InputSlotId(QPrint__Upper)
+)
+
+//QPrint::OutputBinId
+type QPrint__OutputBinId int64
+
+const (
+	QPrint__AutoOutputBin   = QPrint__OutputBinId(0)
+	QPrint__UpperBin        = QPrint__OutputBinId(1)
+	QPrint__LowerBin        = QPrint__OutputBinId(2)
+	QPrint__RearBin         = QPrint__OutputBinId(3)
+	QPrint__CustomOutputBin = QPrint__OutputBinId(4)
+	QPrint__LastOutputBin   = QPrint__OutputBinId(QPrint__CustomOutputBin)
+)
+
+type QPrint struct {
+	ptr unsafe.Pointer
+}
+
+type QPrint_ITF interface {
+	QPrint_PTR() *QPrint
+}
+
+func (p *QPrint) QPrint_PTR() *QPrint {
+	return p
+}
+
+func (p *QPrint) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QPrint) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQPrint(ptr QPrint_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QPrint_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQPrintFromPointer(ptr unsafe.Pointer) *QPrint {
+	var n = new(QPrint)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QPrint) DestroyQPrint() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QPrintDialog struct {
 	QAbstractPrintDialog
 }

qml/qml.go

@@ -6125,6 +6125,71 @@ func (ptr *QQmlParserStatus) ComponentComplete() {
 	}
 }
 
+//QQmlPrivate::AutoParentResult
+type QQmlPrivate__AutoParentResult int64
+
+const (
+	QQmlPrivate__Parented           = QQmlPrivate__AutoParentResult(0)
+	QQmlPrivate__IncompatibleObject = QQmlPrivate__AutoParentResult(1)
+	QQmlPrivate__IncompatibleParent = QQmlPrivate__AutoParentResult(2)
+)
+
+//QQmlPrivate::RegistrationType
+type QQmlPrivate__RegistrationType int64
+
+const (
+	QQmlPrivate__TypeRegistration               = QQmlPrivate__RegistrationType(0)
+	QQmlPrivate__InterfaceRegistration          = QQmlPrivate__RegistrationType(1)
+	QQmlPrivate__AutoParentRegistration         = QQmlPrivate__RegistrationType(2)
+	QQmlPrivate__SingletonRegistration          = QQmlPrivate__RegistrationType(3)
+	QQmlPrivate__CompositeRegistration          = QQmlPrivate__RegistrationType(4)
+	QQmlPrivate__CompositeSingletonRegistration = QQmlPrivate__RegistrationType(5)
+	QQmlPrivate__QmlUnitCacheHookRegistration   = QQmlPrivate__RegistrationType(6)
+)
+
+type QQmlPrivate struct {
+	ptr unsafe.Pointer
+}
+
+type QQmlPrivate_ITF interface {
+	QQmlPrivate_PTR() *QQmlPrivate
+}
+
+func (p *QQmlPrivate) QQmlPrivate_PTR() *QQmlPrivate {
+	return p
+}
+
+func (p *QQmlPrivate) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QQmlPrivate) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQQmlPrivate(ptr QQmlPrivate_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QQmlPrivate_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQQmlPrivateFromPointer(ptr unsafe.Pointer) *QQmlPrivate {
+	var n = new(QQmlPrivate)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QQmlPrivate) DestroyQQmlPrivate() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 //QQmlProperty::PropertyTypeCategory
 type QQmlProperty__PropertyTypeCategory int64
 
@@ -7248,3 +7313,68 @@ func (ptr *QQmlScriptString) StringLiteral() string {
 	}
 	return ""
 }
+
+//QV4::PropertyFlag
+type QV4__PropertyFlag int64
+
+const (
+	QV4__Attr_Data            = QV4__PropertyFlag(0)
+	QV4__Attr_Accessor        = QV4__PropertyFlag(0x1)
+	QV4__Attr_NotWritable     = QV4__PropertyFlag(0x2)
+	QV4__Attr_NotEnumerable   = QV4__PropertyFlag(0x4)
+	QV4__Attr_NotConfigurable = QV4__PropertyFlag(0x8)
+	QV4__Attr_ReadOnly        = QV4__PropertyFlag(QV4__Attr_NotWritable | QV4__Attr_NotEnumerable | QV4__Attr_NotConfigurable)
+	QV4__Attr_Invalid         = QV4__PropertyFlag(0xff)
+)
+
+//QV4::TypeHint
+type QV4__TypeHint int64
+
+const (
+	QV4__PREFERREDTYPE_HINT = QV4__TypeHint(0)
+	QV4__NUMBER_HINT        = QV4__TypeHint(1)
+	QV4__STRING_HINT        = QV4__TypeHint(2)
+)
+
+type QV4 struct {
+	ptr unsafe.Pointer
+}
+
+type QV4_ITF interface {
+	QV4_PTR() *QV4
+}
+
+func (p *QV4) QV4_PTR() *QV4 {
+	return p
+}
+
+func (p *QV4) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QV4) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQV4(ptr QV4_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QV4_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQV4FromPointer(ptr unsafe.Pointer) *QV4 {
+	var n = new(QV4)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QV4) DestroyQV4() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}

quick/quick.go

@@ -15697,6 +15697,57 @@ func (ptr *QSGBasicGeometryNode) PreprocessDefault() {
 	}
 }
 
+//QSGBatchRenderer::BatchCompatibility
+type QSGBatchRenderer__BatchCompatibility int64
+
+const (
+	QSGBatchRenderer__BatchBreaksOnCompare = QSGBatchRenderer__BatchCompatibility(0)
+	QSGBatchRenderer__BatchIsCompatible    = QSGBatchRenderer__BatchCompatibility(1)
+)
+
+type QSGBatchRenderer struct {
+	ptr unsafe.Pointer
+}
+
+type QSGBatchRenderer_ITF interface {
+	QSGBatchRenderer_PTR() *QSGBatchRenderer
+}
+
+func (p *QSGBatchRenderer) QSGBatchRenderer_PTR() *QSGBatchRenderer {
+	return p
+}
+
+func (p *QSGBatchRenderer) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QSGBatchRenderer) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQSGBatchRenderer(ptr QSGBatchRenderer_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QSGBatchRenderer_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQSGBatchRendererFromPointer(ptr unsafe.Pointer) *QSGBatchRenderer {
+	var n = new(QSGBatchRenderer)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QSGBatchRenderer) DestroyQSGBatchRenderer() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QSGClipNode struct {
 	QSGBasicGeometryNode
 }

script/script.go

@@ -22,6 +22,133 @@ func cGoUnpackString(s C.struct_QtScript_PackedString) string {
 	return C.GoStringN(s.data, C.int(s.len))
 }
 
+//QSOperator::Op
+type QSOperator__Op int64
+
+const (
+	QSOperator__Add                = QSOperator__Op(0)
+	QSOperator__And                = QSOperator__Op(1)
+	QSOperator__InplaceAnd         = QSOperator__Op(2)
+	QSOperator__Assign             = QSOperator__Op(3)
+	QSOperator__BitAnd             = QSOperator__Op(4)
+	QSOperator__BitOr              = QSOperator__Op(5)
+	QSOperator__BitXor             = QSOperator__Op(6)
+	QSOperator__InplaceSub         = QSOperator__Op(7)
+	QSOperator__Div                = QSOperator__Op(8)
+	QSOperator__InplaceDiv         = QSOperator__Op(9)
+	QSOperator__Equal              = QSOperator__Op(10)
+	QSOperator__Ge                 = QSOperator__Op(11)
+	QSOperator__Gt                 = QSOperator__Op(12)
+	QSOperator__In                 = QSOperator__Op(13)
+	QSOperator__InplaceAdd         = QSOperator__Op(14)
+	QSOperator__InstanceOf         = QSOperator__Op(15)
+	QSOperator__Le                 = QSOperator__Op(16)
+	QSOperator__LShift             = QSOperator__Op(17)
+	QSOperator__InplaceLeftShift   = QSOperator__Op(18)
+	QSOperator__Lt                 = QSOperator__Op(19)
+	QSOperator__Mod                = QSOperator__Op(20)
+	QSOperator__InplaceMod         = QSOperator__Op(21)
+	QSOperator__Mul                = QSOperator__Op(22)
+	QSOperator__InplaceMul         = QSOperator__Op(23)
+	QSOperator__NotEqual           = QSOperator__Op(24)
+	QSOperator__Or                 = QSOperator__Op(25)
+	QSOperator__InplaceOr          = QSOperator__Op(26)
+	QSOperator__RShift             = QSOperator__Op(27)
+	QSOperator__InplaceRightShift  = QSOperator__Op(28)
+	QSOperator__StrictEqual        = QSOperator__Op(29)
+	QSOperator__StrictNotEqual     = QSOperator__Op(30)
+	QSOperator__Sub                = QSOperator__Op(31)
+	QSOperator__URShift            = QSOperator__Op(32)
+	QSOperator__InplaceURightShift = QSOperator__Op(33)
+	QSOperator__InplaceXor         = QSOperator__Op(34)
+)
+
+type QSOperator struct {
+	ptr unsafe.Pointer
+}
+
+type QSOperator_ITF interface {
+	QSOperator_PTR() *QSOperator
+}
+
+func (p *QSOperator) QSOperator_PTR() *QSOperator {
+	return p
+}
+
+func (p *QSOperator) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QSOperator) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQSOperator(ptr QSOperator_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QSOperator_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQSOperatorFromPointer(ptr unsafe.Pointer) *QSOperator {
+	var n = new(QSOperator)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QSOperator) DestroyQSOperator() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
+type QScript struct {
+	ptr unsafe.Pointer
+}
+
+type QScript_ITF interface {
+	QScript_PTR() *QScript
+}
+
+func (p *QScript) QScript_PTR() *QScript {
+	return p
+}
+
+func (p *QScript) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QScript) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQScript(ptr QScript_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QScript_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQScriptFromPointer(ptr unsafe.Pointer) *QScript {
+	var n = new(QScript)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QScript) DestroyQScript() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 //QScriptClass::Extension
 type QScriptClass__Extension int64
 

sensors/sensors.go

@@ -22,6 +22,72 @@ func cGoUnpackString(s C.struct_QtSensors_PackedString) string {
 	return C.GoStringN(s.data, C.int(s.len))
 }
 
+//AndroidSensors::AndroidSensorType
+type AndroidSensors__AndroidSensorType int64
+
+const (
+	AndroidSensors__TYPE_ACCELEROMETER               = AndroidSensors__AndroidSensorType(1)
+	AndroidSensors__TYPE_AMBIENT_TEMPERATURE         = AndroidSensors__AndroidSensorType(13)
+	AndroidSensors__TYPE_GAME_ROTATION_VECTOR        = AndroidSensors__AndroidSensorType(15)
+	AndroidSensors__TYPE_GRAVITY                     = AndroidSensors__AndroidSensorType(9)
+	AndroidSensors__TYPE_GYROSCOPE                   = AndroidSensors__AndroidSensorType(4)
+	AndroidSensors__TYPE_GYROSCOPE_UNCALIBRATED      = AndroidSensors__AndroidSensorType(16)
+	AndroidSensors__TYPE_LIGHT                       = AndroidSensors__AndroidSensorType(5)
+	AndroidSensors__TYPE_LINEAR_ACCELERATION         = AndroidSensors__AndroidSensorType(10)
+	AndroidSensors__TYPE_MAGNETIC_FIELD              = AndroidSensors__AndroidSensorType(2)
+	AndroidSensors__TYPE_MAGNETIC_FIELD_UNCALIBRATED = AndroidSensors__AndroidSensorType(14)
+	AndroidSensors__TYPE_ORIENTATION                 = AndroidSensors__AndroidSensorType(3)
+	AndroidSensors__TYPE_PRESSURE                    = AndroidSensors__AndroidSensorType(6)
+	AndroidSensors__TYPE_PROXIMITY                   = AndroidSensors__AndroidSensorType(8)
+	AndroidSensors__TYPE_RELATIVE_HUMIDITY           = AndroidSensors__AndroidSensorType(12)
+	AndroidSensors__TYPE_ROTATION_VECTOR             = AndroidSensors__AndroidSensorType(11)
+	AndroidSensors__TYPE_SIGNIFICANT_MOTION          = AndroidSensors__AndroidSensorType(17)
+	AndroidSensors__TYPE_TEMPERATURE                 = AndroidSensors__AndroidSensorType(7)
+)
+
+type AndroidSensors struct {
+	ptr unsafe.Pointer
+}
+
+type AndroidSensors_ITF interface {
+	AndroidSensors_PTR() *AndroidSensors
+}
+
+func (p *AndroidSensors) AndroidSensors_PTR() *AndroidSensors {
+	return p
+}
+
+func (p *AndroidSensors) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *AndroidSensors) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromAndroidSensors(ptr AndroidSensors_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.AndroidSensors_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewAndroidSensorsFromPointer(ptr unsafe.Pointer) *AndroidSensors {
+	var n = new(AndroidSensors)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *AndroidSensors) DestroyAndroidSensors() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 //QAccelerometer::AccelerationMode
 type QAccelerometer__AccelerationMode int64
 
@@ -21186,3 +21252,58 @@ func (ptr *QTiltSensor) MetaObjectDefault() *core.QMetaObject {
 	}
 	return nil
 }
+
+//QtMobility::SimulatorLightLevel
+type QtMobility__SimulatorLightLevel int64
+
+const (
+	QtMobility__Undefined = QtMobility__SimulatorLightLevel(0)
+	QtMobility__Dark      = QtMobility__SimulatorLightLevel(1)
+	QtMobility__Twilight  = QtMobility__SimulatorLightLevel(2)
+	QtMobility__Light     = QtMobility__SimulatorLightLevel(3)
+	QtMobility__Bright    = QtMobility__SimulatorLightLevel(4)
+	QtMobility__Sunny     = QtMobility__SimulatorLightLevel(5)
+)
+
+type QtMobility struct {
+	ptr unsafe.Pointer
+}
+
+type QtMobility_ITF interface {
+	QtMobility_PTR() *QtMobility
+}
+
+func (p *QtMobility) QtMobility_PTR() *QtMobility {
+	return p
+}
+
+func (p *QtMobility) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QtMobility) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQtMobility(ptr QtMobility_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QtMobility_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQtMobilityFromPointer(ptr unsafe.Pointer) *QtMobility {
+	var n = new(QtMobility)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QtMobility) DestroyQtMobility() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}

serialbus/serialbus.go

@@ -21,6 +21,121 @@ func cGoUnpackString(s C.struct_QtSerialBus_PackedString) string {
 	return C.GoStringN(s.data, C.int(s.len))
 }
 
+//Diagnostics::SubFunctionCode
+type Diagnostics__SubFunctionCode int64
+
+const (
+	Diagnostics__ReturnQueryData                    = Diagnostics__SubFunctionCode(0x0000)
+	Diagnostics__RestartCommunicationsOption        = Diagnostics__SubFunctionCode(0x0001)
+	Diagnostics__ReturnDiagnosticRegister           = Diagnostics__SubFunctionCode(0x0002)
+	Diagnostics__ChangeAsciiInputDelimiter          = Diagnostics__SubFunctionCode(0x0003)
+	Diagnostics__ForceListenOnlyMode                = Diagnostics__SubFunctionCode(0x0004)
+	Diagnostics__ClearCountersAndDiagnosticRegister = Diagnostics__SubFunctionCode(0x000a)
+	Diagnostics__ReturnBusMessageCount              = Diagnostics__SubFunctionCode(0x000b)
+	Diagnostics__ReturnBusCommunicationErrorCount   = Diagnostics__SubFunctionCode(0x000c)
+	Diagnostics__ReturnBusExceptionErrorCount       = Diagnostics__SubFunctionCode(0x000d)
+	Diagnostics__ReturnServerMessageCount           = Diagnostics__SubFunctionCode(0x000e)
+	Diagnostics__ReturnServerNoResponseCount        = Diagnostics__SubFunctionCode(0x000f)
+	Diagnostics__ReturnServerNAKCount               = Diagnostics__SubFunctionCode(0x0010)
+	Diagnostics__ReturnServerBusyCount              = Diagnostics__SubFunctionCode(0x0011)
+	Diagnostics__ReturnBusCharacterOverrunCount     = Diagnostics__SubFunctionCode(0x0012)
+	Diagnostics__ClearOverrunCounterAndFlag         = Diagnostics__SubFunctionCode(0x0014)
+)
+
+type Diagnostics struct {
+	ptr unsafe.Pointer
+}
+
+type Diagnostics_ITF interface {
+	Diagnostics_PTR() *Diagnostics
+}
+
+func (p *Diagnostics) Diagnostics_PTR() *Diagnostics {
+	return p
+}
+
+func (p *Diagnostics) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *Diagnostics) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromDiagnostics(ptr Diagnostics_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.Diagnostics_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewDiagnosticsFromPointer(ptr unsafe.Pointer) *Diagnostics {
+	var n = new(Diagnostics)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *Diagnostics) DestroyDiagnostics() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
+//EncapsulatedInterfaceTransport::SubFunctionCode
+type EncapsulatedInterfaceTransport__SubFunctionCode int64
+
+const (
+	EncapsulatedInterfaceTransport__CanOpenGeneralReference  = EncapsulatedInterfaceTransport__SubFunctionCode(0x0D)
+	EncapsulatedInterfaceTransport__ReadDeviceIdentification = EncapsulatedInterfaceTransport__SubFunctionCode(0x0E)
+)
+
+type EncapsulatedInterfaceTransport struct {
+	ptr unsafe.Pointer
+}
+
+type EncapsulatedInterfaceTransport_ITF interface {
+	EncapsulatedInterfaceTransport_PTR() *EncapsulatedInterfaceTransport
+}
+
+func (p *EncapsulatedInterfaceTransport) EncapsulatedInterfaceTransport_PTR() *EncapsulatedInterfaceTransport {
+	return p
+}
+
+func (p *EncapsulatedInterfaceTransport) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *EncapsulatedInterfaceTransport) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromEncapsulatedInterfaceTransport(ptr EncapsulatedInterfaceTransport_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.EncapsulatedInterfaceTransport_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewEncapsulatedInterfaceTransportFromPointer(ptr unsafe.Pointer) *EncapsulatedInterfaceTransport {
+	var n = new(EncapsulatedInterfaceTransport)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *EncapsulatedInterfaceTransport) DestroyEncapsulatedInterfaceTransport() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QCanBus struct {
 	core.QObject
 }

sql/sql.cpp

@@ -174,6 +174,11 @@ void* QSqlDatabase_LastError(void* ptr)
 	return new QSqlError(static_cast<QSqlDatabase*>(ptr)->lastError());
 }
 
+long long QSqlDatabase_NumericalPrecisionPolicy(void* ptr)
+{
+	return static_cast<QSqlDatabase*>(ptr)->numericalPrecisionPolicy();
+}
+
 char QSqlDatabase_Open(void* ptr)
 {
 	return static_cast<QSqlDatabase*>(ptr)->open();
@@ -234,6 +239,11 @@ void QSqlDatabase_SetHostName(void* ptr, char* host)
 	static_cast<QSqlDatabase*>(ptr)->setHostName(QString(host));
 }
 
+void QSqlDatabase_SetNumericalPrecisionPolicy(void* ptr, long long precisionPolicy)
+{
+	static_cast<QSqlDatabase*>(ptr)->setNumericalPrecisionPolicy(static_cast<QSql::NumericalPrecisionPolicy>(precisionPolicy));
+}
+
 void QSqlDatabase_SetPassword(void* ptr, char* password)
 {
 	static_cast<QSqlDatabase*>(ptr)->setPassword(QString(password));
@@ -249,6 +259,11 @@ void QSqlDatabase_SetUserName(void* ptr, char* name)
 	static_cast<QSqlDatabase*>(ptr)->setUserName(QString(name));
 }
 
+struct QtSql_PackedString QSqlDatabase_Tables(void* ptr, long long ty)
+{
+	return ({ QByteArray t302bb5 = static_cast<QSqlDatabase*>(ptr)->tables(static_cast<QSql::TableType>(ty)).join("|").toUtf8(); QtSql_PackedString { const_cast<char*>(t302bb5.prepend("WHITESPACE").constData()+10), t302bb5.size()-10 }; });
+}
+
 char QSqlDatabase_Transaction(void* ptr)
 {
 	return static_cast<QSqlDatabase*>(ptr)->transaction();
@@ -296,6 +311,7 @@ public:
 	QString stripDelimiters(const QString & identifier, QSqlDriver::IdentifierType ty) const { QByteArray tfae9fd = identifier.toUtf8(); QtSql_PackedString identifierPacked = { const_cast<char*>(tfae9fd.prepend("WHITESPACE").constData()+10), tfae9fd.size()-10 };return QString(callbackQSqlDriver_StripDelimiters(const_cast<MyQSqlDriver*>(this), identifierPacked, ty)); };
 	bool subscribeToNotification(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtSql_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };return callbackQSqlDriver_SubscribeToNotification(this, namePacked) != 0; };
 	QStringList subscribedToNotifications() const { return QString(callbackQSqlDriver_SubscribedToNotifications(const_cast<MyQSqlDriver*>(this))).split("|", QString::SkipEmptyParts); };
+	QStringList tables(QSql::TableType tableType) const { return QString(callbackQSqlDriver_Tables(const_cast<MyQSqlDriver*>(this), tableType)).split("|", QString::SkipEmptyParts); };
 	bool unsubscribeFromNotification(const QString & name) { QByteArray t6ae999 = name.toUtf8(); QtSql_PackedString namePacked = { const_cast<char*>(t6ae999.prepend("WHITESPACE").constData()+10), t6ae999.size()-10 };return callbackQSqlDriver_UnsubscribeFromNotification(this, namePacked) != 0; };
 	void timerEvent(QTimerEvent * event) { callbackQSqlDriver_TimerEvent(this, event); };
 	void childEvent(QChildEvent * event) { callbackQSqlDriver_ChildEvent(this, event); };
@@ -443,6 +459,11 @@ void QSqlDriver_Notification2(void* ptr, char* name, long long source, void* pay
 	static_cast<QSqlDriver*>(ptr)->notification(QString(name), static_cast<QSqlDriver::NotificationSource>(source), *static_cast<QVariant*>(payload));
 }
 
+long long QSqlDriver_NumericalPrecisionPolicy(void* ptr)
+{
+	return static_cast<QSqlDriver*>(ptr)->numericalPrecisionPolicy();
+}
+
 char QSqlDriver_Open(void* ptr, char* db, char* user, char* password, char* host, int port, char* options)
 {
 	return static_cast<QSqlDriver*>(ptr)->open(QString(db), QString(user), QString(password), QString(host), port, QString(options));
@@ -488,6 +509,11 @@ void QSqlDriver_SetLastErrorDefault(void* ptr, void* error)
 	static_cast<QSqlDriver*>(ptr)->QSqlDriver::setLastError(*static_cast<QSqlError*>(error));
 }
 
+void QSqlDriver_SetNumericalPrecisionPolicy(void* ptr, long long precisionPolicy)
+{
+	static_cast<QSqlDriver*>(ptr)->setNumericalPrecisionPolicy(static_cast<QSql::NumericalPrecisionPolicy>(precisionPolicy));
+}
+
 void QSqlDriver_SetOpen(void* ptr, char open)
 {
 	static_cast<QSqlDriver*>(ptr)->setOpen(open != 0);
@@ -548,6 +574,16 @@ struct QtSql_PackedString QSqlDriver_SubscribedToNotificationsDefault(void* ptr)
 	return ({ QByteArray t063c3c = static_cast<QSqlDriver*>(ptr)->QSqlDriver::subscribedToNotifications().join("|").toUtf8(); QtSql_PackedString { const_cast<char*>(t063c3c.prepend("WHITESPACE").constData()+10), t063c3c.size()-10 }; });
 }
 
+struct QtSql_PackedString QSqlDriver_Tables(void* ptr, long long tableType)
+{
+	return ({ QByteArray tcfb904 = static_cast<QSqlDriver*>(ptr)->tables(static_cast<QSql::TableType>(tableType)).join("|").toUtf8(); QtSql_PackedString { const_cast<char*>(tcfb904.prepend("WHITESPACE").constData()+10), tcfb904.size()-10 }; });
+}
+
+struct QtSql_PackedString QSqlDriver_TablesDefault(void* ptr, long long tableType)
+{
+	return ({ QByteArray tf0f7df = static_cast<QSqlDriver*>(ptr)->QSqlDriver::tables(static_cast<QSql::TableType>(tableType)).join("|").toUtf8(); QtSql_PackedString { const_cast<char*>(tf0f7df.prepend("WHITESPACE").constData()+10), tf0f7df.size()-10 }; });
+}
+
 char QSqlDriver_UnsubscribeFromNotification(void* ptr, char* name)
 {
 	return static_cast<QSqlDriver*>(ptr)->unsubscribeFromNotification(QString(name));
@@ -1036,11 +1072,26 @@ void* QSqlQuery_NewQSqlQuery2(char* query, void* db)
 	return new QSqlQuery(QString(query), *static_cast<QSqlDatabase*>(db));
 }
 
+void QSqlQuery_AddBindValue(void* ptr, void* val, long long paramType)
+{
+	static_cast<QSqlQuery*>(ptr)->addBindValue(*static_cast<QVariant*>(val), static_cast<QSql::ParamTypeFlag>(paramType));
+}
+
 int QSqlQuery_At(void* ptr)
 {
 	return static_cast<QSqlQuery*>(ptr)->at();
 }
 
+void QSqlQuery_BindValue(void* ptr, char* placeholder, void* val, long long paramType)
+{
+	static_cast<QSqlQuery*>(ptr)->bindValue(QString(placeholder), *static_cast<QVariant*>(val), static_cast<QSql::ParamTypeFlag>(paramType));
+}
+
+void QSqlQuery_BindValue2(void* ptr, int pos, void* val, long long paramType)
+{
+	static_cast<QSqlQuery*>(ptr)->bindValue(pos, *static_cast<QVariant*>(val), static_cast<QSql::ParamTypeFlag>(paramType));
+}
+
 void* QSqlQuery_BoundValue(void* ptr, char* placeholder)
 {
 	return new QVariant(static_cast<QSqlQuery*>(ptr)->boundValue(QString(placeholder)));
@@ -1156,6 +1207,11 @@ int QSqlQuery_NumRowsAffected(void* ptr)
 	return static_cast<QSqlQuery*>(ptr)->numRowsAffected();
 }
 
+long long QSqlQuery_NumericalPrecisionPolicy(void* ptr)
+{
+	return static_cast<QSqlQuery*>(ptr)->numericalPrecisionPolicy();
+}
+
 char QSqlQuery_Prepare(void* ptr, char* query)
 {
 	return static_cast<QSqlQuery*>(ptr)->prepare(QString(query));
@@ -1186,6 +1242,11 @@ void QSqlQuery_SetForwardOnly(void* ptr, char forward)
 	static_cast<QSqlQuery*>(ptr)->setForwardOnly(forward != 0);
 }
 
+void QSqlQuery_SetNumericalPrecisionPolicy(void* ptr, long long precisionPolicy)
+{
+	static_cast<QSqlQuery*>(ptr)->setNumericalPrecisionPolicy(static_cast<QSql::NumericalPrecisionPolicy>(precisionPolicy));
+}
+
 int QSqlQuery_Size(void* ptr)
 {
 	return static_cast<QSqlQuery*>(ptr)->size();
@@ -2599,6 +2660,8 @@ class MyQSqlResult: public QSqlResult
 {
 public:
 	MyQSqlResult(const QSqlDriver *db) : QSqlResult(db) {};
+	void bindValue(const QString & placeholder, const QVariant & val, QSql::ParamType paramType) { QByteArray tff5543 = placeholder.toUtf8(); QtSql_PackedString placeholderPacked = { const_cast<char*>(tff5543.prepend("WHITESPACE").constData()+10), tff5543.size()-10 };callbackQSqlResult_BindValue2(this, placeholderPacked, const_cast<QVariant*>(&val), paramType); };
+	void bindValue(int index, const QVariant & val, QSql::ParamType paramType) { callbackQSqlResult_BindValue(this, index, const_cast<QVariant*>(&val), paramType); };
 	QVariant data(int index) { return *static_cast<QVariant*>(callbackQSqlResult_Data(this, index)); };
 	bool exec() { return callbackQSqlResult_Exec(this) != 0; };
 	bool fetch(int index) { return callbackQSqlResult_Fetch(this, index) != 0; };
@@ -2629,11 +2692,46 @@ void* QSqlResult_NewQSqlResult(void* db)
 	return new MyQSqlResult(static_cast<QSqlDriver*>(db));
 }
 
+void QSqlResult_AddBindValue(void* ptr, void* val, long long paramType)
+{
+	static_cast<QSqlResult*>(ptr)->addBindValue(*static_cast<QVariant*>(val), static_cast<QSql::ParamTypeFlag>(paramType));
+}
+
 int QSqlResult_At(void* ptr)
 {
 	return static_cast<QSqlResult*>(ptr)->at();
 }
 
+void QSqlResult_BindValue2(void* ptr, char* placeholder, void* val, long long paramType)
+{
+	static_cast<QSqlResult*>(ptr)->bindValue(QString(placeholder), *static_cast<QVariant*>(val), static_cast<QSql::ParamTypeFlag>(paramType));
+}
+
+void QSqlResult_BindValue2Default(void* ptr, char* placeholder, void* val, long long paramType)
+{
+	static_cast<QSqlResult*>(ptr)->QSqlResult::bindValue(QString(placeholder), *static_cast<QVariant*>(val), static_cast<QSql::ParamTypeFlag>(paramType));
+}
+
+void QSqlResult_BindValue(void* ptr, int index, void* val, long long paramType)
+{
+	static_cast<QSqlResult*>(ptr)->bindValue(index, *static_cast<QVariant*>(val), static_cast<QSql::ParamTypeFlag>(paramType));
+}
+
+void QSqlResult_BindValueDefault(void* ptr, int index, void* val, long long paramType)
+{
+	static_cast<QSqlResult*>(ptr)->QSqlResult::bindValue(index, *static_cast<QVariant*>(val), static_cast<QSql::ParamTypeFlag>(paramType));
+}
+
+long long QSqlResult_BindValueType2(void* ptr, char* placeholder)
+{
+	return static_cast<QSqlResult*>(ptr)->bindValueType(QString(placeholder));
+}
+
+long long QSqlResult_BindValueType(void* ptr, int index)
+{
+	return static_cast<QSqlResult*>(ptr)->bindValueType(index);
+}
+
 long long QSqlResult_BindingSyntax(void* ptr)
 {
 	return static_cast<QSqlResult*>(ptr)->bindingSyntax();

sql/sql.go

@@ -24,6 +24,87 @@ func cGoUnpackString(s C.struct_QtSql_PackedString) string {
 	return C.GoStringN(s.data, C.int(s.len))
 }
 
+//QSql::Location
+type QSql__Location int64
+
+const (
+	QSql__BeforeFirstRow = QSql__Location(-1)
+	QSql__AfterLastRow   = QSql__Location(-2)
+)
+
+//QSql::NumericalPrecisionPolicy
+type QSql__NumericalPrecisionPolicy int64
+
+const (
+	QSql__LowPrecisionInt32  = QSql__NumericalPrecisionPolicy(0x01)
+	QSql__LowPrecisionInt64  = QSql__NumericalPrecisionPolicy(0x02)
+	QSql__LowPrecisionDouble = QSql__NumericalPrecisionPolicy(0x04)
+	QSql__HighPrecision      = QSql__NumericalPrecisionPolicy(0)
+)
+
+//QSql::ParamTypeFlag
+type QSql__ParamTypeFlag int64
+
+const (
+	QSql__In     = QSql__ParamTypeFlag(0x00000001)
+	QSql__Out    = QSql__ParamTypeFlag(0x00000002)
+	QSql__InOut  = QSql__ParamTypeFlag(QSql__In | QSql__Out)
+	QSql__Binary = QSql__ParamTypeFlag(0x00000004)
+)
+
+//QSql::TableType
+type QSql__TableType int64
+
+const (
+	QSql__Tables       = QSql__TableType(0x01)
+	QSql__SystemTables = QSql__TableType(0x02)
+	QSql__Views        = QSql__TableType(0x04)
+	QSql__AllTables    = QSql__TableType(0xff)
+)
+
+type QSql struct {
+	ptr unsafe.Pointer
+}
+
+type QSql_ITF interface {
+	QSql_PTR() *QSql
+}
+
+func (p *QSql) QSql_PTR() *QSql {
+	return p
+}
+
+func (p *QSql) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QSql) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQSql(ptr QSql_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QSql_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQSqlFromPointer(ptr unsafe.Pointer) *QSql {
+	var n = new(QSql)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QSql) DestroyQSql() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QSqlDatabase struct {
 	ptr unsafe.Pointer
 }
@@ -295,6 +376,13 @@ func (ptr *QSqlDatabase) LastError() *QSqlError {
 	return nil
 }
 
+func (ptr *QSqlDatabase) NumericalPrecisionPolicy() QSql__NumericalPrecisionPolicy {
+	if ptr.Pointer() != nil {
+		return QSql__NumericalPrecisionPolicy(C.QSqlDatabase_NumericalPrecisionPolicy(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QSqlDatabase) Open() bool {
 	if ptr.Pointer() != nil {
 		return C.QSqlDatabase_Open(ptr.Pointer()) != 0
@@ -404,6 +492,12 @@ func (ptr *QSqlDatabase) SetHostName(host string) {
 	}
 }
 
+func (ptr *QSqlDatabase) SetNumericalPrecisionPolicy(precisionPolicy QSql__NumericalPrecisionPolicy) {
+	if ptr.Pointer() != nil {
+		C.QSqlDatabase_SetNumericalPrecisionPolicy(ptr.Pointer(), C.longlong(precisionPolicy))
+	}
+}
+
 func (ptr *QSqlDatabase) SetPassword(password string) {
 	if ptr.Pointer() != nil {
 		var passwordC = C.CString(password)
@@ -426,6 +520,13 @@ func (ptr *QSqlDatabase) SetUserName(name string) {
 	}
 }
 
+func (ptr *QSqlDatabase) Tables(ty QSql__TableType) []string {
+	if ptr.Pointer() != nil {
+		return strings.Split(cGoUnpackString(C.QSqlDatabase_Tables(ptr.Pointer(), C.longlong(ty))), "|")
+	}
+	return make([]string, 0)
+}
+
 func (ptr *QSqlDatabase) Transaction() bool {
 	if ptr.Pointer() != nil {
 		return C.QSqlDatabase_Transaction(ptr.Pointer()) != 0
@@ -1019,6 +1120,13 @@ func (ptr *QSqlDriver) Notification2(name string, source QSqlDriver__Notificatio
 	}
 }
 
+func (ptr *QSqlDriver) NumericalPrecisionPolicy() QSql__NumericalPrecisionPolicy {
+	if ptr.Pointer() != nil {
+		return QSql__NumericalPrecisionPolicy(C.QSqlDriver_NumericalPrecisionPolicy(ptr.Pointer()))
+	}
+	return 0
+}
+
 //export callbackQSqlDriver_Open
 func callbackQSqlDriver_Open(ptr unsafe.Pointer, db C.struct_QtSql_PackedString, user C.struct_QtSql_PackedString, password C.struct_QtSql_PackedString, host C.struct_QtSql_PackedString, port C.int, options C.struct_QtSql_PackedString) C.char {
 
@@ -1226,6 +1334,12 @@ func (ptr *QSqlDriver) SetLastErrorDefault(error QSqlError_ITF) {
 	}
 }
 
+func (ptr *QSqlDriver) SetNumericalPrecisionPolicy(precisionPolicy QSql__NumericalPrecisionPolicy) {
+	if ptr.Pointer() != nil {
+		C.QSqlDriver_SetNumericalPrecisionPolicy(ptr.Pointer(), C.longlong(precisionPolicy))
+	}
+}
+
 //export callbackQSqlDriver_SetOpen
 func callbackQSqlDriver_SetOpen(ptr unsafe.Pointer, open C.char) {
 
@@ -1462,6 +1576,44 @@ func (ptr *QSqlDriver) SubscribedToNotificationsDefault() []string {
 	return make([]string, 0)
 }
 
+//export callbackQSqlDriver_Tables
+func callbackQSqlDriver_Tables(ptr unsafe.Pointer, tableType C.longlong) *C.char {
+
+	if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlDriver::tables"); signal != nil {
+		return C.CString(strings.Join(signal.(func(QSql__TableType) []string)(QSql__TableType(tableType)), "|"))
+	}
+
+	return C.CString(strings.Join(NewQSqlDriverFromPointer(ptr).TablesDefault(QSql__TableType(tableType)), "|"))
+}
+
+func (ptr *QSqlDriver) ConnectTables(f func(tableType QSql__TableType) []string) {
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlDriver::tables", f)
+	}
+}
+
+func (ptr *QSqlDriver) DisconnectTables() {
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlDriver::tables")
+	}
+}
+
+func (ptr *QSqlDriver) Tables(tableType QSql__TableType) []string {
+	if ptr.Pointer() != nil {
+		return strings.Split(cGoUnpackString(C.QSqlDriver_Tables(ptr.Pointer(), C.longlong(tableType))), "|")
+	}
+	return make([]string, 0)
+}
+
+func (ptr *QSqlDriver) TablesDefault(tableType QSql__TableType) []string {
+	if ptr.Pointer() != nil {
+		return strings.Split(cGoUnpackString(C.QSqlDriver_TablesDefault(ptr.Pointer(), C.longlong(tableType))), "|")
+	}
+	return make([]string, 0)
+}
+
 //export callbackQSqlDriver_UnsubscribeFromNotification
 func callbackQSqlDriver_UnsubscribeFromNotification(ptr unsafe.Pointer, name C.struct_QtSql_PackedString) C.char {
 
@@ -2937,6 +3089,12 @@ func NewQSqlQuery2(query string, db QSqlDatabase_ITF) *QSqlQuery {
 	return tmpValue
 }
 
+func (ptr *QSqlQuery) AddBindValue(val core.QVariant_ITF, paramType QSql__ParamTypeFlag) {
+	if ptr.Pointer() != nil {
+		C.QSqlQuery_AddBindValue(ptr.Pointer(), core.PointerFromQVariant(val), C.longlong(paramType))
+	}
+}
+
 func (ptr *QSqlQuery) At() int {
 	if ptr.Pointer() != nil {
 		return int(int32(C.QSqlQuery_At(ptr.Pointer())))
@@ -2944,6 +3102,20 @@ func (ptr *QSqlQuery) At() int {
 	return 0
 }
 
+func (ptr *QSqlQuery) BindValue(placeholder string, val core.QVariant_ITF, paramType QSql__ParamTypeFlag) {
+	if ptr.Pointer() != nil {
+		var placeholderC = C.CString(placeholder)
+		defer C.free(unsafe.Pointer(placeholderC))
+		C.QSqlQuery_BindValue(ptr.Pointer(), placeholderC, core.PointerFromQVariant(val), C.longlong(paramType))
+	}
+}
+
+func (ptr *QSqlQuery) BindValue2(pos int, val core.QVariant_ITF, paramType QSql__ParamTypeFlag) {
+	if ptr.Pointer() != nil {
+		C.QSqlQuery_BindValue2(ptr.Pointer(), C.int(int32(pos)), core.PointerFromQVariant(val), C.longlong(paramType))
+	}
+}
+
 func (ptr *QSqlQuery) BoundValue(placeholder string) *core.QVariant {
 	if ptr.Pointer() != nil {
 		var placeholderC = C.CString(placeholder)
@@ -3121,6 +3293,13 @@ func (ptr *QSqlQuery) NumRowsAffected() int {
 	return 0
 }
 
+func (ptr *QSqlQuery) NumericalPrecisionPolicy() QSql__NumericalPrecisionPolicy {
+	if ptr.Pointer() != nil {
+		return QSql__NumericalPrecisionPolicy(C.QSqlQuery_NumericalPrecisionPolicy(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QSqlQuery) Prepare(query string) bool {
 	if ptr.Pointer() != nil {
 		var queryC = C.CString(query)
@@ -3166,6 +3345,12 @@ func (ptr *QSqlQuery) SetForwardOnly(forward bool) {
 	}
 }
 
+func (ptr *QSqlQuery) SetNumericalPrecisionPolicy(precisionPolicy QSql__NumericalPrecisionPolicy) {
+	if ptr.Pointer() != nil {
+		C.QSqlQuery_SetNumericalPrecisionPolicy(ptr.Pointer(), C.longlong(precisionPolicy))
+	}
+}
+
 func (ptr *QSqlQuery) Size() int {
 	if ptr.Pointer() != nil {
 		return int(int32(C.QSqlQuery_Size(ptr.Pointer())))
@@ -7638,6 +7823,12 @@ func NewQSqlResult(db QSqlDriver_ITF) *QSqlResult {
 	return NewQSqlResultFromPointer(C.QSqlResult_NewQSqlResult(PointerFromQSqlDriver(db)))
 }
 
+func (ptr *QSqlResult) AddBindValue(val core.QVariant_ITF, paramType QSql__ParamTypeFlag) {
+	if ptr.Pointer() != nil {
+		C.QSqlResult_AddBindValue(ptr.Pointer(), core.PointerFromQVariant(val), C.longlong(paramType))
+	}
+}
+
 func (ptr *QSqlResult) At() int {
 	if ptr.Pointer() != nil {
 		return int(int32(C.QSqlResult_At(ptr.Pointer())))
@@ -7645,6 +7836,98 @@ func (ptr *QSqlResult) At() int {
 	return 0
 }
 
+//export callbackQSqlResult_BindValue2
+func callbackQSqlResult_BindValue2(ptr unsafe.Pointer, placeholder C.struct_QtSql_PackedString, val unsafe.Pointer, paramType C.longlong) {
+
+	if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlResult::bindValue2"); signal != nil {
+		signal.(func(string, *core.QVariant, QSql__ParamTypeFlag))(cGoUnpackString(placeholder), core.NewQVariantFromPointer(val), QSql__ParamTypeFlag(paramType))
+	} else {
+		NewQSqlResultFromPointer(ptr).BindValue2Default(cGoUnpackString(placeholder), core.NewQVariantFromPointer(val), QSql__ParamTypeFlag(paramType))
+	}
+}
+
+func (ptr *QSqlResult) ConnectBindValue2(f func(placeholder string, val *core.QVariant, paramType QSql__ParamTypeFlag)) {
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlResult::bindValue2", f)
+	}
+}
+
+func (ptr *QSqlResult) DisconnectBindValue2() {
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlResult::bindValue2")
+	}
+}
+
+func (ptr *QSqlResult) BindValue2(placeholder string, val core.QVariant_ITF, paramType QSql__ParamTypeFlag) {
+	if ptr.Pointer() != nil {
+		var placeholderC = C.CString(placeholder)
+		defer C.free(unsafe.Pointer(placeholderC))
+		C.QSqlResult_BindValue2(ptr.Pointer(), placeholderC, core.PointerFromQVariant(val), C.longlong(paramType))
+	}
+}
+
+func (ptr *QSqlResult) BindValue2Default(placeholder string, val core.QVariant_ITF, paramType QSql__ParamTypeFlag) {
+	if ptr.Pointer() != nil {
+		var placeholderC = C.CString(placeholder)
+		defer C.free(unsafe.Pointer(placeholderC))
+		C.QSqlResult_BindValue2Default(ptr.Pointer(), placeholderC, core.PointerFromQVariant(val), C.longlong(paramType))
+	}
+}
+
+//export callbackQSqlResult_BindValue
+func callbackQSqlResult_BindValue(ptr unsafe.Pointer, index C.int, val unsafe.Pointer, paramType C.longlong) {
+
+	if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlResult::bindValue"); signal != nil {
+		signal.(func(int, *core.QVariant, QSql__ParamTypeFlag))(int(int32(index)), core.NewQVariantFromPointer(val), QSql__ParamTypeFlag(paramType))
+	} else {
+		NewQSqlResultFromPointer(ptr).BindValueDefault(int(int32(index)), core.NewQVariantFromPointer(val), QSql__ParamTypeFlag(paramType))
+	}
+}
+
+func (ptr *QSqlResult) ConnectBindValue(f func(index int, val *core.QVariant, paramType QSql__ParamTypeFlag)) {
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlResult::bindValue", f)
+	}
+}
+
+func (ptr *QSqlResult) DisconnectBindValue() {
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlResult::bindValue")
+	}
+}
+
+func (ptr *QSqlResult) BindValue(index int, val core.QVariant_ITF, paramType QSql__ParamTypeFlag) {
+	if ptr.Pointer() != nil {
+		C.QSqlResult_BindValue(ptr.Pointer(), C.int(int32(index)), core.PointerFromQVariant(val), C.longlong(paramType))
+	}
+}
+
+func (ptr *QSqlResult) BindValueDefault(index int, val core.QVariant_ITF, paramType QSql__ParamTypeFlag) {
+	if ptr.Pointer() != nil {
+		C.QSqlResult_BindValueDefault(ptr.Pointer(), C.int(int32(index)), core.PointerFromQVariant(val), C.longlong(paramType))
+	}
+}
+
+func (ptr *QSqlResult) BindValueType2(placeholder string) QSql__ParamTypeFlag {
+	if ptr.Pointer() != nil {
+		var placeholderC = C.CString(placeholder)
+		defer C.free(unsafe.Pointer(placeholderC))
+		return QSql__ParamTypeFlag(C.QSqlResult_BindValueType2(ptr.Pointer(), placeholderC))
+	}
+	return 0
+}
+
+func (ptr *QSqlResult) BindValueType(index int) QSql__ParamTypeFlag {
+	if ptr.Pointer() != nil {
+		return QSql__ParamTypeFlag(C.QSqlResult_BindValueType(ptr.Pointer(), C.int(int32(index))))
+	}
+	return 0
+}
+
 func (ptr *QSqlResult) BindingSyntax() QSqlResult__BindingSyntax {
 	if ptr.Pointer() != nil {
 		return QSqlResult__BindingSyntax(C.QSqlResult_BindingSyntax(ptr.Pointer()))

sql/sql.h

@@ -38,6 +38,7 @@ char QSqlDatabase_IsOpen(void* ptr);
 char QSqlDatabase_IsOpenError(void* ptr);
 char QSqlDatabase_IsValid(void* ptr);
 void* QSqlDatabase_LastError(void* ptr);
+long long QSqlDatabase_NumericalPrecisionPolicy(void* ptr);
 char QSqlDatabase_Open(void* ptr);
 char QSqlDatabase_Open2(void* ptr, char* user, char* password);
 struct QtSql_PackedString QSqlDatabase_Password(void* ptr);
@@ -50,9 +51,11 @@ char QSqlDatabase_Rollback(void* ptr);
 void QSqlDatabase_SetConnectOptions(void* ptr, char* options);
 void QSqlDatabase_SetDatabaseName(void* ptr, char* name);
 void QSqlDatabase_SetHostName(void* ptr, char* host);
+void QSqlDatabase_SetNumericalPrecisionPolicy(void* ptr, long long precisionPolicy);
 void QSqlDatabase_SetPassword(void* ptr, char* password);
 void QSqlDatabase_SetPort(void* ptr, int port);
 void QSqlDatabase_SetUserName(void* ptr, char* name);
+struct QtSql_PackedString QSqlDatabase_Tables(void* ptr, long long ty);
 char QSqlDatabase_Transaction(void* ptr);
 struct QtSql_PackedString QSqlDatabase_UserName(void* ptr);
 void QSqlDatabase_DestroyQSqlDatabase(void* ptr);
@@ -84,6 +87,7 @@ void QSqlDriver_Notification(void* ptr, char* name);
 void QSqlDriver_ConnectNotification2(void* ptr);
 void QSqlDriver_DisconnectNotification2(void* ptr);
 void QSqlDriver_Notification2(void* ptr, char* name, long long source, void* payload);
+long long QSqlDriver_NumericalPrecisionPolicy(void* ptr);
 char QSqlDriver_Open(void* ptr, char* db, char* user, char* password, char* host, int port, char* options);
 void* QSqlDriver_PrimaryIndex(void* ptr, char* tableName);
 void* QSqlDriver_PrimaryIndexDefault(void* ptr, char* tableName);
@@ -93,6 +97,7 @@ char QSqlDriver_RollbackTransaction(void* ptr);
 char QSqlDriver_RollbackTransactionDefault(void* ptr);
 void QSqlDriver_SetLastError(void* ptr, void* error);
 void QSqlDriver_SetLastErrorDefault(void* ptr, void* error);
+void QSqlDriver_SetNumericalPrecisionPolicy(void* ptr, long long precisionPolicy);
 void QSqlDriver_SetOpen(void* ptr, char open);
 void QSqlDriver_SetOpenDefault(void* ptr, char open);
 void QSqlDriver_SetOpenError(void* ptr, char error);
@@ -105,6 +110,8 @@ char QSqlDriver_SubscribeToNotification(void* ptr, char* name);
 char QSqlDriver_SubscribeToNotificationDefault(void* ptr, char* name);
 struct QtSql_PackedString QSqlDriver_SubscribedToNotifications(void* ptr);
 struct QtSql_PackedString QSqlDriver_SubscribedToNotificationsDefault(void* ptr);
+struct QtSql_PackedString QSqlDriver_Tables(void* ptr, long long tableType);
+struct QtSql_PackedString QSqlDriver_TablesDefault(void* ptr, long long tableType);
 char QSqlDriver_UnsubscribeFromNotification(void* ptr, char* name);
 char QSqlDriver_UnsubscribeFromNotificationDefault(void* ptr, char* name);
 void QSqlDriver_DestroyQSqlDriver(void* ptr);
@@ -198,7 +205,10 @@ void* QSqlQuery_NewQSqlQuery3(void* db);
 void* QSqlQuery_NewQSqlQuery(void* result);
 void* QSqlQuery_NewQSqlQuery4(void* other);
 void* QSqlQuery_NewQSqlQuery2(char* query, void* db);
+void QSqlQuery_AddBindValue(void* ptr, void* val, long long paramType);
 int QSqlQuery_At(void* ptr);
+void QSqlQuery_BindValue(void* ptr, char* placeholder, void* val, long long paramType);
+void QSqlQuery_BindValue2(void* ptr, int pos, void* val, long long paramType);
 void* QSqlQuery_BoundValue(void* ptr, char* placeholder);
 void* QSqlQuery_BoundValue2(void* ptr, int pos);
 void QSqlQuery_Clear(void* ptr);
@@ -222,12 +232,14 @@ struct QtSql_PackedString QSqlQuery_LastQuery(void* ptr);
 char QSqlQuery_Next(void* ptr);
 char QSqlQuery_NextResult(void* ptr);
 int QSqlQuery_NumRowsAffected(void* ptr);
+long long QSqlQuery_NumericalPrecisionPolicy(void* ptr);
 char QSqlQuery_Prepare(void* ptr, char* query);
 char QSqlQuery_Previous(void* ptr);
 void* QSqlQuery_Record(void* ptr);
 void* QSqlQuery_Result(void* ptr);
 char QSqlQuery_Seek(void* ptr, int index, char relative);
 void QSqlQuery_SetForwardOnly(void* ptr, char forward);
+void QSqlQuery_SetNumericalPrecisionPolicy(void* ptr, long long precisionPolicy);
 int QSqlQuery_Size(void* ptr);
 void* QSqlQuery_Value2(void* ptr, char* name);
 void* QSqlQuery_Value(void* ptr, int index);
@@ -491,7 +503,14 @@ char QSqlRelationalTableModel_EventFilterDefault(void* ptr, void* watched, void*
 void* QSqlRelationalTableModel_MetaObject(void* ptr);
 void* QSqlRelationalTableModel_MetaObjectDefault(void* ptr);
 void* QSqlResult_NewQSqlResult(void* db);
+void QSqlResult_AddBindValue(void* ptr, void* val, long long paramType);
 int QSqlResult_At(void* ptr);
+void QSqlResult_BindValue2(void* ptr, char* placeholder, void* val, long long paramType);
+void QSqlResult_BindValue2Default(void* ptr, char* placeholder, void* val, long long paramType);
+void QSqlResult_BindValue(void* ptr, int index, void* val, long long paramType);
+void QSqlResult_BindValueDefault(void* ptr, int index, void* val, long long paramType);
+long long QSqlResult_BindValueType2(void* ptr, char* placeholder);
+long long QSqlResult_BindValueType(void* ptr, int index);
 long long QSqlResult_BindingSyntax(void* ptr);
 void* QSqlResult_BoundValue2(void* ptr, char* placeholder);
 void* QSqlResult_BoundValue(void* ptr, int index);

testlib/testlib.go

@@ -436,6 +436,152 @@ func (ptr *QSignalSpy) MetaObjectDefault() *core.QMetaObject {
 	return nil
 }
 
+//QTest::QBenchmarkMetric
+type QTest__QBenchmarkMetric int64
+
+const (
+	QTest__FramesPerSecond      = QTest__QBenchmarkMetric(0)
+	QTest__BitsPerSecond        = QTest__QBenchmarkMetric(1)
+	QTest__BytesPerSecond       = QTest__QBenchmarkMetric(2)
+	QTest__WalltimeMilliseconds = QTest__QBenchmarkMetric(3)
+	QTest__CPUTicks             = QTest__QBenchmarkMetric(4)
+	QTest__InstructionReads     = QTest__QBenchmarkMetric(5)
+	QTest__Events               = QTest__QBenchmarkMetric(6)
+	QTest__WalltimeNanoseconds  = QTest__QBenchmarkMetric(7)
+	QTest__BytesAllocated       = QTest__QBenchmarkMetric(8)
+	QTest__CPUMigrations        = QTest__QBenchmarkMetric(9)
+	QTest__CPUCycles            = QTest__QBenchmarkMetric(10)
+	QTest__BusCycles            = QTest__QBenchmarkMetric(11)
+	QTest__StalledCycles        = QTest__QBenchmarkMetric(12)
+	QTest__Instructions         = QTest__QBenchmarkMetric(13)
+	QTest__BranchInstructions   = QTest__QBenchmarkMetric(14)
+	QTest__BranchMisses         = QTest__QBenchmarkMetric(15)
+	QTest__CacheReferences      = QTest__QBenchmarkMetric(16)
+	QTest__CacheReads           = QTest__QBenchmarkMetric(17)
+	QTest__CacheWrites          = QTest__QBenchmarkMetric(18)
+	QTest__CachePrefetches      = QTest__QBenchmarkMetric(19)
+	QTest__CacheMisses          = QTest__QBenchmarkMetric(20)
+	QTest__CacheReadMisses      = QTest__QBenchmarkMetric(21)
+	QTest__CacheWriteMisses     = QTest__QBenchmarkMetric(22)
+	QTest__CachePrefetchMisses  = QTest__QBenchmarkMetric(23)
+	QTest__ContextSwitches      = QTest__QBenchmarkMetric(24)
+	QTest__PageFaults           = QTest__QBenchmarkMetric(25)
+	QTest__MinorPageFaults      = QTest__QBenchmarkMetric(26)
+	QTest__MajorPageFaults      = QTest__QBenchmarkMetric(27)
+	QTest__AlignmentFaults      = QTest__QBenchmarkMetric(28)
+	QTest__EmulationFaults      = QTest__QBenchmarkMetric(29)
+)
+
+//QTest::TestFailMode
+type QTest__TestFailMode int64
+
+const (
+	QTest__Abort    = QTest__TestFailMode(1)
+	QTest__Continue = QTest__TestFailMode(2)
+)
+
+//QTest::AttributeIndex
+type QTest__AttributeIndex int64
+
+const (
+	QTest__AI_Undefined     = QTest__AttributeIndex(-1)
+	QTest__AI_Name          = QTest__AttributeIndex(0)
+	QTest__AI_Result        = QTest__AttributeIndex(1)
+	QTest__AI_Tests         = QTest__AttributeIndex(2)
+	QTest__AI_Failures      = QTest__AttributeIndex(3)
+	QTest__AI_Errors        = QTest__AttributeIndex(4)
+	QTest__AI_Type          = QTest__AttributeIndex(5)
+	QTest__AI_Description   = QTest__AttributeIndex(6)
+	QTest__AI_PropertyValue = QTest__AttributeIndex(7)
+	QTest__AI_QTestVersion  = QTest__AttributeIndex(8)
+	QTest__AI_QtVersion     = QTest__AttributeIndex(9)
+	QTest__AI_File          = QTest__AttributeIndex(10)
+	QTest__AI_Line          = QTest__AttributeIndex(11)
+	QTest__AI_Metric        = QTest__AttributeIndex(12)
+	QTest__AI_Tag           = QTest__AttributeIndex(13)
+	QTest__AI_Value         = QTest__AttributeIndex(14)
+	QTest__AI_Iterations    = QTest__AttributeIndex(15)
+)
+
+//QTest::LogElementType
+type QTest__LogElementType int64
+
+const (
+	QTest__LET_Undefined   = QTest__LogElementType(-1)
+	QTest__LET_Property    = QTest__LogElementType(0)
+	QTest__LET_Properties  = QTest__LogElementType(1)
+	QTest__LET_Failure     = QTest__LogElementType(2)
+	QTest__LET_Error       = QTest__LogElementType(3)
+	QTest__LET_TestCase    = QTest__LogElementType(4)
+	QTest__LET_TestSuite   = QTest__LogElementType(5)
+	QTest__LET_Benchmark   = QTest__LogElementType(6)
+	QTest__LET_SystemError = QTest__LogElementType(7)
+)
+
+//QTest::KeyAction
+type QTest__KeyAction int64
+
+const (
+	QTest__Press    = QTest__KeyAction(0)
+	QTest__Release  = QTest__KeyAction(1)
+	QTest__Click    = QTest__KeyAction(2)
+	QTest__Shortcut = QTest__KeyAction(3)
+)
+
+//QTest::MouseAction
+type QTest__MouseAction int64
+
+const (
+	QTest__MousePress   = QTest__MouseAction(0)
+	QTest__MouseRelease = QTest__MouseAction(1)
+	QTest__MouseClick   = QTest__MouseAction(2)
+	QTest__MouseDClick  = QTest__MouseAction(3)
+	QTest__MouseMove    = QTest__MouseAction(4)
+)
+
+type QTest struct {
+	ptr unsafe.Pointer
+}
+
+type QTest_ITF interface {
+	QTest_PTR() *QTest
+}
+
+func (p *QTest) QTest_PTR() *QTest {
+	return p
+}
+
+func (p *QTest) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QTest) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQTest(ptr QTest_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QTest_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQTestFromPointer(ptr unsafe.Pointer) *QTest {
+	var n = new(QTest)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QTest) DestroyQTest() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QTestEventList struct {
 	core.QList
 }

webengine/webengine.go

@@ -9659,3 +9659,54 @@ func (ptr *QWebEngineView) MetaObjectDefault() *core.QMetaObject {
 	}
 	return nil
 }
+
+//QtWebEngineCore::TextureTarget
+type QtWebEngineCore__TextureTarget int64
+
+const (
+	QtWebEngineCore__ExternalTarget  = QtWebEngineCore__TextureTarget(0)
+	QtWebEngineCore__RectangleTarget = QtWebEngineCore__TextureTarget(1)
+)
+
+type QtWebEngineCore struct {
+	ptr unsafe.Pointer
+}
+
+type QtWebEngineCore_ITF interface {
+	QtWebEngineCore_PTR() *QtWebEngineCore
+}
+
+func (p *QtWebEngineCore) QtWebEngineCore_PTR() *QtWebEngineCore {
+	return p
+}
+
+func (p *QtWebEngineCore) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QtWebEngineCore) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQtWebEngineCore(ptr QtWebEngineCore_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QtWebEngineCore_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQtWebEngineCoreFromPointer(ptr unsafe.Pointer) *QtWebEngineCore {
+	var n = new(QtWebEngineCore)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QtWebEngineCore) DestroyQtWebEngineCore() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}

websockets/websockets.cpp

@@ -165,10 +165,12 @@ void* QMaskGenerator_MetaObjectDefault(void* ptr)
 class MyQWebSocket: public QWebSocket
 {
 public:
+	MyQWebSocket(const QString &origin, QWebSocketProtocol::Version version, QObject *parent) : QWebSocket(origin, version, parent) {};
 	void Signal_AboutToClose() { callbackQWebSocket_AboutToClose(this); };
 	void Signal_BinaryFrameReceived(const QByteArray & frame, bool isLastFrame) { callbackQWebSocket_BinaryFrameReceived(this, const_cast<QByteArray*>(&frame), isLastFrame); };
 	void Signal_BinaryMessageReceived(const QByteArray & message) { callbackQWebSocket_BinaryMessageReceived(this, const_cast<QByteArray*>(&message)); };
 	void Signal_BytesWritten(qint64 bytes) { callbackQWebSocket_BytesWritten(this, bytes); };
+	void close(QWebSocketProtocol::CloseCode closeCode, const QString & reason) { QByteArray t7947e9 = reason.toUtf8(); QtWebSockets_PackedString reasonPacked = { const_cast<char*>(t7947e9.prepend("WHITESPACE").constData()+10), t7947e9.size()-10 };callbackQWebSocket_Close(this, closeCode, reasonPacked); };
 	void Signal_Connected() { callbackQWebSocket_Connected(this); };
 	void Signal_Disconnected() { callbackQWebSocket_Disconnected(this); };
 	void Signal_Error2(QAbstractSocket::SocketError error) { callbackQWebSocket_Error2(this, error); };
@@ -194,6 +196,11 @@ public:
 	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWebSocket_MetaObject(const_cast<MyQWebSocket*>(this))); };
 };
 
+void* QWebSocket_NewQWebSocket(char* origin, long long version, void* parent)
+{
+	return new MyQWebSocket(QString(origin), static_cast<QWebSocketProtocol::Version>(version), static_cast<QObject*>(parent));
+}
+
 void QWebSocket_Abort(void* ptr)
 {
 	static_cast<QWebSocket*>(ptr)->abort();
@@ -259,6 +266,16 @@ void QWebSocket_BytesWritten(void* ptr, long long bytes)
 	static_cast<QWebSocket*>(ptr)->bytesWritten(bytes);
 }
 
+void QWebSocket_Close(void* ptr, long long closeCode, char* reason)
+{
+	QMetaObject::invokeMethod(static_cast<QWebSocket*>(ptr), "close", Q_ARG(QWebSocketProtocol::CloseCode, static_cast<QWebSocketProtocol::CloseCode>(closeCode)), Q_ARG(QString, QString(reason)));
+}
+
+long long QWebSocket_CloseCode(void* ptr)
+{
+	return static_cast<QWebSocket*>(ptr)->closeCode();
+}
+
 struct QtWebSockets_PackedString QWebSocket_CloseReason(void* ptr)
 {
 	return ({ QByteArray t003333 = static_cast<QWebSocket*>(ptr)->closeReason().toUtf8(); QtWebSockets_PackedString { const_cast<char*>(t003333.prepend("WHITESPACE").constData()+10), t003333.size()-10 }; });
@@ -554,6 +571,11 @@ void QWebSocket_TextMessageReceived(void* ptr, char* message)
 	static_cast<QWebSocket*>(ptr)->textMessageReceived(QString(message));
 }
 
+long long QWebSocket_Version(void* ptr)
+{
+	return static_cast<QWebSocket*>(ptr)->version();
+}
+
 void QWebSocket_DestroyQWebSocket(void* ptr)
 {
 	static_cast<QWebSocket*>(ptr)->~QWebSocket();
@@ -704,6 +726,7 @@ public:
 	QWebSocket * nextPendingConnection() { return static_cast<QWebSocket*>(callbackQWebSocketServer_NextPendingConnection(this)); };
 	void Signal_OriginAuthenticationRequired(QWebSocketCorsAuthenticator * authenticator) { callbackQWebSocketServer_OriginAuthenticationRequired(this, authenticator); };
 	void Signal_PeerVerifyError(const QSslError & error) { callbackQWebSocketServer_PeerVerifyError(this, const_cast<QSslError*>(&error)); };
+	void Signal_ServerError(QWebSocketProtocol::CloseCode closeCode) { callbackQWebSocketServer_ServerError(this, closeCode); };
 	 ~MyQWebSocketServer() { callbackQWebSocketServer_DestroyQWebSocketServer(this); };
 	void timerEvent(QTimerEvent * event) { callbackQWebSocketServer_TimerEvent(this, event); };
 	void childEvent(QChildEvent * event) { callbackQWebSocketServer_ChildEvent(this, event); };
@@ -756,6 +779,11 @@ void QWebSocketServer_Closed(void* ptr)
 	static_cast<QWebSocketServer*>(ptr)->closed();
 }
 
+long long QWebSocketServer_Error(void* ptr)
+{
+	return static_cast<QWebSocketServer*>(ptr)->error();
+}
+
 struct QtWebSockets_PackedString QWebSocketServer_ErrorString(void* ptr)
 {
 	return ({ QByteArray t92e239 = static_cast<QWebSocketServer*>(ptr)->errorString().toUtf8(); QtWebSockets_PackedString { const_cast<char*>(t92e239.prepend("WHITESPACE").constData()+10), t92e239.size()-10 }; });
@@ -861,6 +889,21 @@ void* QWebSocketServer_ServerAddress(void* ptr)
 	return new QHostAddress(static_cast<QWebSocketServer*>(ptr)->serverAddress());
 }
 
+void QWebSocketServer_ConnectServerError(void* ptr)
+{
+	QObject::connect(static_cast<QWebSocketServer*>(ptr), static_cast<void (QWebSocketServer::*)(QWebSocketProtocol::CloseCode)>(&QWebSocketServer::serverError), static_cast<MyQWebSocketServer*>(ptr), static_cast<void (MyQWebSocketServer::*)(QWebSocketProtocol::CloseCode)>(&MyQWebSocketServer::Signal_ServerError));
+}
+
+void QWebSocketServer_DisconnectServerError(void* ptr)
+{
+	QObject::disconnect(static_cast<QWebSocketServer*>(ptr), static_cast<void (QWebSocketServer::*)(QWebSocketProtocol::CloseCode)>(&QWebSocketServer::serverError), static_cast<MyQWebSocketServer*>(ptr), static_cast<void (MyQWebSocketServer::*)(QWebSocketProtocol::CloseCode)>(&MyQWebSocketServer::Signal_ServerError));
+}
+
+void QWebSocketServer_ServerError(void* ptr, long long closeCode)
+{
+	static_cast<QWebSocketServer*>(ptr)->serverError(static_cast<QWebSocketProtocol::CloseCode>(closeCode));
+}
+
 struct QtWebSockets_PackedString QWebSocketServer_ServerName(void* ptr)
 {
 	return ({ QByteArray tf9a582 = static_cast<QWebSocketServer*>(ptr)->serverName().toUtf8(); QtWebSockets_PackedString { const_cast<char*>(tf9a582.prepend("WHITESPACE").constData()+10), tf9a582.size()-10 }; });

websockets/websockets.go

@@ -541,6 +541,16 @@ func NewQWebSocketFromPointer(ptr unsafe.Pointer) *QWebSocket {
 	n.SetPointer(ptr)
 	return n
 }
+func NewQWebSocket(origin string, version QWebSocketProtocol__Version, parent core.QObject_ITF) *QWebSocket {
+	var originC = C.CString(origin)
+	defer C.free(unsafe.Pointer(originC))
+	var tmpValue = NewQWebSocketFromPointer(C.QWebSocket_NewQWebSocket(originC, C.longlong(version), core.PointerFromQObject(parent)))
+	if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "QObject::destroyed") {
+		tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
+	}
+	return tmpValue
+}
+
 func (ptr *QWebSocket) Abort() {
 	if ptr.Pointer() != nil {
 		C.QWebSocket_Abort(ptr.Pointer())
@@ -663,6 +673,43 @@ func (ptr *QWebSocket) BytesWritten(bytes int64) {
 	}
 }
 
+//export callbackQWebSocket_Close
+func callbackQWebSocket_Close(ptr unsafe.Pointer, closeCode C.longlong, reason C.struct_QtWebSockets_PackedString) {
+	if signal := qt.GetSignal(fmt.Sprint(ptr), "QWebSocket::close"); signal != nil {
+		signal.(func(QWebSocketProtocol__CloseCode, string))(QWebSocketProtocol__CloseCode(closeCode), cGoUnpackString(reason))
+	}
+
+}
+
+func (ptr *QWebSocket) ConnectClose(f func(closeCode QWebSocketProtocol__CloseCode, reason string)) {
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QWebSocket::close", f)
+	}
+}
+
+func (ptr *QWebSocket) DisconnectClose(closeCode QWebSocketProtocol__CloseCode, reason string) {
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QWebSocket::close")
+	}
+}
+
+func (ptr *QWebSocket) Close(closeCode QWebSocketProtocol__CloseCode, reason string) {
+	if ptr.Pointer() != nil {
+		var reasonC = C.CString(reason)
+		defer C.free(unsafe.Pointer(reasonC))
+		C.QWebSocket_Close(ptr.Pointer(), C.longlong(closeCode), reasonC)
+	}
+}
+
+func (ptr *QWebSocket) CloseCode() QWebSocketProtocol__CloseCode {
+	if ptr.Pointer() != nil {
+		return QWebSocketProtocol__CloseCode(C.QWebSocket_CloseCode(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QWebSocket) CloseReason() string {
 	if ptr.Pointer() != nil {
 		return cGoUnpackString(C.QWebSocket_CloseReason(ptr.Pointer()))
@@ -1248,6 +1295,13 @@ func (ptr *QWebSocket) TextMessageReceived(message string) {
 	}
 }
 
+func (ptr *QWebSocket) Version() QWebSocketProtocol__Version {
+	if ptr.Pointer() != nil {
+		return QWebSocketProtocol__Version(C.QWebSocket_Version(ptr.Pointer()))
+	}
+	return 0
+}
+
 //export callbackQWebSocket_DestroyQWebSocket
 func callbackQWebSocket_DestroyQWebSocket(ptr unsafe.Pointer) {
 
@@ -1711,6 +1765,83 @@ func (ptr *QWebSocketCorsAuthenticator) DestroyQWebSocketCorsAuthenticator() {
 	}
 }
 
+//QWebSocketProtocol::CloseCode
+type QWebSocketProtocol__CloseCode int64
+
+const (
+	QWebSocketProtocol__CloseCodeNormal                = QWebSocketProtocol__CloseCode(1000)
+	QWebSocketProtocol__CloseCodeGoingAway             = QWebSocketProtocol__CloseCode(1001)
+	QWebSocketProtocol__CloseCodeProtocolError         = QWebSocketProtocol__CloseCode(1002)
+	QWebSocketProtocol__CloseCodeDatatypeNotSupported  = QWebSocketProtocol__CloseCode(1003)
+	QWebSocketProtocol__CloseCodeReserved1004          = QWebSocketProtocol__CloseCode(1004)
+	QWebSocketProtocol__CloseCodeMissingStatusCode     = QWebSocketProtocol__CloseCode(1005)
+	QWebSocketProtocol__CloseCodeAbnormalDisconnection = QWebSocketProtocol__CloseCode(1006)
+	QWebSocketProtocol__CloseCodeWrongDatatype         = QWebSocketProtocol__CloseCode(1007)
+	QWebSocketProtocol__CloseCodePolicyViolated        = QWebSocketProtocol__CloseCode(1008)
+	QWebSocketProtocol__CloseCodeTooMuchData           = QWebSocketProtocol__CloseCode(1009)
+	QWebSocketProtocol__CloseCodeMissingExtension      = QWebSocketProtocol__CloseCode(1010)
+	QWebSocketProtocol__CloseCodeBadOperation          = QWebSocketProtocol__CloseCode(1011)
+	QWebSocketProtocol__CloseCodeTlsHandshakeFailed    = QWebSocketProtocol__CloseCode(1015)
+)
+
+//QWebSocketProtocol::Version
+type QWebSocketProtocol__Version int64
+
+const (
+	QWebSocketProtocol__VersionUnknown = QWebSocketProtocol__Version(-1)
+	QWebSocketProtocol__Version0       = QWebSocketProtocol__Version(0)
+	QWebSocketProtocol__Version4       = QWebSocketProtocol__Version(4)
+	QWebSocketProtocol__Version5       = QWebSocketProtocol__Version(5)
+	QWebSocketProtocol__Version6       = QWebSocketProtocol__Version(6)
+	QWebSocketProtocol__Version7       = QWebSocketProtocol__Version(7)
+	QWebSocketProtocol__Version8       = QWebSocketProtocol__Version(8)
+	QWebSocketProtocol__Version13      = QWebSocketProtocol__Version(13)
+	QWebSocketProtocol__VersionLatest  = QWebSocketProtocol__Version(QWebSocketProtocol__Version13)
+)
+
+type QWebSocketProtocol struct {
+	ptr unsafe.Pointer
+}
+
+type QWebSocketProtocol_ITF interface {
+	QWebSocketProtocol_PTR() *QWebSocketProtocol
+}
+
+func (p *QWebSocketProtocol) QWebSocketProtocol_PTR() *QWebSocketProtocol {
+	return p
+}
+
+func (p *QWebSocketProtocol) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QWebSocketProtocol) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQWebSocketProtocol(ptr QWebSocketProtocol_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QWebSocketProtocol_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQWebSocketProtocolFromPointer(ptr unsafe.Pointer) *QWebSocketProtocol {
+	var n = new(QWebSocketProtocol)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QWebSocketProtocol) DestroyQWebSocketProtocol() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 //QWebSocketServer::SslMode
 type QWebSocketServer__SslMode int64
 
@@ -1831,6 +1962,13 @@ func (ptr *QWebSocketServer) Closed() {
 	}
 }
 
+func (ptr *QWebSocketServer) Error() QWebSocketProtocol__CloseCode {
+	if ptr.Pointer() != nil {
+		return QWebSocketProtocol__CloseCode(C.QWebSocketServer_Error(ptr.Pointer()))
+	}
+	return 0
+}
+
 func (ptr *QWebSocketServer) ErrorString() string {
 	if ptr.Pointer() != nil {
 		return cGoUnpackString(C.QWebSocketServer_ErrorString(ptr.Pointer()))
@@ -2036,6 +2174,35 @@ func (ptr *QWebSocketServer) ServerAddress() *network.QHostAddress {
 	return nil
 }
 
+//export callbackQWebSocketServer_ServerError
+func callbackQWebSocketServer_ServerError(ptr unsafe.Pointer, closeCode C.longlong) {
+
+	if signal := qt.GetSignal(fmt.Sprint(ptr), "QWebSocketServer::serverError"); signal != nil {
+		signal.(func(QWebSocketProtocol__CloseCode))(QWebSocketProtocol__CloseCode(closeCode))
+	}
+
+}
+
+func (ptr *QWebSocketServer) ConnectServerError(f func(closeCode QWebSocketProtocol__CloseCode)) {
+	if ptr.Pointer() != nil {
+		C.QWebSocketServer_ConnectServerError(ptr.Pointer())
+		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QWebSocketServer::serverError", f)
+	}
+}
+
+func (ptr *QWebSocketServer) DisconnectServerError() {
+	if ptr.Pointer() != nil {
+		C.QWebSocketServer_DisconnectServerError(ptr.Pointer())
+		qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QWebSocketServer::serverError")
+	}
+}
+
+func (ptr *QWebSocketServer) ServerError(closeCode QWebSocketProtocol__CloseCode) {
+	if ptr.Pointer() != nil {
+		C.QWebSocketServer_ServerError(ptr.Pointer(), C.longlong(closeCode))
+	}
+}
+
 func (ptr *QWebSocketServer) ServerName() string {
 	if ptr.Pointer() != nil {
 		return cGoUnpackString(C.QWebSocketServer_ServerName(ptr.Pointer()))

websockets/websockets.h

@@ -36,6 +36,7 @@ char QMaskGenerator_EventFilter(void* ptr, void* watched, void* event);
 char QMaskGenerator_EventFilterDefault(void* ptr, void* watched, void* event);
 void* QMaskGenerator_MetaObject(void* ptr);
 void* QMaskGenerator_MetaObjectDefault(void* ptr);
+void* QWebSocket_NewQWebSocket(char* origin, long long version, void* parent);
 void QWebSocket_Abort(void* ptr);
 void QWebSocket_ConnectAboutToClose(void* ptr);
 void QWebSocket_DisconnectAboutToClose(void* ptr);
@@ -49,6 +50,8 @@ void QWebSocket_BinaryMessageReceived(void* ptr, void* message);
 void QWebSocket_ConnectBytesWritten(void* ptr);
 void QWebSocket_DisconnectBytesWritten(void* ptr);
 void QWebSocket_BytesWritten(void* ptr, long long bytes);
+void QWebSocket_Close(void* ptr, long long closeCode, char* reason);
+long long QWebSocket_CloseCode(void* ptr);
 struct QtWebSockets_PackedString QWebSocket_CloseReason(void* ptr);
 void QWebSocket_ConnectConnected(void* ptr);
 void QWebSocket_DisconnectConnected(void* ptr);
@@ -108,6 +111,7 @@ void QWebSocket_TextFrameReceived(void* ptr, char* frame, char isLastFrame);
 void QWebSocket_ConnectTextMessageReceived(void* ptr);
 void QWebSocket_DisconnectTextMessageReceived(void* ptr);
 void QWebSocket_TextMessageReceived(void* ptr, char* message);
+long long QWebSocket_Version(void* ptr);
 void QWebSocket_DestroyQWebSocket(void* ptr);
 void QWebSocket_DestroyQWebSocketDefault(void* ptr);
 void QWebSocket_TimerEvent(void* ptr, void* event);
@@ -144,6 +148,7 @@ void QWebSocketServer_Close(void* ptr);
 void QWebSocketServer_ConnectClosed(void* ptr);
 void QWebSocketServer_DisconnectClosed(void* ptr);
 void QWebSocketServer_Closed(void* ptr);
+long long QWebSocketServer_Error(void* ptr);
 struct QtWebSockets_PackedString QWebSocketServer_ErrorString(void* ptr);
 char QWebSocketServer_HasPendingConnections(void* ptr);
 char QWebSocketServer_IsListening(void* ptr);
@@ -165,6 +170,9 @@ void* QWebSocketServer_Proxy(void* ptr);
 void QWebSocketServer_ResumeAccepting(void* ptr);
 long long QWebSocketServer_SecureMode(void* ptr);
 void* QWebSocketServer_ServerAddress(void* ptr);
+void QWebSocketServer_ConnectServerError(void* ptr);
+void QWebSocketServer_DisconnectServerError(void* ptr);
+void QWebSocketServer_ServerError(void* ptr, long long closeCode);
 struct QtWebSockets_PackedString QWebSocketServer_ServerName(void* ptr);
 unsigned short QWebSocketServer_ServerPort(void* ptr);
 void* QWebSocketServer_ServerUrl(void* ptr);

widgets/widgets.cpp

@@ -2618,6 +2618,11 @@ void QAbstractItemView_SelectAllDefault(void* ptr)
 	static_cast<QAbstractItemView*>(ptr)->QAbstractItemView::selectAll();
 }
 
+struct QtWidgets_PackedList QAbstractItemView_SelectedIndexes(void* ptr)
+{
+	return ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(static_cast<QAbstractItemView*>(ptr)->selectedIndexes()); QtWidgets_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 void QAbstractItemView_SelectionChanged(void* ptr, void* selected, void* deselected)
 {
 	QMetaObject::invokeMethod(static_cast<QAbstractItemView*>(ptr), "selectionChanged", Q_ARG(QItemSelection, *static_cast<QItemSelection*>(selected)), Q_ARG(QItemSelection, *static_cast<QItemSelection*>(deselected)));
@@ -31171,6 +31176,11 @@ void* QGraphicsItem_childItems_atList(void* ptr, int i)
 	return const_cast<QGraphicsItem*>(static_cast<QList<QGraphicsItem *>*>(ptr)->at(i));
 }
 
+void* QGraphicsItem_children_atList(void* ptr, int i)
+{
+	return const_cast<QGraphicsItem*>(static_cast<QList<QGraphicsItem *>*>(ptr)->at(i));
+}
+
 void* QGraphicsItem_collidingItems_atList(void* ptr, int i)
 {
 	return const_cast<QGraphicsItem*>(static_cast<QList<QGraphicsItem *>*>(ptr)->at(i));
@@ -49996,6 +50006,11 @@ void QListView_ScrollToDefault(void* ptr, void* index, long long hint)
 	static_cast<QListView*>(ptr)->QListView::scrollTo(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemView::ScrollHint>(hint));
 }
 
+struct QtWidgets_PackedList QListView_SelectedIndexes(void* ptr)
+{
+	return ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(static_cast<QListView*>(ptr)->selectedIndexes()); QtWidgets_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 void QListView_SelectionChanged(void* ptr, void* selected, void* deselected)
 {
 	static_cast<QListView*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
@@ -82255,6 +82270,11 @@ void QTableView_SelectRow(void* ptr, int row)
 	QMetaObject::invokeMethod(static_cast<QTableView*>(ptr), "selectRow", Q_ARG(int, row));
 }
 
+struct QtWidgets_PackedList QTableView_SelectedIndexes(void* ptr)
+{
+	return ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(static_cast<QTableView*>(ptr)->selectedIndexes()); QtWidgets_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 void QTableView_SelectionChanged(void* ptr, void* selected, void* deselected)
 {
 	static_cast<QTableView*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
@@ -92333,6 +92353,11 @@ void QTreeView_SelectAllDefault(void* ptr)
 	static_cast<QTreeView*>(ptr)->QTreeView::selectAll();
 }
 
+struct QtWidgets_PackedList QTreeView_SelectedIndexes(void* ptr)
+{
+	return ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(static_cast<QTreeView*>(ptr)->selectedIndexes()); QtWidgets_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 void QTreeView_SelectionChanged(void* ptr, void* selected, void* deselected)
 {
 	static_cast<QTreeView*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
@@ -93750,6 +93775,11 @@ void* QTreeWidget_findItems_atList(void* ptr, int i)
 	return const_cast<QTreeWidgetItem*>(static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i));
 }
 
+void* QTreeWidget_items_atList(void* ptr, int i)
+{
+	return const_cast<QTreeWidgetItem*>(static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i));
+}
+
 void* QTreeWidget_selectedItems_atList(void* ptr, int i)
 {
 	return const_cast<QTreeWidgetItem*>(static_cast<QList<QTreeWidgetItem *>*>(ptr)->at(i));

widgets/widgets.go

@@ -6781,6 +6781,19 @@ func (ptr *QAbstractItemView) SelectAllDefault() {
 	}
 }
 
+func (ptr *QAbstractItemView) SelectedIndexes() []*core.QModelIndex {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
+			var out = make([]*core.QModelIndex, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQAbstractItemViewFromPointer(l.data).selectedIndexes_atList(i)
+			}
+			return out
+		}(C.QAbstractItemView_SelectedIndexes(ptr.Pointer()))
+	}
+	return nil
+}
+
 //export callbackQAbstractItemView_SelectionChanged
 func callbackQAbstractItemView_SelectionChanged(ptr unsafe.Pointer, selected unsafe.Pointer, deselected unsafe.Pointer) {
 	if signal := qt.GetSignal(fmt.Sprint(ptr), "QAbstractItemView::selectionChanged"); signal != nil {
@@ -92596,6 +92609,13 @@ func (ptr *QGraphicsItem) childItems_atList(i int) *QGraphicsItem {
 	return nil
 }
 
+func (ptr *QGraphicsItem) children_atList(i int) *QGraphicsItem {
+	if ptr.Pointer() != nil {
+		return NewQGraphicsItemFromPointer(C.QGraphicsItem_children_atList(ptr.Pointer(), C.int(int32(i))))
+	}
+	return nil
+}
+
 func (ptr *QGraphicsItem) collidingItems_atList(i int) *QGraphicsItem {
 	if ptr.Pointer() != nil {
 		return NewQGraphicsItemFromPointer(C.QGraphicsItem_collidingItems_atList(ptr.Pointer(), C.int(int32(i))))
@@ -148155,6 +148175,19 @@ func (ptr *QListView) ScrollToDefault(index core.QModelIndex_ITF, hint QAbstract
 	}
 }
 
+func (ptr *QListView) SelectedIndexes() []*core.QModelIndex {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
+			var out = make([]*core.QModelIndex, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQListViewFromPointer(l.data).selectedIndexes_atList(i)
+			}
+			return out
+		}(C.QListView_SelectedIndexes(ptr.Pointer()))
+	}
+	return nil
+}
+
 //export callbackQListView_SelectionChanged
 func callbackQListView_SelectionChanged(ptr unsafe.Pointer, selected unsafe.Pointer, deselected unsafe.Pointer) {
 
@@ -240109,6 +240142,19 @@ func (ptr *QTableView) SelectRow(row int) {
 	}
 }
 
+func (ptr *QTableView) SelectedIndexes() []*core.QModelIndex {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
+			var out = make([]*core.QModelIndex, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQTableViewFromPointer(l.data).selectedIndexes_atList(i)
+			}
+			return out
+		}(C.QTableView_SelectedIndexes(ptr.Pointer()))
+	}
+	return nil
+}
+
 //export callbackQTableView_SelectionChanged
 func callbackQTableView_SelectionChanged(ptr unsafe.Pointer, selected unsafe.Pointer, deselected unsafe.Pointer) {
 
@@ -270830,6 +270876,19 @@ func (ptr *QTreeView) SelectAllDefault() {
 	}
 }
 
+func (ptr *QTreeView) SelectedIndexes() []*core.QModelIndex {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtWidgets_PackedList) []*core.QModelIndex {
+			var out = make([]*core.QModelIndex, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQTreeViewFromPointer(l.data).selectedIndexes_atList(i)
+			}
+			return out
+		}(C.QTreeView_SelectedIndexes(ptr.Pointer()))
+	}
+	return nil
+}
+
 //export callbackQTreeView_SelectionChanged
 func callbackQTreeView_SelectionChanged(ptr unsafe.Pointer, selected unsafe.Pointer, deselected unsafe.Pointer) {
 
@@ -274756,6 +274815,13 @@ func (ptr *QTreeWidget) findItems_atList(i int) *QTreeWidgetItem {
 	return nil
 }
 
+func (ptr *QTreeWidget) items_atList(i int) *QTreeWidgetItem {
+	if ptr.Pointer() != nil {
+		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_items_atList(ptr.Pointer(), C.int(int32(i))))
+	}
+	return nil
+}
+
 func (ptr *QTreeWidget) selectedItems_atList(i int) *QTreeWidgetItem {
 	if ptr.Pointer() != nil {
 		return NewQTreeWidgetItemFromPointer(C.QTreeWidget_selectedItems_atList(ptr.Pointer(), C.int(int32(i))))

widgets/widgets.h

@@ -426,6 +426,7 @@ void QAbstractItemView_ScrollToBottom(void* ptr);
 void QAbstractItemView_ScrollToTop(void* ptr);
 void QAbstractItemView_SelectAll(void* ptr);
 void QAbstractItemView_SelectAllDefault(void* ptr);
+struct QtWidgets_PackedList QAbstractItemView_SelectedIndexes(void* ptr);
 void QAbstractItemView_SelectionChanged(void* ptr, void* selected, void* deselected);
 void QAbstractItemView_SelectionChangedDefault(void* ptr, void* selected, void* deselected);
 long long QAbstractItemView_SelectionCommand(void* ptr, void* index, void* event);
@@ -5683,6 +5684,7 @@ void QGraphicsItem_DestroyQGraphicsItem(void* ptr);
 void QGraphicsItem_DestroyQGraphicsItemDefault(void* ptr);
 int QGraphicsItem_QGraphicsItem_UserType();
 void* QGraphicsItem_childItems_atList(void* ptr, int i);
+void* QGraphicsItem_children_atList(void* ptr, int i);
 void* QGraphicsItem_collidingItems_atList(void* ptr, int i);
 void* QGraphicsItem_transformations_atList(void* ptr, int i);
 void* QGraphicsItemGroup_NewQGraphicsItemGroup(void* parent);
@@ -9129,6 +9131,7 @@ void QListView_RowsInserted(void* ptr, void* parent, int start, int end);
 void QListView_RowsInsertedDefault(void* ptr, void* parent, int start, int end);
 void QListView_ScrollTo(void* ptr, void* index, long long hint);
 void QListView_ScrollToDefault(void* ptr, void* index, long long hint);
+struct QtWidgets_PackedList QListView_SelectedIndexes(void* ptr);
 void QListView_SelectionChanged(void* ptr, void* selected, void* deselected);
 void QListView_SelectionChangedDefault(void* ptr, void* selected, void* deselected);
 void QListView_SetPositionForIndex(void* ptr, void* position, void* index);
@@ -14862,6 +14865,7 @@ int QTableView_RowSpan(void* ptr, int row, int column);
 int QTableView_RowViewportPosition(void* ptr, int row);
 void QTableView_SelectColumn(void* ptr, int column);
 void QTableView_SelectRow(void* ptr, int row);
+struct QtWidgets_PackedList QTableView_SelectedIndexes(void* ptr);
 void QTableView_SelectionChanged(void* ptr, void* selected, void* deselected);
 void QTableView_SelectionChangedDefault(void* ptr, void* selected, void* deselected);
 void QTableView_SetColumnHidden(void* ptr, int column, char hide);
@@ -16728,6 +16732,7 @@ void QTreeView_ScrollTo(void* ptr, void* index, long long hint);
 void QTreeView_ScrollToDefault(void* ptr, void* index, long long hint);
 void QTreeView_SelectAll(void* ptr);
 void QTreeView_SelectAllDefault(void* ptr);
+struct QtWidgets_PackedList QTreeView_SelectedIndexes(void* ptr);
 void QTreeView_SelectionChanged(void* ptr, void* selected, void* deselected);
 void QTreeView_SelectionChangedDefault(void* ptr, void* selected, void* deselected);
 void QTreeView_SetColumnHidden(void* ptr, int column, char hide);
@@ -16984,6 +16989,7 @@ void* QTreeWidget_TopLevelItem(void* ptr, int index);
 void* QTreeWidget_VisualItemRect(void* ptr, void* item);
 void QTreeWidget_DestroyQTreeWidget(void* ptr);
 void* QTreeWidget_findItems_atList(void* ptr, int i);
+void* QTreeWidget_items_atList(void* ptr, int i);
 void* QTreeWidget_selectedItems_atList(void* ptr, int i);
 void QTreeWidget_Collapse(void* ptr, void* index);
 void QTreeWidget_CollapseDefault(void* ptr, void* index);

xmlpatterns/xmlpatterns.cpp

@@ -529,6 +529,16 @@ void* QSimpleXmlNodeModel_NamePool(void* ptr)
 	return new QXmlNamePool(static_cast<QSimpleXmlNodeModel*>(ptr)->namePool());
 }
 
+struct QtXmlPatterns_PackedList QSimpleXmlNodeModel_NamespaceBindings(void* ptr, void* node)
+{
+	return ({ QVector<QXmlName>* tmpValue = new QVector<QXmlName>(static_cast<QSimpleXmlNodeModel*>(ptr)->namespaceBindings(*static_cast<QXmlNodeModelIndex*>(node))); QtXmlPatterns_PackedList { tmpValue, tmpValue->size() }; });
+}
+
+struct QtXmlPatterns_PackedList QSimpleXmlNodeModel_NodesByIdref(void* ptr, void* idref)
+{
+	return ({ QVector<QXmlNodeModelIndex>* tmpValue = new QVector<QXmlNodeModelIndex>(static_cast<QSimpleXmlNodeModel*>(ptr)->nodesByIdref(*static_cast<QXmlName*>(idref))); QtXmlPatterns_PackedList { tmpValue, tmpValue->size() }; });
+}
+
 struct QtXmlPatterns_PackedString QSimpleXmlNodeModel_StringValue(void* ptr, void* node)
 {
 	return ({ QByteArray t8d99fb = static_cast<QSimpleXmlNodeModel*>(ptr)->stringValue(*static_cast<QXmlNodeModelIndex*>(node)).toUtf8(); QtXmlPatterns_PackedString { const_cast<char*>(t8d99fb.prepend("WHITESPACE").constData()+10), t8d99fb.size()-10 }; });
@@ -961,6 +971,11 @@ void* QXmlNodeModelIndex_Model(void* ptr)
 	return const_cast<QAbstractXmlNodeModel*>(static_cast<QXmlNodeModelIndex*>(ptr)->model());
 }
 
+void* QXmlNodeModelIndex_namespaceBindings_atList(void* ptr, int i)
+{
+	return new QXmlName(static_cast<QVector<QXmlName>*>(ptr)->at(i));
+}
+
 void* QXmlQuery_NewQXmlQuery()
 {
 	return new QXmlQuery();

xmlpatterns/xmlpatterns.go

@@ -1796,6 +1796,93 @@ func (ptr *QAbstractXmlReceiver) DestroyQAbstractXmlReceiverDefault() {
 	}
 }
 
+//QPatternist::DerivedIntegerLimitsUsage
+type QPatternist__DerivedIntegerLimitsUsage int64
+
+const (
+	QPatternist__None           = QPatternist__DerivedIntegerLimitsUsage(1)
+	QPatternist__LimitUpwards   = QPatternist__DerivedIntegerLimitsUsage(2)
+	QPatternist__LimitDownwards = QPatternist__DerivedIntegerLimitsUsage(4)
+	QPatternist__LimitBoth      = QPatternist__DerivedIntegerLimitsUsage(QPatternist__LimitUpwards | QPatternist__LimitDownwards)
+)
+
+//QPatternist::TypeOfDerivedInteger
+type QPatternist__TypeOfDerivedInteger int64
+
+const (
+	QPatternist__TypeByte               = QPatternist__TypeOfDerivedInteger(0)
+	QPatternist__TypeInt                = QPatternist__TypeOfDerivedInteger(1)
+	QPatternist__TypeLong               = QPatternist__TypeOfDerivedInteger(2)
+	QPatternist__TypeNegativeInteger    = QPatternist__TypeOfDerivedInteger(3)
+	QPatternist__TypeNonNegativeInteger = QPatternist__TypeOfDerivedInteger(4)
+	QPatternist__TypeNonPositiveInteger = QPatternist__TypeOfDerivedInteger(5)
+	QPatternist__TypePositiveInteger    = QPatternist__TypeOfDerivedInteger(6)
+	QPatternist__TypeShort              = QPatternist__TypeOfDerivedInteger(7)
+	QPatternist__TypeUnsignedByte       = QPatternist__TypeOfDerivedInteger(8)
+	QPatternist__TypeUnsignedInt        = QPatternist__TypeOfDerivedInteger(9)
+	QPatternist__TypeUnsignedLong       = QPatternist__TypeOfDerivedInteger(10)
+	QPatternist__TypeUnsignedShort      = QPatternist__TypeOfDerivedInteger(11)
+)
+
+//QPatternist::TypeOfDerivedString
+type QPatternist__TypeOfDerivedString int64
+
+const (
+	QPatternist__TypeString           = QPatternist__TypeOfDerivedString(0)
+	QPatternist__TypeNormalizedString = QPatternist__TypeOfDerivedString(1)
+	QPatternist__TypeToken            = QPatternist__TypeOfDerivedString(2)
+	QPatternist__TypeLanguage         = QPatternist__TypeOfDerivedString(3)
+	QPatternist__TypeNMTOKEN          = QPatternist__TypeOfDerivedString(4)
+	QPatternist__TypeName             = QPatternist__TypeOfDerivedString(5)
+	QPatternist__TypeNCName           = QPatternist__TypeOfDerivedString(6)
+	QPatternist__TypeID               = QPatternist__TypeOfDerivedString(7)
+	QPatternist__TypeIDREF            = QPatternist__TypeOfDerivedString(8)
+	QPatternist__TypeENTITY           = QPatternist__TypeOfDerivedString(9)
+)
+
+type QPatternist struct {
+	ptr unsafe.Pointer
+}
+
+type QPatternist_ITF interface {
+	QPatternist_PTR() *QPatternist
+}
+
+func (p *QPatternist) QPatternist_PTR() *QPatternist {
+	return p
+}
+
+func (p *QPatternist) Pointer() unsafe.Pointer {
+	if p != nil {
+		return p.ptr
+	}
+	return nil
+}
+
+func (p *QPatternist) SetPointer(ptr unsafe.Pointer) {
+	if p != nil {
+		p.ptr = ptr
+	}
+}
+
+func PointerFromQPatternist(ptr QPatternist_ITF) unsafe.Pointer {
+	if ptr != nil {
+		return ptr.QPatternist_PTR().Pointer()
+	}
+	return nil
+}
+
+func NewQPatternistFromPointer(ptr unsafe.Pointer) *QPatternist {
+	var n = new(QPatternist)
+	n.SetPointer(ptr)
+	return n
+}
+
+func (ptr *QPatternist) DestroyQPatternist() {
+	C.free(ptr.Pointer())
+	ptr.SetPointer(nil)
+}
+
 type QSimpleXmlNodeModel struct {
 	QAbstractXmlNodeModel
 }
@@ -1928,6 +2015,32 @@ func (ptr *QSimpleXmlNodeModel) NamePool() *QXmlNamePool {
 	return nil
 }
 
+func (ptr *QSimpleXmlNodeModel) NamespaceBindings(node QXmlNodeModelIndex_ITF) []*QXmlName {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtXmlPatterns_PackedList) []*QXmlName {
+			var out = make([]*QXmlName, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQSimpleXmlNodeModelFromPointer(l.data).namespaceBindings_atList(i)
+			}
+			return out
+		}(C.QSimpleXmlNodeModel_NamespaceBindings(ptr.Pointer(), PointerFromQXmlNodeModelIndex(node)))
+	}
+	return nil
+}
+
+func (ptr *QSimpleXmlNodeModel) NodesByIdref(idref QXmlName_ITF) []*QXmlNodeModelIndex {
+	if ptr.Pointer() != nil {
+		return func(l C.struct_QtXmlPatterns_PackedList) []*QXmlNodeModelIndex {
+			var out = make([]*QXmlNodeModelIndex, int(l.len))
+			for i := 0; i < int(l.len); i++ {
+				out[i] = NewQSimpleXmlNodeModelFromPointer(l.data).nodesByIdref_atList(i)
+			}
+			return out
+		}(C.QSimpleXmlNodeModel_NodesByIdref(ptr.Pointer(), PointerFromQXmlName(idref)))
+	}
+	return nil
+}
+
 //export callbackQSimpleXmlNodeModel_StringValue
 func callbackQSimpleXmlNodeModel_StringValue(ptr unsafe.Pointer, node unsafe.Pointer) *C.char {
 
@@ -3262,6 +3375,15 @@ func (ptr *QXmlNodeModelIndex) Model() *QAbstractXmlNodeModel {
 	return nil
 }
 
+func (ptr *QXmlNodeModelIndex) namespaceBindings_atList(i int) *QXmlName {
+	if ptr.Pointer() != nil {
+		var tmpValue = NewQXmlNameFromPointer(C.QXmlNodeModelIndex_namespaceBindings_atList(ptr.Pointer(), C.int(int32(i))))
+		runtime.SetFinalizer(tmpValue, (*QXmlName).DestroyQXmlName)
+		return tmpValue
+	}
+	return nil
+}
+
 //QXmlQuery::QueryLanguage
 type QXmlQuery__QueryLanguage int64
 

xmlpatterns/xmlpatterns.h

@@ -94,6 +94,8 @@ void* QSimpleXmlNodeModel_BaseUriDefault(void* ptr, void* node);
 void* QSimpleXmlNodeModel_ElementById(void* ptr, void* id);
 void* QSimpleXmlNodeModel_ElementByIdDefault(void* ptr, void* id);
 void* QSimpleXmlNodeModel_NamePool(void* ptr);
+struct QtXmlPatterns_PackedList QSimpleXmlNodeModel_NamespaceBindings(void* ptr, void* node);
+struct QtXmlPatterns_PackedList QSimpleXmlNodeModel_NodesByIdref(void* ptr, void* idref);
 struct QtXmlPatterns_PackedString QSimpleXmlNodeModel_StringValue(void* ptr, void* node);
 struct QtXmlPatterns_PackedString QSimpleXmlNodeModel_StringValueDefault(void* ptr, void* node);
 void QSimpleXmlNodeModel_DestroyQSimpleXmlNodeModel(void* ptr);
@@ -181,6 +183,7 @@ long long QXmlNodeModelIndex_Data(void* ptr);
 void* QXmlNodeModelIndex_InternalPointer(void* ptr);
 char QXmlNodeModelIndex_IsNull(void* ptr);
 void* QXmlNodeModelIndex_Model(void* ptr);
+void* QXmlNodeModelIndex_namespaceBindings_atList(void* ptr, int i);
 void* QXmlQuery_NewQXmlQuery();
 void* QXmlQuery_NewQXmlQuery4(long long queryLanguage, void* np);
 void* QXmlQuery_NewQXmlQuery3(void* np);